Refactor StaticAnalysis to use Tools.Common

Author: cormacpayne

tools/StaticAnalysis/BreakingChangeAnalyzer/BreakingChangeAnalyzer.cs

@@ -23,6 +23,11 @@
 using System.Runtime.Serialization.Formatters.Binary;
 using System.Threading.Tasks;
 using System.Xml.Serialization;
+using Tools.Common.Helpers;
+using Tools.Common.Issues;
+using Tools.Common.Loaders;
+using Tools.Common.Loggers;
+using Tools.Common.Models;
 
 namespace StaticAnalysis.BreakingChangeAnalyzer
 {
@@ -41,7 +46,7 @@ public BreakingChangeAnalyzer()
         }
 
         /// <summary>
-        /// Given a set of directory paths containing PowerShell module folders, 
+        /// Given a set of directory paths containing PowerShell module folders,
         /// analyze the breaking changes in the modules and report any issues
         /// </summary>
         /// <param name="cmdletProbingDirs">Set of directory paths containing PowerShell module folders to be checked for breaking changes.</param>
@@ -53,7 +58,7 @@ public void Analyze(IEnumerable<string> cmdletProbingDirs)
         /// <summary>
         /// Given a set of directory paths containing PowerShell module folders,
         /// analyze the breaking changes in the modules and report any issues
-        /// 
+        ///
         /// Filters can be added to find breaking changes for specific modules
         /// </summary>
         /// <param name="cmdletProbingDirs">Set of directory paths containing PowerShell module folders to be checked for breaking changes.</param>
@@ -73,7 +78,7 @@ public void Analyze(
                 cmdletProbingDirs = directoryFilter(cmdletProbingDirs);
             }
 
