Merge BugFixes to Master

Engine/Commands/GetScriptAnalyzerRuleCommand.cs

@@ -10,17 +10,14 @@
 // THE SOFTWARE.
 //
 
+using Microsoft.PowerShell.Commands;
 using Microsoft.Windows.Powershell.ScriptAnalyzer.Generic;
 using System;
 using System.Collections.Generic;
-using System.ComponentModel.Composition;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
 using System.Management.Automation;
-using System.Resources;
-using System.Threading;
-using System.Reflection;
 
 namespace Microsoft.Windows.Powershell.ScriptAnalyzer.Commands
 {
@@ -50,12 +47,27 @@ public string[] CustomizedRulePath
         [Parameter(Mandatory = false)]
         [ValidateNotNullOrEmpty]
         [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
-        public string[] Name
+        public string[] RuleName
         {
             get { return name; }
             set { name = value; }
         }
         private string[] name;
+
+        /// <summary>
+        /// Severity: Array of the severity types to be enabled.
+        /// </summary>
+        /// </summary>
+        [ValidateSet("Warning", "Error", "Information", IgnoreCase = true)]
+        [Parameter(Mandatory = false)]
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
+        public string[] Severity
+        {
+            get { return severity; }
+            set { severity = value; }
+        }
+        private string[] severity;
+
         #endregion Parameters
 
         #region Private Members
@@ -128,9 +140,16 @@ protected override void ProcessRecord()
             }
             else
             {
+                if (severity != null)
+                {
+                    var ruleSeverity = severity.Select(item => Enum.Parse(typeof (RuleSeverity), item));
+                    rules = rules.Where(item => ruleSeverity.Contains(item.GetSeverity())).ToList();
+                }
+
                 foreach (IRule rule in rules)
                 {
-                    WriteObject(new RuleInfo(rule.GetName(), rule.GetCommonName(), rule.GetDescription(), rule.GetSourceType(), rule.GetSourceName()));
+                    WriteObject(new RuleInfo(rule.GetName(), rule.GetCommonName(), rule.GetDescription(),
+                        rule.GetSourceType(), rule.GetSourceName(), rule.GetSeverity()));
                 }
             }
         }

Engine/Commands/InvokeScriptAnalyzerCommand.cs

@@ -10,6 +10,7 @@
 // THE SOFTWARE.
 //
 
+using System.Text.RegularExpressions;
 using Microsoft.Windows.Powershell.ScriptAnalyzer.Generic;
 using System;
 using System.Collections.Generic;
@@ -272,7 +273,28 @@ private void AnalyzeFile(string filePath)
             IEnumerable<Ast> funcDefAsts;
 
             // Use a List of KVP rather than dictionary, since for a script containing inline functions with same signature, keys clash
-            List<KeyValuePair<CommandInfo, IScriptExtent>> cmdInfoTable = new List<KeyValuePair<CommandInfo, IScriptExtent>>();            
+            List<KeyValuePair<CommandInfo, IScriptExtent>> cmdInfoTable = new List<KeyValuePair<CommandInfo, IScriptExtent>>();
+
+            //Check wild card input for the Include/ExcludeRules and create regex match patterns
+            List<Regex> includeRegexList = new List<Regex>();
+            List<Regex> excludeRegexList = new List<Regex>();
+            if (includeRule != null)
+            {
+                foreach (string rule in includeRule)
+                {
+                    Regex includeRegex = new Regex(String.Format("^{0}$", Regex.Escape(rule).Replace(@"\*", ".*")), RegexOptions.IgnoreCase);
+                    includeRegexList.Add(includeRegex);
+                }
+            }
+            if (excludeRule != null)
+            {
+                foreach (string rule in excludeRule)
+                {
+                    Regex excludeRegex = new Regex(String.Format("^{0}$", Regex.Escape(rule).Replace(@"\*", ".*")), RegexOptions.IgnoreCase);
+                    excludeRegexList.Add(excludeRegex);
+                }
+            }
+
 
             //Parse the file
             if (File.Exists(filePath))
@@ -316,12 +338,30 @@ private void AnalyzeFile(string filePath)
             #region Run ScriptRules
             //Trim down to the leaf element of the filePath and pass it to Diagnostic Record
             string fileName = System.IO.Path.GetFileName(filePath);
