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 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 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))); }