Use allowlist and blocklist terminology, supply alternate configuration key for PSAvoidUsingCmdletAliases (#1604)

bergmeister · web-flow · commit 48575789af03 · 2020-11-03T10:14:07.000-08:00
diff --git a/CHANGELOG.MD b/CHANGELOG.MD
@@ -503,7 +503,7 @@ Many thanks to @rkeithhill for contributing the _Stroustrup_ style code formatti
 ## [1.11.1](https://github.com/PowerShell/PSScriptAnalyzer/tree/1.11.1) - 2017-04-04
 ### Fixed
 - CodeFormatting settings file (#727, #728).
-- Whitelisted aliases comparison in AvoidUsingCmdletAliases rule (#739).
+- Allowlist aliases comparison in AvoidUsingCmdletAliases rule (#739).
 - PlaceCloseBrace rule behavior for NewLineAfter option (#741).
 - UseConsistentIndentation rule to ignore open brace in magic methods (#744).
 
@@ -600,7 +600,7 @@ Here are some improvements since the last release.
 - Fix `SaveDscDependency` switch implementation, which use fail if more than one parameter is given to `Import-DSCResource` dynamic keyword.
 - Add support for external AST based rule suppression
 - Fix rule suppression caused by inavlid offsets
-- Whitelist `Data` in `PSUseSingularNoun` rule
+- Allowlist `Data` in `PSUseSingularNoun` rule
 - Fix rule documentation of `PSDSCExamplesPresent`
 - Fix false positives caused by PSD1 files which are not module manifests
     - affects `PSUseToExportFieldsInManifest`, `PSMissingModuleManifestField` and `PSAvoidUsingDeprecatedManifestFields` rules
diff --git a/RuleDocumentation/AvoidOverwritingBuiltInCmdlets.md b/RuleDocumentation/AvoidOverwritingBuiltInCmdlets.md
@@ -4,7 +4,7 @@
 
 ## Description
 
-This rule flags cmdlets that are available in a given edition/version of PowerShell on a given operating system which are overwritten by a function declaration. It works by comparing function declarations against a set of whitelists which ship with PSScriptAnalyzer. These whitelist files are used by other PSScriptAnalyzer rules. More information can be found in the documentation for the [UseCompatibleCmdlets](./UseCompatibleCmdlets.md) rule.
+This rule flags cmdlets that are available in a given edition/version of PowerShell on a given operating system which are overwritten by a function declaration. It works by comparing function declarations against a set of allowlists which ship with PSScriptAnalyzer. These allowlist files are used by other PSScriptAnalyzer rules. More information can be found in the documentation for the [UseCompatibleCmdlets](./UseCompatibleCmdlets.md) rule.
 
 ## Configuration
 
@@ -25,7 +25,7 @@ To enable the rule to check if your script is compatible on PowerShell Core on W
 
 #### PowerShellVersion
 
-The parameter `PowerShellVersion` is a list of whitelists that ship with PSScriptAnalyzer.
+The parameter `PowerShellVersion` is a list of allowlists that ship with PSScriptAnalyzer.
 
 **Note**: The default value for `PowerShellVersion` is `"core-6.1.0-windows"` if PowerShell 6 or later is installed, and `"desktop-5.1.14393.206-windows"` if it is not.
 
diff --git a/RuleDocumentation/AvoidUsingCmdletAliases.md b/RuleDocumentation/AvoidUsingCmdletAliases.md
@@ -18,9 +18,9 @@ The use of full command names also allows for syntax highlighting in sites and a
 
 Use the full cmdlet name and not an alias.
 
-## Alias Whitelist
+## Alias Allowlist
 
-To prevent `PSScriptAnalyzer` from flagging your preferred aliases, create a whitelist of the aliases in your settings file and point `PSScriptAnalyzer` to use the settings file. For example, to disable `PSScriptAnalyzer` from flagging `cd`, which is an alias of `Set-Location`, set the settings file content to the following.
+To prevent `PSScriptAnalyzer` from flagging your preferred aliases, create an allowlist of the aliases in your settings file and point `PSScriptAnalyzer` to use the settings file. For example, to disable `PSScriptAnalyzer` from flagging `cd`, which is an alias of `Set-Location`, set the settings file content to the following.
 
 ```PowerShell
 # PSScriptAnalyzerSettings.psd1
diff --git a/RuleDocumentation/UseCompatibleCmdlets.md b/RuleDocumentation/UseCompatibleCmdlets.md
@@ -4,7 +4,7 @@
 
 ## Description
 
-This rule flags cmdlets that are not available in a given Edition/Version of PowerShell on a given Operating System. It works by comparing a cmdlet against a set of whitelists which ship with PSScriptAnalyzer. They can be found at `/path/to/PSScriptAnalyzerModule/Settings`. These files are of the form, `PSEDITION-PSVERSION-OS.json` where `PSEDITION` can be either `Core` or `Desktop`, `OS` can be either `Windows`, `Linux` or `MacOS`, and `Version` is the PowerShell version. To enable the rule to check if your script is compatible on PowerShell Core on windows, put the following your settings file:
+This rule flags cmdlets that are not available in a given Edition/Version of PowerShell on a given Operating System. It works by comparing a cmdlet against a set of allowlists which ship with PSScriptAnalyzer. They can be found at `/path/to/PSScriptAnalyzerModule/Settings`. These files are of the form, `PSEDITION-PSVERSION-OS.json` where `PSEDITION` can be either `Core` or `Desktop`, `OS` can be either `Windows`, `Linux` or `MacOS`, and `Version` is the PowerShell version. To enable the rule to check if your script is compatible on PowerShell Core on windows, put the following your settings file:
 
 ```PowerShell
 @{
diff --git a/Rules/AvoidAlias.cs b/Rules/AvoidAlias.cs
@@ -22,13 +22,11 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules
 #endif
     public class AvoidAlias : IScriptRule
     {
-        private readonly string whiteListArgName = "whitelist";
+        private readonly string allowListArgName = "allowlist";
+        // keep legacy argument name for next version to allow customers to transition but remove later
+        private readonly string allowListLegacyArgName = "whitelist";
         private bool isPropertiesSet;
-        private List<string> whiteList;
-        public List<string> WhiteList
-        {
-            get { return whiteList; }
-        }
+        public List<string> AllowList { get; private set; }
 
         public AvoidAlias()
         {
@@ -38,22 +36,27 @@ public AvoidAlias()
         /// <summary>
         /// Configure the rule.
         ///
-        /// Sets the whitelist of this rule
+        /// Sets the allowlist of this rule
         /// </summary>
         private void SetProperties()
         {
-            whiteList = new List<string>();
+            AllowList = new List<string>();
             isPropertiesSet = true;
             Dictionary<string, object> ruleArgs = Helper.Instance.GetRuleArguments(GetName());
             if (ruleArgs == null)
             {
                 return;
             }
-            object obj;
-            if (!ruleArgs.TryGetValue(whiteListArgName, out obj))
+            object objLegacy = null;
+            if (!ruleArgs.TryGetValue(allowListArgName, out object obj) &&
+                !ruleArgs.TryGetValue(allowListLegacyArgName, out objLegacy))
             {
                 return;
             }
+            // Fallback for object from legacy allowlist argument name 
+            if (obj == null) {
+                obj = objLegacy;
+            }
             IEnumerable<string> aliases = obj as IEnumerable<string>;
             if (aliases == null)
             {
@@ -72,13 +75,13 @@ private void SetProperties()
                     }
                     else
                     {
-                        whiteList.Add(y);
+                        AllowList.Add(y);
                     }
                 }
             }
             else
             {
-                whiteList.AddRange(aliases);
+                AllowList.AddRange(aliases);
             }
         }
 
@@ -110,7 +113,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
                 // You can also review the remark section in following document,
                 // MSDN: CommandAst.GetCommandName Method
                 if (commandName == null
-                    || whiteList.Contains<string>(commandName, StringComparer.OrdinalIgnoreCase))
+                    || AllowList.Contains<string>(commandName, StringComparer.OrdinalIgnoreCase))
                 {
                     continue;
                 }
diff --git a/Rules/AvoidUserNameAndPasswordParams.cs b/Rules/AvoidUserNameAndPasswordParams.cs
@@ -36,7 +36,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
 
             List<String> passwords = new List<String>() {"Password", "Passphrase"};
             List<String> usernames = new List<String>() { "Username", "User"};
-            Type[] typeWhiteList = {typeof(CredentialAttribute),
+            Type[] typeAllowList = {typeof(CredentialAttribute),
                                             typeof(PSCredential),
                                             typeof(System.Security.SecureString),
                                             typeof(SwitchParameter),
@@ -54,7 +54,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
                 // Iterates all ParamAsts and check if their names are on the list.
                 foreach (ParameterAst paramAst in paramAsts)
                 {
-                    var attributes = typeWhiteList.Select(x => GetAttributeOfType(paramAst.Attributes, x));
+                    var attributes = typeAllowList.Select(x => GetAttributeOfType(paramAst.Attributes, x));
                     String paramName = paramAst.Name.VariablePath.ToString();                    
                     foreach (String password in passwords)
                     {
diff --git a/Rules/ProvideCommentHelp.cs b/Rules/ProvideCommentHelp.cs
@@ -264,13 +264,13 @@ private void GetCorrectionPosition(
 
         private class ViolationFinder : AstVisitor
         {
-            private HashSet<string> functionWhitelist;
+            private HashSet<string> functionAllowList;
             private List<FunctionDefinitionAst> functionDefinitionAsts;
-            private bool useFunctionWhitelist;
+            private bool useFunctionAllowList;
 
             public ViolationFinder()
             {
-                functionWhitelist = new HashSet<string>();
+                functionAllowList = new HashSet<string>();
                 functionDefinitionAsts = new List<FunctionDefinitionAst>();
             }
 
@@ -281,12 +281,12 @@ public ViolationFinder(HashSet<string> exportedFunctions) : this()
                     throw new ArgumentNullException(nameof(exportedFunctions));
                 }
 
-                this.functionWhitelist = exportedFunctions;
+                this.functionAllowList = exportedFunctions;
             }
 
             public ViolationFinder(HashSet<string> exportedFunctions, bool exportedOnly) : this(exportedFunctions)
             {
-                this.useFunctionWhitelist = exportedOnly;
+                this.useFunctionAllowList = exportedOnly;
             }
 
             public IEnumerable<FunctionDefinitionAst> FunctionDefinitionAsts
@@ -299,7 +299,7 @@ public IEnumerable<FunctionDefinitionAst> FunctionDefinitionAsts
 
             public override AstVisitAction VisitFunctionDefinition(FunctionDefinitionAst funcAst)
             {
-                if ((!useFunctionWhitelist || functionWhitelist.Contains(funcAst.Name))
+                if ((!useFunctionAllowList || functionAllowList.Contains(funcAst.Name))
                     && funcAst.GetHelpContent() == null)
                 {
                     functionDefinitionAsts.Add(funcAst);
diff --git a/Rules/UseCompatibleCmdlets.cs b/Rules/UseCompatibleCmdlets.cs
@@ -498,7 +498,7 @@ private bool RuleParamsValid(Dictionary<string, object> ruleArgs)
         }
 
         /// <summary>
-        /// Check if current command is present in the whitelists
+        /// Check if current command is present in the allowlists
         /// If not, flag the corresponding value in curCmdletCompatibilityMap
         /// </summary>
         private void CheckCompatibility()
diff --git a/Rules/UseConsistentWhitespace.cs b/Rules/UseConsistentWhitespace.cs
@@ -26,7 +26,7 @@ private enum ErrorKind { BeforeOpeningBrace, Paren, Operator, SeparatorComma, Se
             AfterOpeningBrace, BeforeClosingBrace, BeforePipe, AfterPipe, BetweenParameter };
         private const int whiteSpaceSize = 1;
         private const string whiteSpace = " ";
-        private readonly SortedSet<TokenKind> openParenKeywordWhitelist = new SortedSet<TokenKind>()
+        private readonly SortedSet<TokenKind> openParenKeywordAllowList = new SortedSet<TokenKind>()
         {
             TokenKind.If,
             TokenKind.ElseIf,
@@ -474,7 +474,7 @@ private DiagnosticRecord getDiagnosticRecord(
 
         private bool IsKeyword(Token token)
         {
-            return openParenKeywordWhitelist.Contains(token.Kind);
+            return openParenKeywordAllowList.Contains(token.Kind);
         }
 
         private static bool IsPreviousTokenApartByWhitespace(LinkedListNode<Token> tokenNode)
diff --git a/Rules/UseSingularNouns.cs b/Rules/UseSingularNouns.cs
@@ -28,7 +28,7 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules
     [Export(typeof(IScriptRule))]
     public class CmdletSingularNoun : IScriptRule {
 
-        private readonly string[] nounWhiteList =
+        private readonly string[] nounAllowList =
         {
             "Data"
         };
@@ -68,7 +68,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName) {
                     if (!ps.IsSingular(noun) && ps.IsPlural(noun))
                     {
                         IScriptExtent extent = Helper.Instance.GetScriptExtentForFunctionName(funcAst);
-                        if (nounWhiteList.Contains(noun, StringComparer.OrdinalIgnoreCase))
+                        if (nounAllowList.Contains(noun, StringComparer.OrdinalIgnoreCase))
                         {
                             continue;
                         }
diff --git a/Tests/Engine/ModuleHelp.Tests.ps1 b/Tests/Engine/ModuleHelp.Tests.ps1
@@ -58,7 +58,7 @@ $RequiredVersion = (Get-Command Invoke-ScriptAnalyzer).Module.Version
 
 $ms = $null
 $commands = $null
-$paramBlackList = @(
+$paramBlockList = @(
 	'AttachAndDebug' # Reason: When building with DEGUG configuration, an additional parameter 'AttachAndDebug' will be added to Invoke-ScriptAnalyzer and Invoke-Formatter, but there is no Help for those, as they are not intended for production usage.
 )
 [string] $ModuleName = 'PSScriptAnalyzer'
@@ -89,11 +89,11 @@ $testCases = $commands.ForEach{
 
 
 BeforeAll {
-	$paramBlackList = @(
+	$paramBlockList = @(
 		'AttachAndDebug' # Reason: When building with DEGUG configuration, an additional parameter 'AttachAndDebug' will be added to Invoke-ScriptAnalyzer and Invoke-Formatter, but there is no Help for those, as they are not intended for production usage.
 	)
 	if ($PSVersionTable.PSVersion -lt '5.0') {
-		$paramBlackList += 'SaveDscDependency'
+		$paramBlockList += 'SaveDscDependency'
 	}
 }
 
@@ -217,7 +217,7 @@ Describe 'Cmdlet parameter help' {
 		$HelpParameterNames = $Help.Parameters.Parameter.Name | Sort-Object -Unique
 
 		foreach ($parameter in $parameters) {
-			if ($parameter.Name -in $paramBlackList) {
+			if ($parameter.Name -in $paramBlockList) {
 				continue
 			}
 			$parameterName = $parameter.Name
@@ -242,7 +242,7 @@ Describe 'Cmdlet parameter help' {
 		}
 
 		foreach ($helpParam in $HelpParameterNames) {
-			if ($helpParam -in $paramBlackList) {
+			if ($helpParam -in $paramBlockList) {
 				continue
 			}
 			$helpParam -in $parameterNames | Should -BeTrue -Because "There should be no extra parameters in help. '$helpParam' was not in '$parameterNames'"
diff --git a/Tests/Engine/Settings.tests.ps1 b/Tests/Engine/Settings.tests.ps1
@@ -79,7 +79,32 @@ Describe "Settings Class" {
         }
     }
 
-    Context "When rule arguments are provided in a hashtable" {
+    Context 'When rule arguments are provided in a hashtable' {
+        BeforeAll {
+            $settingsHashtable = @{
+                Rules = @{
+                    PSAvoidUsingCmdletAliases = @{
+                        AllowList = @('cd', 'cp')
+                    }
+                }
+            }
+            $settings = New-Object -TypeName $settingsTypeName -ArgumentList $settingsHashtable
+        }
+
+        It 'Should return the rule arguments' {
+            $settings.RuleArguments['PSAvoidUsingCmdletAliases']['AllowList'].Count | Should -Be 2
+            $settings.RuleArguments['PSAvoidUsingCmdletAliases']['AllowList'][0] | Should -Be 'cd'
+            $settings.RuleArguments['PSAvoidUsingCmdletAliases']['AllowList'][1] | Should -Be 'cp'
+        }
+
+        It 'Should Be case insensitive' {
+            $settings.RuleArguments['psAvoidUsingCmdletAliases']['AllowList'].Count | Should -Be 2
+            $settings.RuleArguments['psAvoidUsingCmdletAliases']['AllowList'][0] | Should -Be 'cd'
+            $settings.RuleArguments['psAvoidUsingCmdletAliases']['AllowList'][1] | Should -Be 'cp'
+        }
+    }
+
+    Context 'When rule arguments are provided in a hashtable (legacy argument name)' {
         BeforeAll {
             $settingsHashtable = @{
                 Rules = @{
diff --git a/Tests/Engine/SettingsTest/Issue828/PSScriptAnalyzerSettings.psd1 b/Tests/Engine/SettingsTest/Issue828/PSScriptAnalyzerSettings.psd1
@@ -1,7 +1,7 @@
 @{
     Severity     = @(
-        'Error', 
-        'Warning', 
+        'Error',
+        'Warning',
         'Information'
     )
     ExcludeRules = @(
@@ -14,7 +14,7 @@
             CheckHashtable = $true
         }
         PSAvoidUsingCmdletAliases  = @{
-            # only whitelist verbs from *-Object cmdlets
+            # only allowlist verbs from *-Object cmdlets
             Whitelist = @(
                 '%',
                 '?',
diff --git a/Tests/Rules/AvoidUsingAlias.tests.ps1 b/Tests/Rules/AvoidUsingAlias.tests.ps1
@@ -67,9 +67,9 @@ Configuration MyDscConfiguration {
         }
     }
 
-    Context "Settings file provides whitelist" {
+    Context "Settings file provides allowlist" {
         BeforeAll {
-            $whiteListTestScriptDef = 'gci; cd;'
+            $allowListTestScriptDef = 'gci; cd;'
             $settings = @{
                 'Rules' = @{
                     'PSAvoidUsingCmdletAliases' = @{
@@ -79,26 +79,26 @@ Configuration MyDscConfiguration {
             }
         }
 
-        It "honors the whitelist provided as hashtable" {
+        It "honors the allowlist provided as hashtable" {
             $settings = @{
                 'Rules' = @{
                     'PSAvoidUsingCmdletAliases' = @{
                         'Whitelist' = @('cd')
                     }
                 }
             }
-            $violations = Invoke-ScriptAnalyzer -ScriptDefinition $whiteListTestScriptDef -Settings $settings -IncludeRule $violationName
+            $violations = Invoke-ScriptAnalyzer -ScriptDefinition $allowListTestScriptDef -Settings $settings -IncludeRule $violationName
             $violations.Count | Should -Be 1
         }
 
-        It "honors the whitelist provided through settings file" {
+        It "honors the allowlist provided through settings file" {
             # even though join-path returns string, if we do not use tostring, then invoke-scriptanalyzer cannot cast it to string type
             $settingsFilePath = (Join-Path $PSScriptRoot (Join-Path 'TestSettings' 'AvoidAliasSettings.psd1')).ToString()
-            $violations = Invoke-ScriptAnalyzer -ScriptDefinition $whiteListTestScriptDef -Settings $settingsFilePath -IncludeRule $violationName
+            $violations = Invoke-ScriptAnalyzer -ScriptDefinition $allowListTestScriptDef -Settings $settingsFilePath -IncludeRule $violationName
             $violations.Count | Should -Be 1
         }
 
-        It "honors the whitelist in a case-insensitive manner" {
+        It "honors the allowlist in a case-insensitive manner" {
             $violations = Invoke-ScriptAnalyzer -ScriptDefinition "CD" -Settings $settings -IncludeRule $violationName
             $violations.Count | Should -Be 0
         }
diff --git a/Tests/Rules/UseSingularNounsReservedVerbs.tests.ps1 b/Tests/Rules/UseSingularNounsReservedVerbs.tests.ps1
@@ -30,7 +30,7 @@ Describe "UseSingularNouns" -Skip:$IsCoreCLR {
         }
     }
 
-    Context "When function names have nouns from whitelist" {
+    Context "When function names have nouns from allowlist" {
 
         It "ignores function name ending with Data" {
             $nounViolationScript = @'

Original file line number	Diff line number	Diff line change
`@@ -22,13 +22,11 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules`
`22`	`22`	`#endif`
`23`	`23`	`public class AvoidAlias : IScriptRule`
`24`	`24`	`{`
`25`		`- private readonly string whiteListArgName = "whitelist";`
	`25`	`+ private readonly string allowListArgName = "allowlist";`
	`26`	`+ // keep legacy argument name for next version to allow customers to transition but remove later`
	`27`	`+ private readonly string allowListLegacyArgName = "whitelist";`
`26`	`28`	`private bool isPropertiesSet;`
`27`		`- private List<string> whiteList;`
`28`		`- public List<string> WhiteList`
`29`		`- {`
`30`		`- get { return whiteList; }`
`31`		`- }`
	`29`	`+ public List<string> AllowList { get; private set; }`
`32`	`30`
`33`	`31`	`public AvoidAlias()`
`34`	`32`	`{`
`@@ -38,22 +36,27 @@ public AvoidAlias()`
`38`	`36`	`/// <summary>`
`39`	`37`	`/// Configure the rule.`
`40`	`38`	`///`
`41`		`- /// Sets the whitelist of this rule`
	`39`	`+ /// Sets the allowlist of this rule`
`42`	`40`	`/// </summary>`
`43`	`41`	`private void SetProperties()`
`44`	`42`	`{`
`45`		`- whiteList = new List<string>();`
	`43`	`+ AllowList = new List<string>();`
`46`	`44`	`isPropertiesSet = true;`
`47`	`45`	`Dictionary<string, object> ruleArgs = Helper.Instance.GetRuleArguments(GetName());`
`48`	`46`	`if (ruleArgs == null)`
`49`	`47`	`{`
`50`	`48`	`return;`
`51`	`49`	`}`
`52`		`- object obj;`
`53`		`- if (!ruleArgs.TryGetValue(whiteListArgName, out obj))`
	`50`	`+ object objLegacy = null;`
	`51`	`+ if (!ruleArgs.TryGetValue(allowListArgName, out object obj) &&`
	`52`	`+ !ruleArgs.TryGetValue(allowListLegacyArgName, out objLegacy))`
`54`	`53`	`{`
`55`	`54`	`return;`
`56`	`55`	`}`
	`56`	`+ // Fallback for object from legacy allowlist argument name`
	`57`	`+ if (obj == null) {`
	`58`	`+ obj = objLegacy;`
	`59`	`+ }`
`57`	`60`	`IEnumerable<string> aliases = obj as IEnumerable<string>;`
`58`	`61`	`if (aliases == null)`
`59`	`62`	`{`
`@@ -72,13 +75,13 @@ private void SetProperties()`
`72`	`75`	`}`
`73`	`76`	`else`
`74`	`77`	`{`
`75`		`- whiteList.Add(y);`
	`78`	`+ AllowList.Add(y);`
`76`	`79`	`}`
`77`	`80`	`}`
`78`	`81`	`}`
`79`	`82`	`else`
`80`	`83`	`{`
`81`		`- whiteList.AddRange(aliases);`
	`84`	`+ AllowList.AddRange(aliases);`
`82`	`85`	`}`
`83`	`86`	`}`
`84`	`87`
`@@ -110,7 +113,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)`
`110`	`113`	`// You can also review the remark section in following document,`
`111`	`114`	`// MSDN: CommandAst.GetCommandName Method`
`112`	`115`	`if (commandName == null`
`113`		`- \|\| whiteList.Contains<string>(commandName, StringComparer.OrdinalIgnoreCase))`
	`116`	`+ \|\| AllowList.Contains<string>(commandName, StringComparer.OrdinalIgnoreCase))`
`114`	`117`	`{`
`115`	`118`	`continue;`
`116`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -264,13 +264,13 @@ private void GetCorrectionPosition(`
`264`	`264`
`265`	`265`	`private class ViolationFinder : AstVisitor`
`266`	`266`	`{`
`267`		`- private HashSet<string> functionWhitelist;`
	`267`	`+ private HashSet<string> functionAllowList;`
`268`	`268`	`private List<FunctionDefinitionAst> functionDefinitionAsts;`
`269`		`- private bool useFunctionWhitelist;`
	`269`	`+ private bool useFunctionAllowList;`
`270`	`270`
`271`	`271`	`public ViolationFinder()`
`272`	`272`	`{`
`273`		`- functionWhitelist = new HashSet<string>();`
	`273`	`+ functionAllowList = new HashSet<string>();`
`274`	`274`	`functionDefinitionAsts = new List<FunctionDefinitionAst>();`
`275`	`275`	`}`
`276`	`276`
`@@ -281,12 +281,12 @@ public ViolationFinder(HashSet<string> exportedFunctions) : this()`
`281`	`281`	`throw new ArgumentNullException(nameof(exportedFunctions));`
`282`	`282`	`}`
`283`	`283`
`284`		`- this.functionWhitelist = exportedFunctions;`
	`284`	`+ this.functionAllowList = exportedFunctions;`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`public ViolationFinder(HashSet<string> exportedFunctions, bool exportedOnly) : this(exportedFunctions)`
`288`	`288`	`{`
`289`		`- this.useFunctionWhitelist = exportedOnly;`
	`289`	`+ this.useFunctionAllowList = exportedOnly;`
`290`	`290`	`}`
`291`	`291`
`292`	`292`	`public IEnumerable<FunctionDefinitionAst> FunctionDefinitionAsts`
`@@ -299,7 +299,7 @@ public IEnumerable<FunctionDefinitionAst> FunctionDefinitionAsts`
`299`	`299`
`300`	`300`	`public override AstVisitAction VisitFunctionDefinition(FunctionDefinitionAst funcAst)`
`301`	`301`	`{`
`302`		`- if ((!useFunctionWhitelist \|\| functionWhitelist.Contains(funcAst.Name))`
	`302`	`+ if ((!useFunctionAllowList \|\| functionAllowList.Contains(funcAst.Name))`
`303`	`303`	`&& funcAst.GetHelpContent() == null)`
`304`	`304`	`{`
`305`	`305`	`functionDefinitionAsts.Add(funcAst);`
Original file line number	Diff line number	Diff line change
`@@ -498,7 +498,7 @@ private bool RuleParamsValid(Dictionary<string, object> ruleArgs)`
`498`	`498`	`}`
`499`	`499`
`500`	`500`	`/// <summary>`
`501`		`- /// Check if current command is present in the whitelists`
	`501`	`+ /// Check if current command is present in the allowlists`
`502`	`502`	`/// If not, flag the corresponding value in curCmdletCompatibilityMap`
`503`	`503`	`/// </summary>`
`504`	`504`	`private void CheckCompatibility()`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ private enum ErrorKind { BeforeOpeningBrace, Paren, Operator, SeparatorComma, Se`
`26`	`26`	`AfterOpeningBrace, BeforeClosingBrace, BeforePipe, AfterPipe, BetweenParameter };`
`27`	`27`	`private const int whiteSpaceSize = 1;`
`28`	`28`	`private const string whiteSpace = " ";`
`29`		`- private readonly SortedSet<TokenKind> openParenKeywordWhitelist = new SortedSet<TokenKind>()`
	`29`	`+ private readonly SortedSet<TokenKind> openParenKeywordAllowList = new SortedSet<TokenKind>()`
`30`	`30`	`{`
`31`	`31`	`TokenKind.If,`
`32`	`32`	`TokenKind.ElseIf,`
`@@ -474,7 +474,7 @@ private DiagnosticRecord getDiagnosticRecord(`
`474`	`474`
`475`	`475`	`private bool IsKeyword(Token token)`
`476`	`476`	`{`
`477`		`- return openParenKeywordWhitelist.Contains(token.Kind);`
	`477`	`+ return openParenKeywordAllowList.Contains(token.Kind);`
`478`	`478`	`}`
`479`	`479`
`480`	`480`	`private static bool IsPreviousTokenApartByWhitespace(LinkedListNode<Token> tokenNode)`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules`
`28`	`28`	`[Export(typeof(IScriptRule))]`
`29`	`29`	`public class CmdletSingularNoun : IScriptRule {`
`30`	`30`
`31`		`- private readonly string[] nounWhiteList =`
	`31`	`+ private readonly string[] nounAllowList =`
`32`	`32`	`{`
`33`	`33`	`"Data"`
`34`	`34`	`};`
`@@ -68,7 +68,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName) {`
`68`	`68`	`if (!ps.IsSingular(noun) && ps.IsPlural(noun))`
`69`	`69`	`{`
`70`	`70`	`IScriptExtent extent = Helper.Instance.GetScriptExtentForFunctionName(funcAst);`
`71`		`- if (nounWhiteList.Contains(noun, StringComparer.OrdinalIgnoreCase))`
	`71`	`+ if (nounAllowList.Contains(noun, StringComparer.OrdinalIgnoreCase))`
`72`	`72`	`{`
`73`	`73`	`continue;`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ $RequiredVersion = (Get-Command Invoke-ScriptAnalyzer).Module.Version`
`58`	`58`
`59`	`59`	`$ms = $null`
`60`	`60`	`$commands = $null`
`61`		`-$paramBlackList = @(`
	`61`	`+$paramBlockList = @(`
`62`	`62`	`'AttachAndDebug' # Reason: When building with DEGUG configuration, an additional parameter 'AttachAndDebug' will be added to Invoke-ScriptAnalyzer and Invoke-Formatter, but there is no Help for those, as they are not intended for production usage.`
`63`	`63`	`)`
`64`	`64`	`[string] $ModuleName = 'PSScriptAnalyzer'`
`@@ -89,11 +89,11 @@ $testCases = $commands.ForEach{`
`89`	`89`
`90`	`90`
`91`	`91`	`BeforeAll {`
`92`		`- $paramBlackList = @(`
	`92`	`+ $paramBlockList = @(`
`93`	`93`	`'AttachAndDebug' # Reason: When building with DEGUG configuration, an additional parameter 'AttachAndDebug' will be added to Invoke-ScriptAnalyzer and Invoke-Formatter, but there is no Help for those, as they are not intended for production usage.`
`94`	`94`	`)`
`95`	`95`	`if ($PSVersionTable.PSVersion -lt '5.0') {`
`96`		`- $paramBlackList += 'SaveDscDependency'`
	`96`	`+ $paramBlockList += 'SaveDscDependency'`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`
`@@ -217,7 +217,7 @@ Describe 'Cmdlet parameter help' {`
`217`	`217`	`$HelpParameterNames = $Help.Parameters.Parameter.Name \| Sort-Object -Unique`
`218`	`218`
`219`	`219`	`foreach ($parameter in $parameters) {`
`220`		`- if ($parameter.Name -in $paramBlackList) {`
	`220`	`+ if ($parameter.Name -in $paramBlockList) {`
`221`	`221`	`continue`
`222`	`222`	`}`
`223`	`223`	`$parameterName = $parameter.Name`
`@@ -242,7 +242,7 @@ Describe 'Cmdlet parameter help' {`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`foreach ($helpParam in $HelpParameterNames) {`
`245`		`- if ($helpParam -in $paramBlackList) {`
	`245`	`+ if ($helpParam -in $paramBlockList) {`
`246`	`246`	`continue`
`247`	`247`	`}`
`248`	`248`	`$helpParam -in $parameterNames \| Should -BeTrue -Because "There should be no extra parameters in help. '$helpParam' was not in '$parameterNames'"`
Original file line number	Diff line number	Diff line change
`@@ -67,9 +67,9 @@ Configuration MyDscConfiguration {`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`- Context "Settings file provides whitelist" {`
	`70`	`+ Context "Settings file provides allowlist" {`
`71`	`71`	`BeforeAll {`
`72`		`- $whiteListTestScriptDef = 'gci; cd;'`
	`72`	`+ $allowListTestScriptDef = 'gci; cd;'`
`73`	`73`	`$settings = @{`
`74`	`74`	`'Rules' = @{`
`75`	`75`	`'PSAvoidUsingCmdletAliases' = @{`
`@@ -79,26 +79,26 @@ Configuration MyDscConfiguration {`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`82`		`- It "honors the whitelist provided as hashtable" {`
	`82`	`+ It "honors the allowlist provided as hashtable" {`
`83`	`83`	`$settings = @{`
`84`	`84`	`'Rules' = @{`
`85`	`85`	`'PSAvoidUsingCmdletAliases' = @{`
`86`	`86`	`'Whitelist' = @('cd')`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`	`}`
`90`		`- $violations = Invoke-ScriptAnalyzer -ScriptDefinition $whiteListTestScriptDef -Settings $settings -IncludeRule $violationName`
	`90`	`+ $violations = Invoke-ScriptAnalyzer -ScriptDefinition $allowListTestScriptDef -Settings $settings -IncludeRule $violationName`
`91`	`91`	`$violations.Count \| Should -Be 1`
`92`	`92`	`}`
`93`	`93`
`94`		`- It "honors the whitelist provided through settings file" {`
	`94`	`+ It "honors the allowlist provided through settings file" {`
`95`	`95`	`# even though join-path returns string, if we do not use tostring, then invoke-scriptanalyzer cannot cast it to string type`
`96`	`96`	`$settingsFilePath = (Join-Path $PSScriptRoot (Join-Path 'TestSettings' 'AvoidAliasSettings.psd1')).ToString()`
`97`		`- $violations = Invoke-ScriptAnalyzer -ScriptDefinition $whiteListTestScriptDef -Settings $settingsFilePath -IncludeRule $violationName`
	`97`	`+ $violations = Invoke-ScriptAnalyzer -ScriptDefinition $allowListTestScriptDef -Settings $settingsFilePath -IncludeRule $violationName`
`98`	`98`	`$violations.Count \| Should -Be 1`
`99`	`99`	`}`
`100`	`100`
`101`		`- It "honors the whitelist in a case-insensitive manner" {`
	`101`	`+ It "honors the allowlist in a case-insensitive manner" {`
`102`	`102`	`$violations = Invoke-ScriptAnalyzer -ScriptDefinition "CD" -Settings $settings -IncludeRule $violationName`
`103`	`103`	`$violations.Count \| Should -Be 0`
`104`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ Describe "UseSingularNouns" -Skip:$IsCoreCLR {`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`		`- Context "When function names have nouns from whitelist" {`
	`33`	`+ Context "When function names have nouns from allowlist" {`
`34`	`34`
`35`	`35`	`It "ignores function name ending with Data" {`
`36`	`36`	`$nounViolationScript = @'`