Merge pull request #311 from PowerShell/kapilmb/UpdatablePSSARules

Make PSSA includerule list updatable

Author: daviwil

src/PowerShellEditorServices.Protocol/LanguageServer/GetPSSARulesRequest.cs

@@ -0,0 +1,16 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.LanguageServer
+{
+    class GetPSSARulesRequest
+    {
+        public static readonly
+            RequestType<string, object> Type =
+            RequestType<string, object>.Create("powerShell/getPSSARules");
+    }
+}

src/PowerShellEditorServices.Protocol/LanguageServer/SetPSSARulesRequest.cs

@@ -0,0 +1,16 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.LanguageServer
+{
+    class SetPSSARulesRequest
+    {
+        public static readonly
+            RequestType<object, object> Type =
+            RequestType<object, object>.Create("powerShell/setPSSARules");
+    }
+}

src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj

@@ -55,11 +55,13 @@
     <Compile Include="DebugAdapter\ContinueRequest.cs" />
     <Compile Include="DebugAdapter\SetFunctionBreakpointsRequest.cs" />
     <Compile Include="DebugAdapter\SetVariableRequest.cs" />
+    <Compile Include="LanguageServer\GetPSSARulesRequest.cs" />
     <Compile Include="LanguageServer\EditorCommands.cs" />
     <Compile Include="LanguageServer\CodeAction.cs" />
     <Compile Include="LanguageServer\FindModuleRequest.cs" />
     <Compile Include="LanguageServer\InstallModuleRequest.cs" />
     <Compile Include="LanguageServer\PowerShellVersionRequest.cs" />
+    <Compile Include="LanguageServer\SetPSSARulesRequest.cs" />
     <Compile Include="MessageProtocol\Channel\NamedPipeClientChannel.cs" />
     <Compile Include="MessageProtocol\Channel\NamedPipeServerChannel.cs" />
     <Compile Include="MessageProtocol\Channel\TcpSocketClientChannel.cs" />

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -109,6 +109,9 @@ protected override void Initialize()
 
             this.SetRequestHandler(DebugAdapterMessages.EvaluateRequest.Type, this.HandleEvaluateRequest);
 