+
             if (ScriptAnalyzer.Instance.ScriptRules != null)
             {
                 foreach (IScriptRule scriptRule in ScriptAnalyzer.Instance.ScriptRules)
                 {
-                    if ((includeRule == null || includeRule.Contains(scriptRule.GetName(), StringComparer.OrdinalIgnoreCase)) && 
-                        (excludeRule == null || !excludeRule.Contains(scriptRule.GetName(), StringComparer.OrdinalIgnoreCase)))
+                    bool includeRegexMatch = false;
+                    bool excludeRegexMatch = false;
+                    foreach (Regex include in includeRegexList)
+                    {
+                        if (include.IsMatch(scriptRule.GetName()))
+                        {
+                            includeRegexMatch = true;
+                            break;
+                        }
+                    }
+                    foreach (Regex exclude in excludeRegexList)
+                    {
+                        if (exclude.IsMatch(scriptRule.GetName()))
+                        {
+                            excludeRegexMatch = true;
+                            break;
+                        }
+                    }
+                    if ((includeRule == null || includeRegexMatch) &&                         (excludeRule == null || !excludeRegexMatch))
                     {
                         WriteVerbose(string.Format(CultureInfo.CurrentCulture, Strings.VerboseRunningMessage, scriptRule.GetName()));
 
@@ -334,7 +374,6 @@ private void AnalyzeFile(string filePath)
                         catch (Exception scriptRuleException)
                         {
                             WriteError(new ErrorRecord(scriptRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, filePath));
-                            continue;
                         }
                     }
                 }
@@ -379,8 +418,25 @@ private void AnalyzeFile(string filePath)
             {
                 foreach (ICommandRule commandRule in ScriptAnalyzer.Instance.CommandRules)
                 {
-                    if ((includeRule == null || includeRule.Contains(commandRule.GetName(), StringComparer.OrdinalIgnoreCase)) &&
-                        (excludeRule == null || !excludeRule.Contains(commandRule.GetName(), StringComparer.OrdinalIgnoreCase)))
+                    bool includeRegexMatch = false;
+                    bool excludeRegexMatch = false;
+                    foreach (Regex include in includeRegexList)
+                    {
+                        if (include.IsMatch(commandRule.GetName()))
+                        {
+                            includeRegexMatch = true;
+                            break;
+                        }
+                    }
+                    foreach (Regex exclude in excludeRegexList)
+                    {
+                        if (exclude.IsMatch(commandRule.GetName()))
+                        {
+                            excludeRegexMatch = true;
+                            break;
+                         }
+                    }
+                    if ((includeRule == null || includeRegexMatch) && (excludeRule == null || !excludeRegexMatch))
                     {
                         foreach (KeyValuePair<CommandInfo, IScriptExtent> commandInfo in cmdInfoTable)
                         {
@@ -395,7 +451,6 @@ private void AnalyzeFile(string filePath)
                             catch (Exception commandRuleException)
                             {
                                 WriteError(new ErrorRecord(commandRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, fileName));
-                                continue;
                             }  
                         }
                     }
@@ -410,8 +465,25 @@ private void AnalyzeFile(string filePath)
             {
                 foreach (ITokenRule tokenRule in ScriptAnalyzer.Instance.TokenRules)
                 {
-                    if ((includeRule == null || includeRule.Contains(tokenRule.GetName(), StringComparer.OrdinalIgnoreCase)) && 
-                        (excludeRule == null || !excludeRule.Contains(tokenRule.GetName(), StringComparer.OrdinalIgnoreCase)))
+                    bool includeRegexMatch = false;
+                    bool excludeRegexMatch = false;
+                    foreach (Regex include in includeRegexList)
+                    {
+                        if (include.IsMatch(tokenRule.GetName()))
+                        {
+                            includeRegexMatch = true;
+                            break;
+                        }
+                    }
+                    foreach (Regex exclude in excludeRegexList)
+                    {
+                        if (exclude.IsMatch(tokenRule.GetName()))
+                        {
+                            excludeRegexMatch = true;
+                            break;
+                        }
+                    }
+                    if ((includeRule == null || includeRegexMatch) && (excludeRule == null  || !excludeRegexMatch))
                     {
                         WriteVerbose(string.Format(CultureInfo.CurrentCulture, Strings.VerboseRunningMessage, tokenRule.GetName()));
 
@@ -424,7 +496,6 @@ private void AnalyzeFile(string filePath)
                         catch (Exception tokenRuleException)
                         {
                             WriteError(new ErrorRecord(tokenRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, fileName));
-                            continue;
                         } 
                     }
                 }
@@ -438,8 +509,25 @@ private void AnalyzeFile(string filePath)
                 // Run DSC Class rule
                 foreach (IDSCResourceRule dscResourceRule in ScriptAnalyzer.Instance.DSCResourceRules)
                 {
-                    if ((includeRule == null || includeRule.Contains(dscResourceRule.GetName(), StringComparer.OrdinalIgnoreCase)) &&
-                        (excludeRule == null || !excludeRule.Contains(dscResourceRule.GetName(), StringComparer.OrdinalIgnoreCase)))
+                    bool includeRegexMatch = false;
+                    bool excludeRegexMatch = false;
+                    foreach (Regex include in includeRegexList)
+                    {
+                        if (include.IsMatch(dscResourceRule.GetName()))
+                        {
+                            includeRegexMatch = true;
+                            break;
+                        }
+                    }
+                    foreach (Regex exclude in excludeRegexList)
+                    {
+                        if (exclude.IsMatch(dscResourceRule.GetName()))
+                        {
+                            excludeRegexMatch = true;
+                            break;
+                        }
+                    }
+                    if ((includeRule == null || includeRegexMatch) && (excludeRule == null || excludeRegexMatch))
                     {
                         WriteVerbose(string.Format(CultureInfo.CurrentCulture, Strings.VerboseRunningMessage, dscResourceRule.GetName()));
 
@@ -452,7 +540,6 @@ private void AnalyzeFile(string filePath)
                         catch (Exception dscResourceRuleException)
                         {
                             WriteError(new ErrorRecord(dscResourceRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, filePath));
-                            continue;
                         }    
                     }
                 }
@@ -480,8 +567,24 @@ private void AnalyzeFile(string filePath)
                                     // Run all DSC Rules
                                     foreach (IDSCResourceRule dscResourceRule in ScriptAnalyzer.Instance.DSCResourceRules)
                                     {
-                                        if ((includeRule == null || includeRule.Contains(dscResourceRule.GetName(), StringComparer.OrdinalIgnoreCase)) &&
-                                            (excludeRule == null || !excludeRule.Contains(dscResourceRule.GetName(), StringComparer.OrdinalIgnoreCase)))
+                                        bool includeRegexMatch = false;
+                                        bool excludeRegexMatch = false;
+                                        foreach (Regex include in includeRegexList)
+                                        {
+                                            if (include.IsMatch(dscResourceRule.GetName()))
+                                            {
+                                                includeRegexMatch = true;
+                                                break;
+                                            }
+                                        }
+                                        foreach (Regex exclude in excludeRegexList)
+                                        {
+                                            if (exclude.IsMatch(dscResourceRule.GetName()))
+                                            {
+                                                excludeRegexMatch = true;
+                                            }
+                                        }
+                                        if ((includeRule == null || includeRegexMatch) && (excludeRule == null || !excludeRegexMatch))
                                         {
                                             WriteVerbose(string.Format(CultureInfo.CurrentCulture, Strings.VerboseRunningMessage, dscResourceRule.GetName()));
 
@@ -494,7 +597,6 @@ private void AnalyzeFile(string filePath)
                                             catch (Exception dscResourceRuleException)
                                             {
                                                 WriteError(new ErrorRecord(dscResourceRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, filePath));
-                                                continue;
                                             }  
                                         }
                                     }

Engine/Generic/AvoidCmdletGeneric.cs

@@ -93,5 +93,11 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
         /// </summary>
         /// <returns>The source type of the rule.</returns>
         public abstract  SourceType GetSourceType();
+
+        /// <summary>
+        /// GetSeverity: Retrieves the severity of the rule: error, warning of information.
+        /// </summary>
+        /// <returns></returns>
+        public abstract RuleSeverity GetSeverity();
     }
 }

Engine/Generic/AvoidParameterGeneric.cs

@@ -104,5 +104,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
         /// </summary>
         /// <returns>The source type of the rule.</returns>
         public abstract  SourceType GetSourceType();
+
+        public abstract RuleSeverity GetSeverity();
     }
 }

