Add CustomRulePath property to settings file

.build.ps1

@@ -113,7 +113,12 @@ function Get-ResourceTaskParam($project) {
     @{
         Inputs  = "$project/Strings.resx"
         Outputs = "$project/Strings.cs"
-        Jobs    = {& "$resourceScript $project"}
+        Data = $project
+        Jobs    = {
+            Push-Location $BuildRoot
+            & $resourceScript $Task.Data
+            Pop-Location
+        }
         Before  = "$project/build"
     }
 }

.vscode/settings.json

@@ -0,0 +1,5 @@
+// Place your settings in this file to overwrite default and user settings.
+{
+    "editor.tabSize": 4,
+    "powershell.codeFormatting.preset": "Allman"
+}

Engine/Commands/InvokeScriptAnalyzerCommand.cs

@@ -265,6 +265,9 @@ protected override void BeginProcessing()
                 ProcessPath();
             }
 
+            string[] combRulePaths = null;
+            var combRecurseCustomRulePath = RecurseCustomRulePath.IsPresent;
+            var combIncludeDefaultRules = IncludeDefaultRules.IsPresent;
             try
             {
                 var settingsObj = PSSASettings.Create(
@@ -274,7 +277,30 @@ protected override void BeginProcessing()
                 if (settingsObj != null)
                 {
                     ScriptAnalyzer.Instance.UpdateSettings(settingsObj);
+
+                    // For includeDefaultRules and RecurseCustomRulePath we override the value in the settings file by
+                    // command line argument.
+                    combRecurseCustomRulePath = OverrideSwitchParam(
+                        settingsObj.RecurseCustomRulePath,
+                        "RecurseCustomRulePath");
+                    combIncludeDefaultRules = OverrideSwitchParam(
+                        settingsObj.IncludeDefaultRules,
+                        "IncludeDefaultRules");
                 }
+
+                // Ideally we should not allow the parameter to be set from settings and command line
+                // simultaneously. But since, this was done before with IncludeRules, ExcludeRules and Severity,
+                // we use the same strategy for CustomRulePath. So, we take the union of CustomRulePath provided in
+                // the settings file and if provided on command line.
+                var settingsCustomRulePath = Helper.ProcessCustomRulePaths(
+                        settingsObj?.CustomRulePath?.ToArray(),
+                        this.SessionState,
+                        combRecurseCustomRulePath);
+                    combRulePaths = rulePaths == null
+                                                ? settingsCustomRulePath
+                                                : settingsCustomRulePath == null
+                                                    ? rulePaths
+                                                    : rulePaths.Concat(settingsCustomRulePath).ToArray();
             }
             catch
             {
@@ -285,11 +311,11 @@ protected override void BeginProcessing()
 
             ScriptAnalyzer.Instance.Initialize(
                 this,
-                rulePaths,
+                combRulePaths,
                 this.includeRule,
                 this.excludeRule,
                 this.severity,
-                null == rulePaths ? true : this.includeDefaultRules,
+                combRulePaths == null || combIncludeDefaultRules,
                 this.suppressedOnly);
         }
 
@@ -388,6 +414,13 @@ private bool IsFileParameterSet()
             return String.Equals(this.ParameterSetName, "File", StringComparison.OrdinalIgnoreCase);
         }
 
+        private bool OverrideSwitchParam(bool paramValue, string paramName)
+        {
+            return MyInvocation.BoundParameters.ContainsKey(paramName)
+                ? ((SwitchParameter)MyInvocation.BoundParameters[paramName]).ToBool()
+                : paramValue;
+        }
+
         #endregion // Private Methods
     }
 }

Engine/Settings.cs

