Clean up LanguageServerSettings.cs

Author: andyleejordan

src/PowerShellEditorServices/Services/Workspace/LanguageServerSettings.cs

@@ -15,78 +15,61 @@ namespace Microsoft.PowerShell.EditorServices.Services.Configuration
 {
     internal class LanguageServerSettings
     {
-        private readonly object updateLock = new object();
-
-        public bool EnableProfileLoading { get; set; } = false;
-
+        private readonly object updateLock = new();
+        public bool EnableProfileLoading { get; set; }
         public bool PromptToUpdatePackageManagement { get; set; } = true;
-
         public ScriptAnalysisSettings ScriptAnalysis { get; set; }
-
         public CodeFormattingSettings CodeFormatting { get; set; }
-
         public CodeFoldingSettings CodeFolding { get; set; }
-
         public PesterSettings Pester { get; set; }
-
         public string Cwd { get; set; }
 
         public LanguageServerSettings()
         {
-            this.ScriptAnalysis = new ScriptAnalysisSettings();
-            this.CodeFormatting = new CodeFormattingSettings();
-            this.CodeFolding = new CodeFoldingSettings();
-            this.Pester = new PesterSettings();
+            ScriptAnalysis = new ScriptAnalysisSettings();
+            CodeFormatting = new CodeFormattingSettings();
+            CodeFolding = new CodeFoldingSettings();
+            Pester = new PesterSettings();
         }
 
         public void Update(
             LanguageServerSettings settings,
             string workspaceRootPath,
             ILogger logger)
         {
-            if (settings != null)
+            if (settings is not null)
             {
                 lock (updateLock)
                 {
-                    this.EnableProfileLoading = settings.EnableProfileLoading;
-                    this.PromptToUpdatePackageManagement = settings.PromptToUpdatePackageManagement;
-                    this.ScriptAnalysis.Update(
-                        settings.ScriptAnalysis,
-                        workspaceRootPath,
-                        logger);
-                    this.CodeFormatting = new CodeFormattingSettings(settings.CodeFormatting);
-                    this.CodeFolding.Update(settings.CodeFolding, logger);
-                    this.Pester.Update(settings.Pester, logger);
-                    this.Cwd = settings.Cwd;
+                    EnableProfileLoading = settings.EnableProfileLoading;
+                    PromptToUpdatePackageManagement = settings.PromptToUpdatePackageManagement;
+                    ScriptAnalysis.Update(settings.ScriptAnalysis, workspaceRootPath, logger);
+                    CodeFormatting = new CodeFormattingSettings(settings.CodeFormatting);
+                    CodeFolding.Update(settings.CodeFolding, logger);
+                    Pester.Update(settings.Pester, logger);
+                    Cwd = settings.Cwd;
                 }
             }
         }
     }
 
     internal class ScriptAnalysisSettings
     {
-        private readonly object updateLock = new object();
-
+        private readonly object updateLock = new();
         public bool? Enable { get; set; }
-
         public string SettingsPath { get; set; }
-
-        public ScriptAnalysisSettings()
-        {
-            this.Enable = true;
-        }
+        public ScriptAnalysisSettings() { Enable = true; }
 
         public void Update(
             ScriptAnalysisSettings settings,
             string workspaceRootPath,
             ILogger logger)
         {
-            if (settings != null)
+            if (settings is not null)
             {
-                lock(updateLock)
+                lock (updateLock)
                 {
-                    this.Enable = settings.Enable;
-
+                    Enable = settings.Enable;
                     string settingsPath = settings.SettingsPath;
 
                     try
@@ -105,29 +88,22 @@ public void Update(
                                 // In this case we should just log an error and let
                                 // the specified settings path go through even though
                                 // it will fail to load.
-                                logger.LogError(
-                                    "Could not resolve Script Analyzer settings path due to null or empty workspaceRootPath.");
+                                logger.LogError( "Could not resolve Script Analyzer settings path due to null or empty workspaceRootPath.");
                             }
                             else
                             {
                                 settingsPath = Path.GetFullPath(Path.Combine(workspaceRootPath, settingsPath));
                             }
                         }
 
-                        this.SettingsPath = settingsPath;
+                        SettingsPath = settingsPath;
                         logger.LogTrace($"Using Script Analyzer settings path - '{settingsPath ?? ""}'.");
                     }
-                    catch (Exception ex) when (
-                        ex is NotSupportedException ||
-                        ex is PathTooLongException ||
-                        ex is SecurityException)
+                    catch (Exception ex) when (ex is NotSupportedException or PathTooLongException or SecurityException)
                     {
                         // Invalid chars in path like ${env:HOME} can cause Path.GetFullPath() to throw, catch such errors here
-                        logger.LogException(
-                            $"Invalid Script Analyzer settings path - '{settingsPath}'.",
-                            ex);
-
-                        this.SettingsPath = null;
+                        logger.LogException($"Invalid Script Analyzer settings path - '{settingsPath}'.", ex);
+                        SettingsPath = null;
                     }
                 }
             }
@@ -192,22 +168,20 @@ internal class CodeFormattingSettings
         /// <summary>
         /// Default constructor.
         /// </summary>>
-        public CodeFormattingSettings()
-        {
-        }
+        public CodeFormattingSettings() { }
 
         /// <summary>
         /// Copy constructor.
         /// </summary>
         /// <param name="codeFormattingSettings">An instance of type CodeFormattingSettings.</param>
         public CodeFormattingSettings(CodeFormattingSettings codeFormattingSettings)
         {
-            if (codeFormattingSettings == null)
+            if (codeFormattingSettings is null)
             {
                 throw new ArgumentNullException(nameof(codeFormattingSettings));
             }
 
-            foreach (var prop in this.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
+            foreach (PropertyInfo prop in GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
             {
                 prop.SetValue(this, prop.GetValue(codeFormattingSettings));
             }
@@ -226,29 +200,28 @@ public CodeFormattingSettings(CodeFormattingSettings codeFormattingSettings)
         public bool WhitespaceBeforeOpenParen { get; set; }
         public bool WhitespaceAroundOperator { get; set; }
         public bool WhitespaceAfterSeparator { get; set; }
-        public bool WhitespaceBetweenParameters  { get; set; }
+        public bool WhitespaceBetweenParameters { get; set; }
         public bool WhitespaceInsideBrace { get; set; }
         public bool IgnoreOneLineBlock { get; set; }
         public bool AlignPropertyValuePairs { get; set; }
         public bool UseCorrectCasing { get; set; }
 
-
         /// <summary>
         /// Get the settings hashtable that will be consumed by PSScriptAnalyzer.
         /// </summary>
         /// <param name="tabSize">The tab size in the number spaces.</param>
         /// <param name="insertSpaces">If true, insert spaces otherwise insert tabs for indentation.</param>
-        /// <returns></returns>
         public Hashtable GetPSSASettingsHashtable(
             int tabSize,
             bool insertSpaces,
             ILogger logger)
         {
-            var settings = GetCustomPSSASettingsHashtable(tabSize, insertSpaces);
-            var ruleSettings = (Hashtable)(settings["Rules"]);
-            var closeBraceSettings = (Hashtable)ruleSettings["PSPlaceCloseBrace"];
-            var openBraceSettings = (Hashtable)ruleSettings["PSPlaceOpenBrace"];
-            switch(Preset)
+            Hashtable settings = GetCustomPSSASettingsHashtable(tabSize, insertSpaces);
+            Hashtable ruleSettings = settings["Rules"] as Hashtable;
+            Hashtable closeBraceSettings = ruleSettings["PSPlaceCloseBrace"] as Hashtable;
+            Hashtable openBraceSettings = ruleSettings["PSPlaceOpenBrace"] as Hashtable;
+
+            switch (Preset)
             {
                 case CodeFormattingPreset.Allman:
                     openBraceSettings["OnSameLine"] = false;
@@ -268,6 +241,7 @@ public Hashtable GetPSSASettingsHashtable(
                     closeBraceSettings["NewLineAfter"] = true;
                     break;
 
+                case CodeFormattingPreset.Custom:
                 default:
                     break;
             }
@@ -278,7 +252,7 @@ public Hashtable GetPSSASettingsHashtable(
 
         private Hashtable GetCustomPSSASettingsHashtable(int tabSize, bool insertSpaces)
         {
-            var ruleConfigurations = new Hashtable
+            Hashtable ruleConfigurations = new()
             {
                 { "PSPlaceOpenBrace", new Hashtable {
                     { "Enable", true },
@@ -337,8 +311,7 @@ private Hashtable GetCustomPSSASettingsHashtable(int tabSize, bool insertSpaces)
                         "PSAlignAssignmentStatement",
                         "PSAvoidUsingDoubleQuotesForConstantString",
                 }},
-                {
-                    "Rules", ruleConfigurations
+                { "Rules", ruleConfigurations
                 }
             };
         }
@@ -366,14 +339,17 @@ public void Update(
             CodeFoldingSettings settings,
             ILogger logger)
         {
-            if (settings != null) {
-                if (this.Enable != settings.Enable) {
-                    this.Enable = settings.Enable;
-                    logger.LogTrace(string.Format("Using Code Folding Enabled - {0}", this.Enable));
+            if (settings is not null)
+            {
+                if (Enable != settings.Enable)
+                {
+                    Enable = settings.Enable;
+                    logger.LogTrace(string.Format("Using Code Folding Enabled - {0}", Enable));
                 }
-                if (this.ShowLastLine != settings.ShowLastLine) {
-                    this.ShowLastLine = settings.ShowLastLine;
-                    logger.LogTrace(string.Format("Using Code Folding ShowLastLine - {0}", this.ShowLastLine));
+                if (ShowLastLine != settings.ShowLastLine)
+                {
+                    ShowLastLine = settings.ShowLastLine;
+                    logger.LogTrace(string.Format("Using Code Folding ShowLastLine - {0}", ShowLastLine));
                 }
             }
         }
@@ -401,20 +377,21 @@ public void Update(
             PesterSettings settings,
             ILogger logger)
         {
-            if (settings is null) {
+            if (settings is null)
+            {
                 return;
             }
 
-            if (this.CodeLens != settings.CodeLens)
+            if (CodeLens != settings.CodeLens)
             {
-                this.CodeLens = settings.CodeLens;
-                logger.LogTrace(string.Format("Using Pester Code Lens - {0}", this.CodeLens));
+                CodeLens = settings.CodeLens;
+                logger.LogTrace(string.Format("Using Pester Code Lens - {0}", CodeLens));
             }
 
-            if (this.UseLegacyCodeLens != settings.UseLegacyCodeLens)
+            if (UseLegacyCodeLens != settings.UseLegacyCodeLens)
             {
-                this.UseLegacyCodeLens = settings.UseLegacyCodeLens;
-                logger.LogTrace(string.Format("Using Pester Legacy Code Lens - {0}", this.UseLegacyCodeLens));
+                UseLegacyCodeLens = settings.UseLegacyCodeLens;
+                logger.LogTrace(string.Format("Using Pester Legacy Code Lens - {0}", UseLegacyCodeLens));
             }
         }
     }