Engine/Generic/ExternalRule.cs

@@ -55,6 +55,12 @@ public SourceType GetSourceType()
             return SourceType.Module;
         }
 
+        //Set the community rule level as warning as the current implementation does not require user to specify rule severity when defining their functions in PS scripts
+        public RuleSeverity GetSeverity()
+        {
+            return RuleSeverity.Warning;
+        }
+
         public string GetSourceName()
         {
             return this.srcName;

Engine/Generic/IRule.cs

@@ -10,12 +10,6 @@
 // THE SOFTWARE.
 //
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
 namespace Microsoft.Windows.Powershell.ScriptAnalyzer.Generic
 {
     /// <summary>
@@ -52,5 +46,12 @@ public interface IRule
         /// </summary>
         /// <returns>The source type of the rule.</returns>
         SourceType GetSourceType();
+
+        /// <summary>
+        /// GetSeverity: Retrieves severity of the rule.
+        /// </summary>
+        /// <returns></returns>
+        RuleSeverity GetSeverity();
+
     }
 }

Engine/Generic/RuleInfo.cs

@@ -29,12 +29,13 @@ public class RuleInfo
         private string description;
         private SourceType sourceType;
         private string sourceName;
+        private RuleSeverity ruleSeverity;
 
         /// <summary>
         /// Name: The name of the rule.
         /// </summary>
         [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-        public string Name
+        public string RuleName
         {
             get { return name; }
             private set { name = value; }
@@ -81,6 +82,16 @@ public string SourceName
             private set { sourceName = value; }
         }
 
+        /// <summary>
+        /// Severity : The severity of the rule violation.
+        /// </summary>
+        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        public RuleSeverity Severity
+        {
+            get { return ruleSeverity; }
+            private set { ruleSeverity = value; }
+        }
+
         /// <summary>
         /// Constructor for a RuleInfo.
         /// </summary>
@@ -89,13 +100,14 @@ public string SourceName
         /// <param name="description">Description of the rule.</param>
         /// <param name="sourceType">Source type of the rule.</param>
         /// <param name="sourceName">Source name of the rule.</param>
-        public RuleInfo(string name, string commonName, string description, SourceType sourceType, string sourceName)
+        public RuleInfo(string name, string commonName, string description, SourceType sourceType, string sourceName, RuleSeverity severity)
         {
-            Name        = name;
+            RuleName        = name;
             CommonName  = commonName;
             Description = description;
             SourceType  = sourceType;
             SourceName  = sourceName;
+            Severity = severity;
         }
     }
 }