-            foreach (var baseDirectory in cmdletProbingDirs.Where(s => !s.Contains("ServiceManagement") && 
+            foreach (var baseDirectory in cmdletProbingDirs.Where(s => !s.Contains("ServiceManagement") &&
                                                                         !s.Contains("Stack") && Directory.Exists(Path.GetFullPath(s))))
             {
                 List<string> probingDirectories = new List<string>();
@@ -99,34 +104,44 @@ public void Analyze(
                     }
 
                     var psd1 = manifestFiles.FirstOrDefault();
-
-                    var parentDirectory = Directory.GetParent(psd1);
+                    var parentDirectory = Directory.GetParent(psd1).FullName;
                     var psd1FileName = Path.GetFileName(psd1);
-
+                    IEnumerable<string> nestedModules = null;
+                    List<string> requiredModules = null;
                     PowerShell powershell = PowerShell.Create();
-                    powershell.AddScript("Import-LocalizedData -BaseDirectory " + parentDirectory + 
-                                        " -FileName " + psd1FileName + 
-                                        " -BindingVariable ModuleMetadata; $ModuleMetadata.NestedModules");
-
+                    powershell.AddScript("Import-LocalizedData -BaseDirectory " + parentDirectory +
+                                         " -FileName " + psd1FileName +
+                                         " -BindingVariable ModuleMetadata; $ModuleMetadata.NestedModules; $ModuleMetadata.RequiredModules | % { $_[\"ModuleName\"] };");
                     var cmdletResult = powershell.Invoke();
-                    var cmdletFiles = cmdletResult.Select(c => c.ToString().Substring(2));
+                    nestedModules = cmdletResult.Where(c => c.ToString().StartsWith(".")).Select(c => c.ToString().Substring(2));
+                    requiredModules = cmdletResult.Where(c => !c.ToString().StartsWith(".")).Select(c => c.ToString()).ToList();
 
-                    if (cmdletFiles.Any())
+                    if (nestedModules.Any())
                     {
-                        foreach (var cmdletFileName in cmdletFiles)
+                        Directory.SetCurrentDirectory(directory);
+
+                        requiredModules = requiredModules.Join(cmdletProbingDirs,
+                                                               module => 1,
+                                                               dir => 1,
+                                                               (module, dir) => Path.Combine(dir, module))
+                                                          .Where(f => Directory.Exists(f))
+                                                          .ToList();
+
+                        requiredModules.Add(directory);
+
+                        foreach (var nestedModule in nestedModules)
                         {
-                            var cmdletFileFullPath = Path.Combine(directory, Path.GetFileName(cmdletFileName));
-                            
-                            if (File.Exists(cmdletFileFullPath))
+                            var assemblyFile = Directory.GetFiles(parentDirectory, nestedModule, SearchOption.AllDirectories).FirstOrDefault();
+                            var assemblyFileName = Path.GetFileName(assemblyFile);
+                            if (File.Exists(assemblyFile))
                             {
-                                issueLogger.Decorator.AddDecorator(a => a.AssemblyFileName = cmdletFileFullPath, "AssemblyFileName");
-                                processedHelpFiles.Add(cmdletFileName);
-                                var proxy = 
-                                    EnvironmentHelpers.CreateProxy<CmdletBreakingChangeLoader>(directory, out _appDomain);
-                                var newModuleMetadata = proxy.GetModuleMetadata(cmdletFileFullPath);
-
-                                string fileName = cmdletFileName + ".json";
-                                string executingPath = 
+                                issueLogger.Decorator.AddDecorator(a => a.AssemblyFileName = assemblyFileName, "AssemblyFileName");
+                                processedHelpFiles.Add(assemblyFileName);
+                                var proxy = EnvironmentHelpers.CreateProxy<CmdletLoader>(directory, out _appDomain);
+                                var newModuleMetadata = proxy.GetModuleMetadata(assemblyFile, requiredModules);
+
+                                string fileName = assemblyFileName + ".json";
+                                string executingPath =
                                     Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).AbsolutePath);
 
                                 string filePath = executingPath + "\\SerializedCmdlets\\" + fileName;
@@ -150,7 +165,7 @@ public void Analyze(
                                         string output = string.Format("Before filter\nOld module cmdlet count: {0}\nNew module cmdlet count: {1}",
                                             oldModuleMetadata.Cmdlets.Count, newModuleMetadata.Cmdlets.Count);
 
-                                        output += string.Format("\nCmdlet file: {0}", cmdletFileFullPath);
+                                        output += string.Format("\nCmdlet file: {0}", assemblyFileName);
 
                                         oldModuleMetadata.FilterCmdlets(cmdletFilter);
                                         newModuleMetadata.FilterCmdlets(cmdletFilter);
@@ -173,6 +188,8 @@ public void Analyze(
 
                                     RunBreakingChangeChecks(oldModuleMetadata, newModuleMetadata, issueLogger);
                                 }
+
+                                AppDomain.Unload(_appDomain);
                             }
                         }
                     }
@@ -249,7 +266,7 @@ public AnalysisReport GetAnalysisReport()
     public static class LogExtensions
     {
         public static void LogBreakingChangeIssue(
-            this ReportLogger<BreakingChangeIssue> issueLogger, CmdletBreakingChangeMetadata cmdlet,
+            this ReportLogger<BreakingChangeIssue> issueLogger, CmdletMetadata cmdlet,
             string description, string remediation, int severity, int problemId)
         {
             issueLogger.LogRecord(new BreakingChangeIssue

tools/StaticAnalysis/BreakingChangeAnalyzer/BreakingChangeIssue.cs

@@ -14,6 +14,7 @@
 
 using System;
 using System.Text.RegularExpressions;
+using Tools.Common.Issues;
 
 namespace StaticAnalysis.BreakingChangeAnalyzer
 {

tools/StaticAnalysis/BreakingChangeAnalyzer/CmdletBreakingChangeMetadata.cs

@@ -15,14 +15,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Text.RegularExpressions;
-using System.Threading.Tasks;
+using Tools.Common.Loggers;
+using Tools.Common.Models;
 
 namespace StaticAnalysis.BreakingChangeAnalyzer
 {
     /// <summary>
-    /// This class is responsible for comparing CmdletBreakingChangeMetadata and
+    /// This class is responsible for comparing CmdletMetadata and
     /// checking for breaking changes between old (serialized) metadata and new metadata.
     /// </summary>
     public class CmdletMetadataHelper
@@ -47,29 +47,29 @@ public CmdletMetadataHelper(TypeMetadataHelper typeMetadataHelper)
 
         /// <summary>
         /// Compares the metadata of cmdlets with the same name (or alias) for any breaking changes.
-        /// 
+        ///
         /// Breaking changes for cmdlets include
         ///   - Removing a cmdlet
         ///   - Removing an alias to a cmdlet
         ///   - Removing SupportsShouldProcess
         ///   - Removing SupportsPaging
         ///   - Output type (or any of its properties) of cmdlet has changed
         ///   - Default parameter set has changed
-        ///   
+        ///
         /// This method will also check for breaking changes in the cmdlets' parameters and
         /// parameter sets using the appropriate helpers.
         /// </summary>
         /// <param name="oldCmdlets">The list of cmdlets from the old (serialized) metadata.</param>
         /// <param name="newCmdlets">The list of cmdlets from the new metadata.</param>
         /// <param name="issueLogger">ReportLogger that will keep track of issues found.</param>
         public void CompareCmdletMetadata(
-            List<CmdletBreakingChangeMetadata> oldCmdlets,
-            List<CmdletBreakingChangeMetadata> newCmdlets,
+            List<CmdletMetadata> oldCmdlets,
+            List<CmdletMetadata> newCmdlets,
             ReportLogger<BreakingChangeIssue> issueLogger)
         {
             // This dictionary will map a cmdlet name (or alias) to the corresponding metadata
-            Dictionary<string, CmdletBreakingChangeMetadata> cmdletDictionary =
-                new Dictionary<string, CmdletBreakingChangeMetadata>();
+            Dictionary<string, CmdletMetadata> cmdletDictionary =
+                new Dictionary<string, CmdletMetadata>();
 
             // Add each cmdlet and its aliases to the dictionary
             foreach (var newCmdlet in newCmdlets)
@@ -125,8 +125,8 @@ public void CompareCmdletMetadata(
         /// <param name="newCmdlet">The cmdlet metadata from the new assembly.</param>
         /// <param name="issueLogger">ReportLogger that will keep track of issues found.</param>
         private void CheckForRemovedCmdletAlias(
-            CmdletBreakingChangeMetadata oldCmdlet,
-            CmdletBreakingChangeMetadata newCmdlet,
+            CmdletMetadata oldCmdlet,
+            CmdletMetadata newCmdlet,
             ReportLogger<BreakingChangeIssue> issueLogger)
         {
             // This set will contain all of the aliases in the new metadata
@@ -164,8 +164,8 @@ private void CheckForRemovedCmdletAlias(
         /// <param name="newCmdlet">The cmdlet metadata from the new assembly.</param>
         /// <param name="issueLogger">ReportLogger that will keep track of issues found.</param>
         private void CheckForRemovedSupportsShouldProcess(
-            CmdletBreakingChangeMetadata oldCmdlet,
-            CmdletBreakingChangeMetadata newCmdlet,
+            CmdletMetadata oldCmdlet,
+            CmdletMetadata newCmdlet,
             ReportLogger<BreakingChangeIssue> issueLogger)
         {
             // If the old cmdlet implements SupportsShouldProcess and the new cmdlet does not, log an issue
@@ -187,8 +187,8 @@ private void CheckForRemovedSupportsShouldProcess(
         /// <param name="newCmdlet">The cmdlet metadata from the new assembly.</param>
         /// <param name="issueLogger">ReportLogger that will keep track of issues found.</param>
         private void CheckForRemovedSupportsPaging(
-            CmdletBreakingChangeMetadata oldCmdlet,
-            CmdletBreakingChangeMetadata newCmdlet,
+            CmdletMetadata oldCmdlet,
+            CmdletMetadata newCmdlet,
             ReportLogger<BreakingChangeIssue> issueLogger)
         {
             // If the old cmdlet implements SupportsPaging and the new cmdlet does not, log an issue
@@ -211,8 +211,8 @@ private void CheckForRemovedSupportsPaging(
         /// <param name="newCmdlet">The cmdlet metadata from the new assembly.</param>
         /// <param name="issueLogger">ReportLogger that will keep track of issues found.</param>
         private void CheckForChangedOutputType(
-            CmdletBreakingChangeMetadata oldCmdlet,
-            CmdletBreakingChangeMetadata newCmdlet,
+            CmdletMetadata oldCmdlet,
+            CmdletMetadata newCmdlet,
             ReportLogger<BreakingChangeIssue> issueLogger)
         {
             // This dictionary will map an output type name to the corresponding type metadata
@@ -262,8 +262,8 @@ private void CheckForChangedOutputType(
         /// <param name="newCmdlet">The cmdlet metadata from the new assembly.</param>
         /// <param name="issueLogger">ReportLogger that will keep track of issues found.</param>
         private void CheckDefaultParameterName(
-            CmdletBreakingChangeMetadata oldCmdlet,
-            CmdletBreakingChangeMetadata newCmdlet,
+            CmdletMetadata oldCmdlet,
+            CmdletMetadata newCmdlet,
             ReportLogger<BreakingChangeIssue> issueLogger)
         {
             // If the default parameter name hasn't changed, or if there wasn't a
@@ -315,7 +315,7 @@ private void CheckDefaultParameterName(
         }
 
         /// <summary>
-        /// Comparer for assebly qualified names.  Parses of the PublicKeyToken, so that types from signed and unsigned assemblies match 
+        /// Comparer for assebly qualified names.  Parses of the PublicKeyToken, so that types from signed and unsigned assemblies match
         /// </summary>
         class TypeNameComparer : IEqualityComparer<string>
         {