+            this.SetRequestHandler(GetPSSARulesRequest.Type, this.HandleGetPSSARulesRequest);
+            this.SetRequestHandler(SetPSSARulesRequest.Type, this.HandleSetPSSARulesRequest);
+
             // Initialize the extension service
             // TODO: This should be made awaited once Initialize is async!
             this.editorSession.ExtensionService.Initialize(
@@ -180,6 +183,55 @@ protected async Task HandleShowOnlineHelpRequest(
             await requestContext.SendResult(null);
         }
 
+        private async Task HandleSetPSSARulesRequest(
+            object param,
+            RequestContext<object> requestContext)
+        {
+            var dynParams = param as dynamic;
+            if (editorSession.AnalysisService != null &&
+                    editorSession.AnalysisService.SettingsPath == null)
+            {
+                var activeRules = new List<string>();
+                var ruleInfos = dynParams.ruleInfos;
+                foreach (dynamic ruleInfo in ruleInfos)
+                {
+                    if ((Boolean) ruleInfo.isEnabled)
+                    {
+                        activeRules.Add((string) ruleInfo.name);
+                    }
+                }
+                editorSession.AnalysisService.ActiveRules = activeRules.ToArray();
+            }
+
+            var sendresult = requestContext.SendResult(null);
+            var scripFile = editorSession.Workspace.GetFile((string)dynParams.filepath);
+            await RunScriptDiagnostics(
+                    new ScriptFile[] { scripFile },
+                        editorSession,
+                        requestContext.SendEvent);
+            await sendresult;
+        }
+
+        private async Task HandleGetPSSARulesRequest(
+            object param,
+            RequestContext<object> requestContext)
+        {
+            List<object> rules = null;
+            if (editorSession.AnalysisService != null
+                    && editorSession.AnalysisService.SettingsPath == null)
+            {
+                rules = new List<object>();
+                var ruleNames = editorSession.AnalysisService.GetPSScriptAnalyzerRules();
+                var activeRules = editorSession.AnalysisService.ActiveRules;
+                foreach (var ruleName in ruleNames)
+                {
+                    rules.Add(new { name = ruleName, isEnabled = activeRules.Contains(ruleName, StringComparer.OrdinalIgnoreCase) });
+                }
+            }
+
+            await requestContext.SendResult(rules);
+        }
+
         private async Task HandleInstallModuleRequest(
             string moduleName,
             RequestContext<object> requestContext
@@ -964,6 +1016,14 @@ private Task RunScriptDiagnostics(
             ScriptFile[] filesToAnalyze,
             EditorSession editorSession,
             EventContext eventContext)
+        {
+            return RunScriptDiagnostics(filesToAnalyze, editorSession, eventContext.SendEvent);
+        }
+
+        private Task RunScriptDiagnostics(
+            ScriptFile[] filesToAnalyze,
+            EditorSession editorSession,
+            Func<EventType<PublishDiagnosticsNotification>, PublishDiagnosticsNotification, Task> eventSender)
         {
             if (!this.currentSettings.ScriptAnalysis.Enable.Value)
             {
@@ -1011,7 +1071,7 @@ private Task RunScriptDiagnostics(
                         filesToAnalyze,
                         this.codeActionsPerFile,
                         editorSession,
-                        eventContext,
+                        eventSender,
                         existingRequestCancellation.Token),
                 CancellationToken.None,
                 TaskCreationOptions.None,
@@ -1020,13 +1080,32 @@ private Task RunScriptDiagnostics(
             return Task.FromResult(true);
         }
 
+
         private static async Task DelayThenInvokeDiagnostics(
             int delayMilliseconds,
             ScriptFile[] filesToAnalyze,
             Dictionary<string, Dictionary<string, MarkerCorrection>> correctionIndex,
             EditorSession editorSession,
             EventContext eventContext,
             CancellationToken cancellationToken)
+        {
+            await DelayThenInvokeDiagnostics(
+                delayMilliseconds,
+                filesToAnalyze,
+                correctionIndex,
+                editorSession,
+                eventContext.SendEvent,
+                cancellationToken);
+        }
+
+
+        private static async Task DelayThenInvokeDiagnostics(
+            int delayMilliseconds,
+            ScriptFile[] filesToAnalyze,
+            Dictionary<string, Dictionary<string, MarkerCorrection>> correctionIndex,
+            EditorSession editorSession,
+            Func<EventType<PublishDiagnosticsNotification>, PublishDiagnosticsNotification, Task> eventSender,
+            CancellationToken cancellationToken)
         {
             // First of all, wait for the desired delay period before
             // analyzing the provided list of files
@@ -1072,7 +1151,7 @@ await PublishScriptDiagnostics(
                     scriptFile,
                     semanticMarkers,
                     correctionIndex,
-                    eventContext);
+                    eventSender);
             }
         }
 
@@ -1081,6 +1160,19 @@ private static async Task PublishScriptDiagnostics(
             ScriptFileMarker[] semanticMarkers,
             Dictionary<string, Dictionary<string, MarkerCorrection>> correctionIndex,
             EventContext eventContext)
+        {
+            await PublishScriptDiagnostics(
+                scriptFile,
+                semanticMarkers,
+                correctionIndex,
+                eventContext.SendEvent);
+        }
+
+        private static async Task PublishScriptDiagnostics(
+            ScriptFile scriptFile,
+            ScriptFileMarker[] semanticMarkers,
+            Dictionary<string, Dictionary<string, MarkerCorrection>> correctionIndex,
+            Func<EventType<PublishDiagnosticsNotification>, PublishDiagnosticsNotification, Task> eventSender)
         {
             List<Diagnostic> diagnostics = new List<Diagnostic>();
 
@@ -1104,7 +1196,7 @@ private static async Task PublishScriptDiagnostics(
 
             // Always send syntax and semantic errors.  We want to
             // make sure no out-of-date markers are being displayed.
-            await eventContext.SendEvent(
+            await eventSender(
                 PublishDiagnosticsNotification.Type,
                 new PublishDiagnosticsNotification
                 {

src/PowerShellEditorServices/Analysis/AnalysisService.cs

@@ -51,6 +51,11 @@ public class AnalysisService : IDisposable
 
         #region Properties
 
+        /// <summary>
+        /// Set of PSScriptAnalyzer rules used for analysis
+        /// </summary>
+        public string[] ActiveRules { get; set; }
+
         /// <summary>
         /// Gets or sets the path to a settings file (.psd1)
         /// containing PSScriptAnalyzer settings.
@@ -79,6 +84,7 @@ public AnalysisService(IConsoleHost consoleHost, string settingsPath = null)
                 this.analysisRunspace = RunspaceFactory.CreateRunspace(InitialSessionState.CreateDefault2());
                 this.analysisRunspace.ThreadOptions = PSThreadOptions.ReuseThread;
                 this.analysisRunspace.Open();
+                ActiveRules = IncludedRules.ToArray();
                 InitializePSScriptAnalyzer();
             }
             catch (Exception e)
@@ -129,6 +135,28 @@ public ScriptFileMarker[] GetSemanticMarkers(ScriptFile file)
             }
         }
 
+        /// <summary>
+        /// Returns a list of builtin-in PSScriptAnalyzer rules
+        /// </summary>
+        public IEnumerable<string> GetPSScriptAnalyzerRules()
+        {
+            List<string> ruleNames = new List<string>();
+            if (scriptAnalyzerModuleInfo != null)
+            {
+                using (var ps = System.Management.Automation.PowerShell.Create())
+                {
+                    ps.Runspace = this.analysisRunspace;
+                    var ruleObjects = ps.AddCommand("Get-ScriptAnalyzerRule").Invoke();
+                    foreach (var rule in ruleObjects)
+                    {
+                        ruleNames.Add((string)rule.Members["RuleName"].Value);
+                    }
+                }
+            }
+
+            return ruleNames;
+        }
+
         /// <summary>
         /// Disposes the runspace being used by the analysis service.
         /// </summary>
@@ -207,23 +235,16 @@ private void EnumeratePSScriptAnalyzerRules()
         {
             if (scriptAnalyzerModuleInfo != null)
             {
-                using (var ps = System.Management.Automation.PowerShell.Create())
+                var rules = GetPSScriptAnalyzerRules();
+                var sb = new StringBuilder();
+                sb.AppendLine("Available PSScriptAnalyzer Rules:");
+                foreach (var rule in rules)
                 {
-                    ps.Runspace = this.analysisRunspace;
-
-                    var rules = ps.AddCommand("Get-ScriptAnalyzerRule").Invoke();
-                    var sb = new StringBuilder();
-                    sb.AppendLine("Available PSScriptAnalyzer Rules:");
-
-                    foreach (var rule in rules)
-                    {
-                        sb.AppendLine((string)rule.Members["RuleName"].Value);
-                    }
-
-                    Logger.Write(LogLevel.Verbose, sb.ToString());
+                    sb.AppendLine(rule);
                 }
-            }
 
+                Logger.Write(LogLevel.Verbose, sb.ToString());
+            }
         }
 
         private void InitializePSScriptAnalyzer()
@@ -257,7 +278,7 @@ private IEnumerable<PSObject> GetDiagnosticRecords(ScriptFile file)
                     }
                     else
                     {
-                        powerShell.AddParameter("IncludeRule", IncludedRules);
+                        powerShell.AddParameter("IncludeRule", ActiveRules);
                     }
 
                     diagnosticRecords = powerShell.Invoke();

src/PowerShellEditorServices/Nano.PowerShellEditorServices.csproj

@@ -36,6 +36,12 @@
     <DocumentationFile>bin\Release\Microsoft.PowerShell.EditorServices.XML</DocumentationFile>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="..\PowerShellEditorServices.Protocol\LanguageServer\GetPSSARulesRequest.cs">
+      <Link>GetPSSARulesRequest.cs</Link>
+    </Compile>
+    <Compile Include="..\PowerShellEditorServices.Protocol\LanguageServer\SetPSSARulesRequest.cs">
+      <Link>SetPSSARulesRequest.cs</Link>
+    </Compile>
     <Compile Include="Analysis\AnalysisOutputWriter.cs" />
     <Compile Include="Analysis\AnalysisService.cs" />
     <Compile Include="Console\ChoicePromptHandler.cs" />