public void ValidProps()
{
var moduleWeaver = new ValidModuleWeaver();
var moduleDefinition = ModuleDefinition.CreateModule("Foo", ModuleKind.Dll);
var assemblyResolver = new Mock<IAssemblyResolver>().Object;
var innerWeaver = new InnerWeaver
{
AssemblyPath = "AssemblyPath"
};
var moduleWeaverRunner = new WeaverInitialiser
{
ModuleDefinition = moduleDefinition,
Logger = new Mock<ILogger>().Object,
AssemblyResolver = assemblyResolver,
InnerWeaver = innerWeaver
};
var weaverEntry = new WeaverEntry {Element = "<foo/>"};
moduleWeaverRunner.SetProperties(weaverEntry, moduleWeaver);
Assert.IsNotNull(moduleWeaver.LogInfo);
Assert.IsNotNull(moduleWeaver.LogWarning);
Assert.IsNotNull(moduleWeaver.LogWarningPoint);
Assert.IsNotNull(moduleWeaver.LogError);
Assert.IsNotNull(moduleWeaver.LogErrorPoint);
Assert.AreEqual(moduleDefinition, moduleWeaver.ModuleDefinition);
Assert.AreEqual(assemblyResolver, moduleWeaver.AssemblyResolver);
Assert.AreEqual("AssemblyPath", moduleWeaver.AssemblyPath);
}
public virtual void SetProperties(WeaverEntry weaverEntry, object weaverInstance, WeaverDelegate @delegate)
{
if (weaverEntry.Element != null)
{
var weaverElement = XElement.Parse(weaverEntry.Element);
@delegate.SetConfig(weaverInstance, weaverElement);
}
@delegate.SetModuleDefinition(weaverInstance, ModuleDefinition);
@delegate.SetAssemblyResolver(weaverInstance, this);
@delegate.SetAssemblyFilePath(weaverInstance, AssemblyFilePath);
@delegate.SetAddinDirectoryPath(weaverInstance, Path.GetDirectoryName(weaverEntry.AssemblyPath));
@delegate.SetReferences(weaverInstance, References);
@delegate.SetReferenceCopyLocalPaths(weaverInstance, ReferenceCopyLocalPaths);
@delegate.SetSolutionDirectoryPath(weaverInstance, SolutionDirectoryPath);
@delegate.SetProjectDirectoryPath(weaverInstance, ProjectDirectoryPath);
@delegate.SetLogDebug(weaverInstance, s => Logger.LogDebug(" " + s));
@delegate.SetLogInfo(weaverInstance, s => Logger.LogInfo(" " + s));
@delegate.SetLogMessage(weaverInstance, (s, importance) => Logger.LogMessage(" " + s, importance));
@delegate.SetLogWarning(weaverInstance, Logger.LogWarning);
@delegate.SetLogWarningPoint(weaverInstance, LogWarningPoint);
@delegate.SetLogError(weaverInstance, Logger.LogError);
@delegate.SetLogErrorPoint(weaverInstance, LogErrorPoint);
@delegate.SetDefineConstants(weaverInstance, DefineConstants);
}
public void ReadProjectWeavers()
{
if (Weavers != null)
{
return;
}
Weavers = new List<WeaverEntry>();
foreach (var configFile in ConfigFiles)
{
var xDocument = GetDocument(configFile);
foreach (var element in xDocument.Root.Elements())
{
var assemblyName = element.Name.LocalName;
var existing = Weavers.FirstOrDefault(x => x.AssemblyName == assemblyName);
var index = Weavers.Count;
if (existing != null)
{
index = Weavers.IndexOf(existing);
Weavers.Remove(existing);
}
var weaverEntry = new WeaverEntry
{
Element = element.ToString(SaveOptions.OmitDuplicateNamespaces),
AssemblyName = assemblyName
};
Weavers.Insert(index, weaverEntry);
}
}
}
public void ValidProps()
{
var moduleDefinition = ModuleDefinition.CreateModule("Foo", ModuleKind.Dll);
var innerWeaver = new InnerWeaver
{
AssemblyFilePath = "AssemblyFilePath",
SolutionDirectoryPath = "SolutionDirectoryPath",
ReferenceDictionary = new Dictionary<string, string> { { "Ref1;Ref2","Path1" } },
ModuleDefinition = moduleDefinition,
};
var weaverEntry = new WeaverEntry
{
Element = "<foo/>",
AssemblyPath = @"c:\FakePath\Assembly.dll"
};
var moduleWeaver = new ValidModuleWeaver();
innerWeaver.SetProperties(weaverEntry, moduleWeaver);
Assert.IsNotNull(moduleWeaver.LogInfo);
Assert.IsNotNull(moduleWeaver.LogWarning);
Assert.IsNotNull(moduleWeaver.LogWarningPoint);
Assert.IsNotNull(moduleWeaver.LogError);
Assert.IsNotNull(moduleWeaver.LogErrorPoint);
// Assert.IsNotEmpty(moduleWeaver.References);
Assert.AreEqual(moduleDefinition, moduleWeaver.ModuleDefinition);
Assert.AreEqual(innerWeaver, moduleWeaver.AssemblyResolver);
Assert.AreEqual(@"c:\FakePath",moduleWeaver.AddinDirectoryPath);
Assert.AreEqual("AssemblyFilePath", moduleWeaver.AssemblyFilePath);
Assert.AreEqual("SolutionDirectoryPath", moduleWeaver.SolutionDirectoryPath);
}
public void SetProperties(WeaverEntry weaverEntry)
{
Logger.LogInfo(string.Format("Loading weaver '{0}'.", weaverEntry.AssemblyPath));
var assembly = LoadAssembly(weaverEntry.AssemblyPath);
var weaverType = assembly.FindType(weaverEntry.TypeName);
var weaverInstance = weaverType.ConstructInstance();
SetProperties(weaverEntry, weaverInstance);
WeaverInstances.Add(weaverInstance);
}
public void SetProperties(WeaverEntry weaverEntry, object weaverInstance)
{
if (weaverEntry.Element != null)
{
var weaverElement = XElement.Parse(weaverEntry.Element);
SetConfig(weaverInstance, weaverElement);
}
SetModule(weaverInstance);
SetAssemblyResolver(weaverInstance);
SetAssemblyPath(weaverInstance);
SetLogInfo(weaverInstance);
SetLogWarning(weaverInstance);
SetLogWarningPoint(weaverInstance);
SetLogError(weaverInstance);
SetLogErrorPoint(weaverInstance);
}
public void ValidProps()
{
var moduleDefinition = ModuleDefinition.CreateModule("Foo", ModuleKind.Dll);
var innerWeaver = new InnerWeaver
{
Logger = new Mock<ILogger>().Object,
AssemblyFilePath = "AssemblyFilePath",
ProjectDirectoryPath = "ProjectDirectoryPath",
SolutionDirectoryPath = "SolutionDirectoryPath",
ReferenceDictionary = new Dictionary<string, string> {{"Ref1;Ref2", "Path1"}},
ReferenceCopyLocalPaths = new List<string> {"CopyRef1","CopyRef2"},
References ="Ref1;Ref2",
ModuleDefinition = moduleDefinition,
DefineConstants = new List<string>{"Debug", "Release"}
};
var weaverEntry = new WeaverEntry
{
Element = "<foo/>",
AssemblyPath = @"c:\FakePath\Assembly.dll"
};
var moduleWeaver = new ValidModuleWeaver();
innerWeaver.SetProperties(weaverEntry, moduleWeaver, (typeof(ValidModuleWeaver)).BuildDelegateHolder());
Assert.IsNotNull(moduleWeaver.LogDebug);
Assert.IsNotNull(moduleWeaver.LogInfo);
Assert.IsNotNull(moduleWeaver.LogWarning);
Assert.IsNotNull(moduleWeaver.LogWarningPoint);
Assert.IsNotNull(moduleWeaver.LogError);
Assert.IsNotNull(moduleWeaver.LogErrorPoint);
Assert.IsNotNull(moduleWeaver.LogMessage);
Assert.AreEqual("Ref1;Ref2", moduleWeaver.References);
Assert.AreEqual("CopyRef1", moduleWeaver.ReferenceCopyLocalPaths[0]);
Assert.AreEqual("CopyRef2", moduleWeaver.ReferenceCopyLocalPaths[1]);
Assert.AreEqual("Debug", moduleWeaver.DefineConstants[0]);
Assert.AreEqual("Release", moduleWeaver.DefineConstants[1]);
// Assert.IsNotEmpty(moduleWeaver.References);
Assert.AreEqual(moduleDefinition, moduleWeaver.ModuleDefinition);
Assert.AreEqual(innerWeaver, moduleWeaver.AssemblyResolver);
Assert.AreEqual(@"c:\FakePath", moduleWeaver.AddinDirectoryPath);
Assert.AreEqual("AssemblyFilePath", moduleWeaver.AssemblyFilePath);
Assert.AreEqual("ProjectDirectoryPath", moduleWeaver.ProjectDirectoryPath);
Assert.AreEqual("SolutionDirectoryPath", moduleWeaver.SolutionDirectoryPath);
}
public void CustomWeaverInWeaversProject()
{
var mock = new Mock<Processor>();
mock.Setup(x => x.WeaverProjectContainsType("CustomWeaver"))
.Returns(true);
var processor = mock.Object;
processor.WeaverAssemblyPath = "Path";
var weaverConfig = new WeaverEntry
{
AssemblyName = "CustomWeaver"
};
processor.ProcessConfig(weaverConfig);
Assert.AreEqual("CustomWeaver", weaverConfig.TypeName);
Assert.AreEqual("Path",weaverConfig.AssemblyPath);
}
public void SetProperties(WeaverEntry weaverEntry, object weaverInstance)
{
if (weaverEntry.Element != null)
{
var weaverElement = XElement.Parse(weaverEntry.Element);
weaverInstance.SetProperty("Config",weaverElement);
}
var type = weaverInstance.GetType();
SetModule(weaverInstance, type);
weaverInstance.SetProperty("AssemblyResolver", AssemblyResolver);
weaverInstance.SetProperty("AssemblyPath", InnerWeaver.AssemblyPath);
weaverInstance.SetProperty("LogInfo", new Action<string>(s => Logger.LogInfo(s)));
weaverInstance.SetProperty("LogWarning", new Action<string>(s => Logger.LogWarning(s)));
weaverInstance.SetProperty("LogWarningPoint", new Action<string, SequencePoint>(LogWarningPoint));
weaverInstance.SetProperty("LogError", new Action<string>(s => Logger.LogError(s)));
weaverInstance.SetProperty("LogErrorPoint", new Action<string, SequencePoint>(LogErrorPoint));
}
public void ProcessConfig(WeaverEntry weaverConfig)
{
//support for diff names weavers when "In solution weaving"
var weaverProjectContains = WeaverProjectContainsType(weaverConfig.AssemblyName);
if (weaverProjectContains)
{
weaverConfig.AssemblyPath = WeaverAssemblyPath;
weaverConfig.TypeName = weaverConfig.AssemblyName;
return;
}
var assemblyPath = FindAssemblyPath(weaverConfig.AssemblyName);
if (assemblyPath == null)
{
throw new WeavingException(string.Format("Could not find a weaver named '{0}'.", weaverConfig.AssemblyName));
}
weaverConfig.AssemblyPath = assemblyPath;
weaverConfig.TypeName = "ModuleWeaver";
}
public void Should_use_Custom_weaver_from_weaver_project_When_added_to_configured_weavers()
{
var mock = new Mock<Processor>();
mock.Setup(x => x.WeaverProjectContainsType("CustomWeaver"))
.Returns(true);
mock.CallBase = true;
var processor = mock.Object;
processor.WeaverAssemblyPath = "Path";
var weaverConfig = new WeaverEntry
{
AssemblyName = "CustomWeaver"
};
processor.ProcessConfig(weaverConfig);
Assert.AreEqual("CustomWeaver", weaverConfig.TypeName);
Assert.AreEqual("Path",weaverConfig.AssemblyPath);
}
public void WeaverInAddin()
{
var mock = new Mock<Processor>();
mock.Setup(x => x.WeaverProjectContainsType("AddinName"))
.Returns(false);
mock.Setup(x => x.FindAssemblyPath("AddinName")).Returns("Path");
var processor = mock.Object;
var weaverConfig = new WeaverEntry
{
AssemblyName = "AddinName"
};
processor.ProcessConfig(weaverConfig);
Assert.AreEqual("ModuleWeaver", weaverConfig.TypeName);
Assert.AreEqual("Path",weaverConfig.AssemblyPath);
mock.Verify();
}
public static IEnumerable <string> GetPackageReferenceValidationErrors(WeaverEntry weaver)
{
if (!weaver.HasPackageReference)
{
yield break;
}
if (!string.Equals(weaver.PrivateAssets, "All", StringComparison.OrdinalIgnoreCase))
{
yield return($"The package reference for {weaver.WeaverName} does not contain PrivateAssets='All'");
}
if (weaver.IncludeAssets != string.Empty &&
!string.Equals(weaver.IncludeAssets, "All", StringComparison.OrdinalIgnoreCase) &&
!weaver.IncludeAssets !.Split(';').Select(item => item.Trim()).Contains("compile", StringComparer.OrdinalIgnoreCase))
{
yield return($"The package reference for {weaver.WeaverName} is missing the 'compile' part in the IncludeAssets setting; it's recommended to completely remove IncludeAssets");
}
}
public void SetProperties(WeaverEntry weaverEntry, object weaverInstance)
{
if (weaverEntry.Element != null)
{
var weaverElement = XElement.Parse(weaverEntry.Element);
weaverInstance.SetProperty("Config",weaverElement);
}
var type = weaverInstance.GetType();
SetModule(weaverInstance, type);
weaverInstance.SetProperty("AssemblyResolver", (IAssemblyResolver)this);
// weaverInstance.SetProperty("References", SplitReferences);
weaverInstance.SetProperty("AssemblyFilePath", AssemblyFilePath);
weaverInstance.SetProperty("AddinDirectoryPath", Path.GetDirectoryName(weaverEntry.AssemblyPath));
weaverInstance.SetProperty("SolutionDirectoryPath", SolutionDirectoryPath);
weaverInstance.SetProperty("LogInfo", new Action<string>(s => Logger.LogInfo(s)));
weaverInstance.SetProperty("LogWarning", new Action<string>(s => Logger.LogWarning(s)));
weaverInstance.SetProperty("LogWarningPoint", new Action<string, SequencePoint>(LogWarningPoint));
weaverInstance.SetProperty("LogError", new Action<string>(s => Logger.LogError(s)));
weaverInstance.SetProperty("LogErrorPoint", new Action<string, SequencePoint>(LogErrorPoint));
}
public void Should_use_named_weaver_When_added_to_configured_weavers()
{
var mock = new Mock<Processor>();
mock.Setup(x => x.WeaverProjectContainsType("AddinName"))
.Returns(false);
mock.Setup(x => x.FindAssemblyPath("AddinName")).Returns("Path");
mock.CallBase = true;
var processor = mock.Object;
var weaverConfig = new WeaverEntry
{
AssemblyName = "AddinName"
};
processor.ProcessConfig(weaverConfig);
Assert.AreEqual("ModuleWeaver", weaverConfig.TypeName);
Assert.AreEqual("Path",weaverConfig.AssemblyPath);
mock.Verify();
}
public void SetProperties(WeaverEntry weaverEntry, object weaverInstance, WeaverDelegate @delegate)
{
if (weaverEntry.Element != null)
{
var weaverElement = XElement.Parse(weaverEntry.Element);
@delegate.SetConfig(weaverInstance, weaverElement);
}
@delegate.SetModuleDefinition(weaverInstance, ModuleDefinition);
@delegate.SetAssemblyResolver(weaverInstance, this);
@delegate.SetAssemblyFilePath(weaverInstance, AssemblyFilePath);
@delegate.SetAddinDirectoryPath(weaverInstance, Path.GetDirectoryName(weaverEntry.AssemblyPath));
@delegate.SetReferenceCopyLocalPaths(weaverInstance, ReferenceCopyLocalPaths);
@delegate.SetSolutionDirectoryPath(weaverInstance, SolutionDirectoryPath);
@delegate.SetProjectDirectoryPath(weaverInstance, ProjectDirectoryPath);
@delegate.SetLogInfo(weaverInstance, Logger.LogInfo);
@delegate.SetLogWarning(weaverInstance, Logger.LogWarning);
@delegate.SetLogWarningPoint(weaverInstance, LogWarningPoint);
@delegate.SetLogError(weaverInstance, Logger.LogError);
@delegate.SetLogErrorPoint(weaverInstance, LogErrorPoint);
@delegate.SetDefineConstants(weaverInstance, DefineConstants);
}
public void ProcessConfig(WeaverEntry weaverConfig)
{
//support for diff names weavers when "In solution weaving"
var weaverProjectContains = WeaverProjectContainsType(weaverConfig.AssemblyName);
if (weaverProjectContains)
{
weaverConfig.AssemblyPath = WeaverAssemblyPath;
weaverConfig.TypeName = weaverConfig.AssemblyName;
return;
}
var assemblyPath = FindAssemblyPath(weaverConfig.AssemblyName);
if (assemblyPath == null)
{
var searchPaths = string.Join(Environment.NewLine, addinFinder.AddinSearchPaths);
var message = string.Format("Could not find a weaver named '{0}'. Tried:{1}{2}.", weaverConfig.AssemblyName, Environment.NewLine, searchPaths);
throw new WeavingException(message);
}
weaverConfig.AssemblyPath = assemblyPath;
weaverConfig.TypeName = "ModuleWeaver";
}
public void ValidPropsFromBase()
{
var moduleDefinition = ModuleDefinition.CreateModule("Foo", ModuleKind.Dll);
var resolver = new MockAssemblyResolver();
var innerWeaver = BuildInnerWeaver(moduleDefinition, resolver);
innerWeaver.SplitUpReferences();
var weaverEntry = new WeaverEntry
{
Element = "<foo/>",
AssemblyPath = @"c:\FakePath\Assembly.dll"
};
var moduleWeaver = new ValidFromBaseModuleWeaver();
innerWeaver.SetProperties(weaverEntry, moduleWeaver);
SerializerBuilder.IgnoreMembersWithType <ModuleDefinition>();
ObjectApprover.VerifyWithJson(moduleWeaver);
}
public void WeaverInAddin()
{
var mock = new Mock<Processor>();
mock.Setup(x => x.WeaverProjectContainsType("AddinName"))
.Returns(false);
mock.Setup(x => x.FindAssemblyPath("AddinName")).Returns("Path");
mock.CallBase = true;
var processor = mock.Object;
var weaverConfig = new WeaverEntry
{
AssemblyName = "AddinName"
};
processor.ProcessConfig(weaverConfig);
Assert.AreEqual("ModuleWeaver", weaverConfig.TypeName);
Assert.AreEqual("Path",weaverConfig.AssemblyPath);
mock.Verify();
}
public void ValidProps()
{
var moduleDefinition = ModuleDefinition.CreateModule("Foo", ModuleKind.Dll);
var resolver = new MockAssemblyResolver();
var innerWeaver = BuildInnerWeaver(moduleDefinition, resolver);
innerWeaver.SplitUpReferences();
var weaverEntry = new WeaverEntry
{
Element = "<foo/>",
AssemblyPath = @"c:\FakePath\Assembly.dll"
};
var moduleWeaver = new ValidModuleWeaver();
innerWeaver.SetProperties(weaverEntry, moduleWeaver, typeof(ValidModuleWeaver).BuildDelegateHolder());
ValidateProps(moduleWeaver, moduleDefinition);
Assert.Equal(resolver, moduleWeaver.AssemblyResolver);
}
WeaverHolder InitialiseWeaver(WeaverEntry weaverConfig)
{
Logger.LogDebug($"Weaver '{weaverConfig.AssemblyPath}'.");
Logger.LogDebug(" Initializing weaver");
var assembly = LoadWeaverAssembly(weaverConfig.AssemblyPath);
var weaverType = assembly.FindType(weaverConfig.TypeName);
var delegateHolder = weaverType.GetDelegateHolderFromCache();
var weaverInstance = delegateHolder();
var weaverHolder = new WeaverHolder(weaverInstance, weaverConfig);
if (FodyVersion.WeaverRequiresUpdate(assembly, out var referencedVersion))
{
Logger.LogWarning($"Weavers should reference at least the current major version of Fody (version {FodyVersion.Major}). The weaver in {assembly.GetName().Name} references version {referencedVersion}. This may result in incompatibilities at build time such as MissingMethodException being thrown.", "FodyVersionMismatch");
weaverHolder.IsUsingOldFodyVersion = true;
}
weaverHolder.FodyVersion = referencedVersion;
SetProperties(weaverConfig, weaverInstance);
return(weaverHolder);
}
public void Should_use_Custom_weaver_from_weaver_project_When_added_to_configured_weavers()
{
var mock = new Mock <Processor>();
mock.Setup(x => x.WeaverProjectContainsType("CustomWeaver"))
.Returns(true);
mock.CallBase = true;
var processor = mock.Object;
processor.WeaverAssemblyPath = "Path";
var weaverConfig = new WeaverEntry
{
AssemblyName = "CustomWeaver"
};
processor.ProcessConfig(weaverConfig);
Assert.Equal("CustomWeaver", weaverConfig.TypeName);
Assert.Equal("Path", weaverConfig.AssemblyPath);
}
public void ConfigureWhenNoWeaversFound()
{
if (!FoundWeaverProjectFile)
{
return;
}
if (WeaverProjectUsed)
{
return;
}
var weaverProjectContainsType = WeaverProjectContainsType("ModuleWeaver");
if (weaverProjectContainsType)
{
Logger.LogInfo("Found 'ModuleWeaver' in project 'Weavers' so will run that one.");
var weaverEntry = new WeaverEntry
{
AssemblyPath = WeaverAssemblyPath,
TypeName = "ModuleWeaver"
};
Weavers.Add(weaverEntry);
}
}
public void ConfigureWhenNoWeaversFound()
{
if (!FoundWeaverProjectFile)
{
return;
}
if (WeaverProjectUsed)
{
return;
}
var weaverProjectContainsType = WeaverProjectContainsType("ModuleWeaver");
if (weaverProjectContainsType)
{
Logger.LogInfo("Found 'ModuleWeaver' in project 'Weavers' so will run that one.");
var weaverEntry = new WeaverEntry
{
AssemblyPath = WeaverAssemblyPath,
TypeName = "ModuleWeaver"
};
Weavers.Add(weaverEntry);
}
}
public Task ValidPropsFromBase()
{
var moduleDefinition = ModuleDefinition.CreateModule("Foo", ModuleKind.Dll);
var resolver = new MockAssemblyResolver();
var innerWeaver = BuildInnerWeaver(moduleDefinition, resolver);
innerWeaver.SplitUpReferences();
var weaverEntry = new WeaverEntry
{
Element = "<foo/>",
AssemblyPath = @"c:\FakePath\Assembly.dll"
};
var moduleWeaver = new ValidFromBaseModuleWeaver();
innerWeaver.SetProperties(weaverEntry, moduleWeaver);
var verifySettings = new VerifySettings();
verifySettings.ModifySerialization(settings => { settings.IgnoreMembersWithType <ModuleDefinition>(); });
verifySettings.UniqueForRuntime();
return(Verify(moduleWeaver, verifySettings));
}
public void ProcessConfig(WeaverEntry weaverConfig)
{
//support for diff names weavers when "In solution weaving"
var weaverProjectContains = WeaverProjectContainsType(weaverConfig.AssemblyName);
if (weaverProjectContains)
{
weaverConfig.AssemblyPath = WeaverAssemblyPath;
weaverConfig.TypeName = weaverConfig.AssemblyName;
return;
}
var assemblyPath = FindAssemblyPath(weaverConfig.AssemblyName);
if (assemblyPath == null)
{
var searchPaths = string.Join(Environment.NewLine, addinFinder.AddinSearchPaths);
var message = string.Format("Could not find a weaver named '{0}'. Tried:{1}{2}.", weaverConfig.AssemblyName, Environment.NewLine, searchPaths);
throw new WeavingException(message);
}
weaverConfig.AssemblyPath = assemblyPath;
weaverConfig.TypeName = "ModuleWeaver";
}
public void ValidPropsFromBase()
{
var moduleDefinition = ModuleDefinition.CreateModule("Foo", ModuleKind.Dll);
var resolver = new MockAssemblyResolver();
var innerWeaver = BuildInnerWeaver(moduleDefinition, resolver);
innerWeaver.SplitUpReferences();
var weaverEntry = new WeaverEntry
{
Element = "<foo/>",
AssemblyPath = @"c:\FakePath\Assembly.dll"
};
var moduleWeaver = new ValidFromBaseModuleWeaver();
innerWeaver.SetProperties(weaverEntry, moduleWeaver);
ValidateProps(moduleWeaver, moduleDefinition);
Assert.NotNull(moduleWeaver.FindType);
Assert.NotNull(moduleWeaver.TryFindType);
Assert.NotNull(moduleWeaver.ResolveAssembly);
}
public void ProcessConfig(WeaverEntry weaverConfig)
{
//support for diff names weavers when "In solution weaving"
var weaverProjectContains = WeaverProjectContainsType(weaverConfig.AssemblyName);
if (weaverProjectContains)
{
weaverConfig.AssemblyPath = WeaverAssemblyPath;
weaverConfig.TypeName = weaverConfig.AssemblyName;
return;
}
var assemblyPath = FindAssemblyPath(weaverConfig.AssemblyName);
if (assemblyPath == null)
{
var message = string.Format(
@"Could not find a weaver named '{0}'.
If you have nuget package restore turned on you probably need to do a build to download the weavers.
Alternatively you may have added a weaver to your 'FodyWeavers.xml' and forgot to add the appropriate nuget package.
Perhaps you need to run 'Install-Package {0}.Fody'. This url may provide more information http://nuget.org/packages/{0}.Fody/ .", weaverConfig.AssemblyName);
throw new WeavingException(message);
}
weaverConfig.AssemblyPath = assemblyPath;
weaverConfig.TypeName = "ModuleWeaver";
}
public void ValidProps()
{
var moduleDefinition = ModuleDefinition.CreateModule("Foo", ModuleKind.Dll);
var resolver = new MockAssemblyResolver();
var innerWeaver = new InnerWeaver
{
Logger = new Mock <ILogger>().Object,
AssemblyFilePath = "AssemblyFilePath",
ProjectDirectoryPath = "ProjectDirectoryPath",
SolutionDirectoryPath = "SolutionDirectoryPath",
DocumentationFilePath = "DocumentationFilePath",
ReferenceDictionary = new Dictionary <string, string>
{
{ "Ref1;Ref2", "Path1" }
},
ReferenceCopyLocalPaths = new List <string>
{
"CopyRef1",
"CopyRef2"
},
References = "Ref1;Ref2",
ModuleDefinition = moduleDefinition,
DefineConstants = new List <string>
{
"Debug",
"Release"
},
assemblyResolver = resolver
};
var weaverEntry = new WeaverEntry
{
Element = "<foo/>",
AssemblyPath = @"c:\FakePath\Assembly.dll"
};
var moduleWeaver = new ValidModuleWeaver();
innerWeaver.SetProperties(weaverEntry, moduleWeaver, typeof(ValidModuleWeaver).BuildDelegateHolder());
Assert.IsNotNull(moduleWeaver.LogDebug);
Assert.IsNotNull(moduleWeaver.LogInfo);
Assert.IsNotNull(moduleWeaver.LogWarning);
Assert.IsNotNull(moduleWeaver.LogWarningPoint);
Assert.IsNotNull(moduleWeaver.LogError);
Assert.IsNotNull(moduleWeaver.LogErrorPoint);
Assert.IsNotNull(moduleWeaver.LogMessage);
Assert.AreEqual("Ref1;Ref2", moduleWeaver.References);
Assert.AreEqual("CopyRef1", moduleWeaver.ReferenceCopyLocalPaths[0]);
Assert.AreEqual("CopyRef2", moduleWeaver.ReferenceCopyLocalPaths[1]);
Assert.AreEqual("Debug", moduleWeaver.DefineConstants[0]);
Assert.AreEqual("Release", moduleWeaver.DefineConstants[1]);
// Assert.IsNotEmpty(moduleWeaver.References);
Assert.AreEqual(moduleDefinition, moduleWeaver.ModuleDefinition);
Assert.AreEqual(resolver, moduleWeaver.AssemblyResolver);
Assert.AreEqual(@"c:\FakePath", moduleWeaver.AddinDirectoryPath);
Assert.AreEqual("AssemblyFilePath", moduleWeaver.AssemblyFilePath);
Assert.AreEqual("ProjectDirectoryPath", moduleWeaver.ProjectDirectoryPath);
Assert.AreEqual("SolutionDirectoryPath", moduleWeaver.SolutionDirectoryPath);
Assert.AreEqual("DocumentationFilePath", moduleWeaver.DocumentationFilePath);
}
public void Configure(
IEnumerable <string> configurationSearchPaths,
IReadOnlyCollection <string> weaverSearchPaths)
{
const string assemblyNameSuffix = ".Fody.dll";
IReadOnlyList <XDocument> documents = configurationSearchPaths.SelectMany(
path => Directory.GetFiles(path, "FodyWeavers.xml", SearchOption.AllDirectories))
.Select(XDocument.Load)
.ToList();
IReadOnlyList <XElement> runnerElements = documents.SelectMany(
document => document.Root?.Elements(typeof(Runner).Namespace))
.ToList();
IEnumerable <XElement> weaverElements = documents
.SelectMany(document => document.Element("Weavers")?.Elements())
.Except(runnerElements);
IReadOnlyDictionary <string, string> weaverAssembliesPathsByName = weaverSearchPaths
.SelectMany(path => Directory.GetFiles(path, $"*{assemblyNameSuffix}", SearchOption.AllDirectories))
.GroupBy(
path =>
{
string fileName = Path.GetFileName(path);
return(fileName?.Remove(
fileName.Length - assemblyNameSuffix.Length,
assemblyNameSuffix.Length));
})
.ToDictionary(grouping => grouping.Key, grouping => grouping.FirstOrDefault());
_logForwarder.SetLogLevelFromConfiguration(runnerElements);
_weaverEntries.Clear();
foreach (XElement weaverElement in weaverElements)
{
string assemblyName = weaverElement.Name.LocalName;
if (!weaverAssembliesPathsByName.TryGetValue(assemblyName, out string assemblyPath))
{
_logForwarder.LogError(
$"A configuration lists '{assemblyName}' but the assembly file wasn't found"
+ $" in the search paths '{string.Join(", ", weaverSearchPaths)}'.");
continue;
}
WeaverEntry existingEntry = _weaverEntries.FirstOrDefault(entry => entry.AssemblyName == assemblyName);
int index = _weaverEntries.Count;
if (existingEntry != null)
{
_logForwarder.LogWarning(
$"There are multiple configurations for '{assemblyName}'. The configuration read last is used.");
index = _weaverEntries.IndexOf(existingEntry);
_weaverEntries.Remove(existingEntry);
}
WeaverEntry weaverEntry = new WeaverEntry
{
Element = weaverElement.ToString(SaveOptions.OmitDuplicateNamespaces),
AssemblyName = assemblyName,
AssemblyPath = assemblyPath,
TypeName = "ModuleWeaver"
};
_weaverEntries.Insert(index, weaverEntry);
}
const string assemblyNameRegexElementName = "AssemblyNameRegex";
IEnumerable <Regex> regexes = runnerElements
.SelectMany(element => element.Elements(assemblyNameRegexElementName))
.Select(element => new Regex(element.Value, RegexOptions.Compiled));
_assemblyRegexes.Clear();
_assemblyRegexes.AddRange(regexes);
if (runnerElements.Count > 0 && _assemblyRegexes.Count == 0)
{
_logForwarder.LogWarning(
$"No configuration uses an element '{assemblyNameRegexElementName}' inside the"
+ $" '{runnerElements.First().Name}' element. No assembly will be processed.");
}
}
static string GetWeaverName(WeaverEntry weaver)
{
return(string.IsNullOrEmpty(weaver.Element) ? weaver.TypeName : weaver.AssemblyName);
}
static List<WeaverEntry> InitializeWeavers(XDocument fodyConfig, IAssemblyResolver resolver)
{
var weavers = new List<WeaverEntry>();
if (fodyConfig != null)
{
foreach (var element in fodyConfig.Root.Elements())
{
var assemblyName = element.Name.LocalName + ".Fody";
var existing = weavers.FirstOrDefault(x => string.Equals(x.AssemblyName, assemblyName, StringComparison.OrdinalIgnoreCase));
var index = weavers.Count;
if (existing != null)
{
index = weavers.IndexOf(existing);
weavers.Remove(existing);
}
var weaverEntry = new WeaverEntry
{
Element = element.ToString(SaveOptions.None),
AssemblyName = assemblyName,
TypeName = "ModuleWeaver"
};
//Debug.LogFormat("Added weaver {0}", weaverEntry.AssemblyName);
weavers.Insert(index, weaverEntry);
}
foreach (var weaverConfig in weavers.ToArray())
{
if (weaverConfig.WeaverType != null) continue;
//determine the assembly path.
var weavePath = AssetDatabase.FindAssets(weaverConfig.AssemblyName).Select(w => AssetDatabase.GUIDToAssetPath(w)).FirstOrDefault(p => p.EndsWith(".dll"));
if (string.IsNullOrEmpty(weavePath))
{
//Debug.LogWarningFormat("Could not find weaver named {0}", weaverConfig.AssemblyName);
weavers.Remove(weaverConfig);
continue;
}
weaverConfig.AssemblyPath = weavePath;
//Debug.Log(string.Format("Weaver '{0}'.", weaverConfig.AssemblyPath));
var assembly = LoadAssembly(weaverConfig.AssemblyPath);
var weaverType = GetType(assembly, weaverConfig.TypeName);
if (weaverType == null)
{
weavers.Remove(weaverConfig);
continue;
}
weaverConfig.Activate(weaverType);
SetProperties(weaverConfig, resolver);
}
}
//add a project weaver
var projectWeavers = typeof(FodyAssemblyPostProcessor).Assembly.GetTypes().Where(t => t.Name.EndsWith("ModuleWeaver"));
foreach(var weaver in projectWeavers)
{
//Debug.LogFormat("Added project weaver {0}", weaver);
var entry = new WeaverEntry();
entry.Activate(weaver);
SetProperties(entry,resolver);
weavers.Add(entry);
}
Debug.LogFormat("Fody processor running for weavers {0}", string.Join("; ", weavers.Select(w => w.PrettyName()).ToArray()));
return weavers;
}
static List <WeaverEntry> InitializeWeavers(XDocument fodyConfig, IAssemblyResolver resolver)
{
var weavers = new List <WeaverEntry>();
if (fodyConfig != null)
{
foreach (var element in fodyConfig.Root.Elements())
{
var assemblyName = element.Name.LocalName + ".Fody";
var existing = weavers.FirstOrDefault(x => string.Equals(x.AssemblyName, assemblyName, StringComparison.OrdinalIgnoreCase));
var index = weavers.Count;
if (existing != null)
{
index = weavers.IndexOf(existing);
weavers.Remove(existing);
}
var weaverEntry = new WeaverEntry
{
Element = element.ToString(SaveOptions.None),
AssemblyName = assemblyName,
TypeName = "ModuleWeaver"
};
//Debug.LogFormat("Added weaver {0}", weaverEntry.AssemblyName);
weavers.Insert(index, weaverEntry);
}
foreach (var weaverConfig in weavers.ToArray())
{
if (weaverConfig.WeaverType != null)
{
continue;
}
//determine the assembly path.
var weavePath = AssetDatabase.FindAssets(weaverConfig.AssemblyName).Select(w => AssetDatabase.GUIDToAssetPath(w)).FirstOrDefault(p => p.EndsWith(".dll"));
if (string.IsNullOrEmpty(weavePath))
{
//Debug.LogWarningFormat("Could not find weaver named {0}", weaverConfig.AssemblyName);
weavers.Remove(weaverConfig);
continue;
}
weaverConfig.AssemblyPath = weavePath;
//Debug.Log(string.Format("Weaver '{0}'.", weaverConfig.AssemblyPath));
var assembly = LoadAssembly(weaverConfig.AssemblyPath);
var weaverType = GetType(assembly, weaverConfig.TypeName);
if (weaverType == null)
{
weavers.Remove(weaverConfig);
continue;
}
weaverConfig.Activate(weaverType);
SetProperties(weaverConfig, resolver);
}
}
//add a project weaver
var projectWeavers = typeof(FodyAssemblyPostProcessor).Assembly.GetTypes().Where(t => t.Name.EndsWith("ModuleWeaver"));
foreach (var weaver in projectWeavers)
{
//Debug.LogFormat("Added project weaver {0}", weaver);
var entry = new WeaverEntry();
entry.Activate(weaver);
SetProperties(entry, resolver);
weavers.Add(entry);
}
//Debug.LogFormat("Fody processor running for weavers {0}", string.Join("; ", weavers.Select(w => w.PrettyName()).ToArray()));
return(weavers);
}
private static void SetProperties(WeaverEntry weaverEntry, IAssemblyResolver resolver)
{
if (weaverEntry.WeaverInstance == null) return;
if (weaverEntry.Element != null)
{
var weaverElement = XElement.Parse(weaverEntry.Element);
weaverEntry.TrySetProperty("Config", weaverElement);
}
weaverEntry.TrySetProperty("AssemblyResolver", resolver);
weaverEntry.TryAddEvent("LogDebug", new Action<string>((str) => Debug.Log(str)));
weaverEntry.TryAddEvent("LogInfo", new Action<string>((str) => Debug.Log(str)));
weaverEntry.TryAddEvent("LogWarning", new Action<string>((str) => Debug.LogWarning(str)));
}