@@ -28,17 +28,23 @@ internal enum SettingsMode { None = 0, Auto, File, Hashtable, Preset };
     /// </summary>
     public class Settings
     {
+        private bool recurseCustomRulePath = false;
+        private bool includeDefaultRules = false;
         private string filePath;
         private List<string> includeRules;
         private List<string> excludeRules;
         private List<string> severities;
+        private List<string> customRulePath;
         private Dictionary<string, Dictionary<string, object>> ruleArguments;
 
-        public string FilePath { get { return filePath; } }
-        public IEnumerable<string> IncludeRules { get { return includeRules; } }
-        public IEnumerable<string> ExcludeRules { get { return excludeRules; } }
-        public IEnumerable<string> Severities { get { return severities; } }
-        public Dictionary<string, Dictionary<string, object>> RuleArguments { get { return ruleArguments; } }
+        public bool RecurseCustomRulePath => recurseCustomRulePath;
+        public bool IncludeDefaultRules => includeDefaultRules;
+        public string FilePath => filePath;
+        public IEnumerable<string> IncludeRules => includeRules;
+        public IEnumerable<string> ExcludeRules => excludeRules;
+        public IEnumerable<string> Severities => severities;
+        public IEnumerable<string> CustomRulePath => customRulePath;
+        public Dictionary<string, Dictionary<string, object>> RuleArguments => ruleArguments;
 
         /// <summary>
         /// Create a settings object from the input object.
@@ -400,6 +406,27 @@ private void parseSettingsHashtable(Hashtable settingsHashtable)
                         excludeRules = GetData(val, key);
                         break;
 
+                    case "customrulepath":
+                        customRulePath = GetData(val, key);
+                        break;
+
+                    case "includedefaultrules":
+                    case "recursecustomrulepath":
+                        if (!(val is bool))
+                        {
+                            throw new InvalidDataException(string.Format(
+                                CultureInfo.CurrentCulture,
+                                Strings.SettingsValueTypeMustBeBool,
+                                settingKey));
+                        }
+
+                        var booleanVal = (bool)val;
+                        var field = this.GetType().GetField(
+                            key,
+                            BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.NonPublic);
+                        field.SetValue(this, booleanVal);
+                        break;
+
                     case "rules":
                         try
                         {

Engine/Strings.resx

@@ -273,6 +273,9 @@
   <data name="SettingsNotParsable" xml:space="preserve">
     <value>Cannot parse settings. Will abort the invocation.</value>
   </data>
+  <data name="SettingsValueTypeMustBeBool" xml:space="preserve">
+    <value>{0} property must be of type bool.</value>
+  </data>
   <data name="ModuleDepHandlerTempLocation" xml:space="preserve">
     <value>Temporary module location: {0}.</value>
   </data>

New-StronglyTypedCsFileForResx.ps1

@@ -113,7 +113,7 @@ internal class {0} {{
             $entry -f $name,$val
         }
     } | Out-String
-    
+
     $bodyCode = $body -f $shortClassName,$ModuleName,$entries,$ClassName
 
     if ($NamespaceName)
@@ -126,10 +126,10 @@ internal class {0} {{
     return $resultCode -replace "`r`n?|`n","`r`n"
 }
 
-$projectRoot = Split-Path $MyInvocation.InvocationName
+$projectRoot = $PWD
 if (-not (Test-Path "$projectRoot/global.json"))
 {
-    throw "Not in solution root"
+    throw "Not in solution root: $projectRoot"
 }
 $inputFilePath = Join-Path $projectRoot "$project/Strings.resx"
 $outputFilePath = Join-Path $projectRoot "$project/Strings.cs"
@@ -141,4 +141,4 @@ if ($project -eq "Rules")
 $className += ".Strings"
 $xml = [xml](Get-Content -raw $inputFilePath)
 $genSource = Get-StronglyTypeCsFileForResx -xml $xml -ModuleName Foo -ClassName $className
-Set-Content -Encoding Ascii -Path $outputFilePath -Value $genSource
+Set-Content -Encoding Ascii -Path $outputFilePath -Value $genSource

Tests/Engine/InvokeScriptAnalyzer.tests.ps1

@@ -380,9 +380,74 @@ Describe "Test CustomizedRulePath" {
             $customizedRulePath = Invoke-ScriptAnalyzer $directory\TestScript.ps1 -CustomRulePath ("$directory\CommunityAnalyzerRules", "$directory\samplerule", "$directory\samplerule\samplerule2")
             $customizedRulePath.Count | Should Be 3
         }
-
     }
 
+    if (!$testingLibraryUsage)
+    {
+        Context "When used from settings file" {
+            It "Should use the CustomRulePath parameter" {
+                $settings = @{
+                    CustomRulePath        = "$directory\CommunityAnalyzerRules"
+                    IncludeDefaultRules   = $false
+                    RecurseCustomRulePath = $false
+                }
+
+                $v = Invoke-ScriptAnalyzer -Path $directory\TestScript.ps1 -Settings $settings
+                $v.Count | Should Be 1
+            }
+
+            It "Should use the IncludeDefaultRulePath parameter" {
+                $settings = @{
+                    CustomRulePath        = "$directory\CommunityAnalyzerRules"
+                    IncludeDefaultRules   = $true
+                    RecurseCustomRulePath = $false
+                }
+
+                $v = Invoke-ScriptAnalyzer -Path $directory\TestScript.ps1 -Settings $settings
+                $v.Count | Should Be 2
+            }
+
+            It "Should use the RecurseCustomRulePath parameter" {
+                $settings = @{
+                    CustomRulePath        = "$directory\samplerule"
+                    IncludeDefaultRules   = $false
+                    RecurseCustomRulePath = $true
+                }
+
+                $v = Invoke-ScriptAnalyzer -Path $directory\TestScript.ps1 -Settings $settings
+                $v.Count | Should Be 3
+            }
+        }
+
+        Context "When used from settings file and command line simulataneusly" {
+            BeforeAll {
+                $settings = @{
+                    CustomRulePath        = "$directory\samplerule"
+                    IncludeDefaultRules   = $false
+                    RecurseCustomRulePath = $false
+                }
+                $isaParams = @{
+                    Path     = "$directory\TestScript.ps1"
+                    Settings = $settings
+                }
+            }
+
+            It "Should combine CustomRulePaths" {
+                $v = Invoke-ScriptAnalyzer @isaParams -CustomRulePath "$directory\CommunityAnalyzerRules"
+                $v.Count | Should Be 2
+            }
+
+            It "Should override the settings IncludeDefaultRules parameter" {
+                $v = Invoke-ScriptAnalyzer @isaParams -IncludeDefaultRules
+                $v.Count | Should Be 2
+            }
+
+            It "Should override the settings RecurseCustomRulePath parameter" {
+                $v = Invoke-ScriptAnalyzer @isaParams -RecurseCustomRulePath
+                $v.Count | Should Be 3
+            }
+        }
+    }
 
     Context "When used incorrectly" {
         It "file cannot be found" {

Tests/Engine/Settings.tests.ps1

@@ -114,4 +114,69 @@ Describe "Settings Class" {
             $settings.RuleArguments["PSProvideCommentHelp"]["Placement"] | Should Be 'end'
         }
     }
+
+    Context "When CustomRulePath parameter is provided" {
+        It "Should return an array of 1 item when only 1 path is given in a hashtable" {
+            $rulePath = "C:\rules\module1"
+            $settingsHashtable = @{
+                CustomRulePath = $rulePath
+            }
+
+            $settings = New-Object -TypeName $settingsTypeName  -ArgumentList $settingsHashtable
+            $settings.CustomRulePath.Count | Should Be 1
+            $settings.CustomRulePath[0] | Should be $rulePath
+        }
+
+        It "Should return an array of n items when n items are given in a hashtable" {
+            $rulePaths = @("C:\rules\module1", "C:\rules\module2")
+            $settingsHashtable = @{
+                CustomRulePath = $rulePaths
+            }
+
+            $settings = New-Object -TypeName $settingsTypeName  -ArgumentList $settingsHashtable
+            $settings.CustomRulePath.Count | Should Be $rulePaths.Count
+            0..($rulePaths.Count - 1) | ForEach-Object { $settings.CustomRulePath[$_] | Should be $rulePaths[$_] }
+
+        }
+
+        It "Should detect the parameter in a settings file" {
+            $settings = New-Object -TypeName $settingsTypeName `
+                              -ArgumentList ([System.IO.Path]::Combine($project1Root, "CustomRulePathSettings.psd1"))
+            $settings.CustomRulePath.Count | Should Be 2
+        }
+    }
+
+    @("IncludeDefaultRules", "RecurseCustomRulePath") | ForEach-Object {
+        $paramName = $_
+        Context "When $paramName parameter is provided" {
+            It "Should correctly set the value if a boolean is given - true" {
+                $settingsHashtable = @{}
+                $settingsHashtable.Add($paramName, $true)
+
+                $settings = New-Object -TypeName $settingsTypeName -ArgumentList $settingsHashtable
+                $settings."$paramName" | Should Be $true
+            }
+
+            It "Should correctly set the value if a boolean is given - false" {
+                $settingsHashtable = @{}
+                $settingsHashtable.Add($paramName, $false)
+
+                $settings = New-Object -TypeName $settingsTypeName -ArgumentList $settingsHashtable
+                $settings."$paramName" | Should Be $false
+            }
+
+            It "Should throw if a non-boolean value is given" {
+                $settingsHashtable = @{}
+                $settingsHashtable.Add($paramName, "some random string")
+
+                { New-Object -TypeName $settingsTypeName -ArgumentList $settingsHashtable } | Should Throw
+            }
+
+            It "Should detect the parameter in a settings file" {
+                $settings = New-Object -TypeName $settingsTypeName `
+                    -ArgumentList ([System.IO.Path]::Combine($project1Root, "CustomRulePathSettings.psd1"))
+                $settings."$paramName" | Should Be $true
+            }
+        }
+    }
 }

Tests/Engine/SettingsTest/Project1/CustomRulePathSettings.psd1

@@ -0,0 +1,5 @@
+@{
+    "CustomRulePath" = @("C:\rules\module1", "C:\rules\module2")
+    "IncludeDefaultRules" = $true
+    "RecurseCustomRulePath" = $true
+}