Move some methods to Helper class

Refactors and moves some methods from UseShouldProcessForStateChangingFunctions to Helper class to allow reusability. These methods can potentially be used by other rules that deal with the SupportShouldProcess attribute.

Author: Kapil Borle

Engine/Helper.cs

@@ -1329,6 +1329,134 @@ public static string[] ProcessCustomRulePaths(string[] rulePaths, SessionState s
 
         }
 
+        /// <summary>
+        /// Check if the function name starts with one of potentailly state changing verbs
+        /// </summary>
+        /// <param name="functionName"></param>
+        /// <returns>true if the function name starts with a state changing verb, otherwise false</returns>
+        public bool IsStateChangingFunctionName(string functionName)
+        {
+            if (functionName == null)
+            {
+                throw new ArgumentNullException("functionName");
+            }
+            // Array of verbs that can potentially change the state of a system
+            string[] stateChangingVerbs =
+            {
+                "Restart-",
+                "Stop-",
+                "New-",
+                "Set-",
+                "Update-",
+                "Reset-",
+                "Remove-"
+            };
+            foreach (var verb in stateChangingVerbs)
+            {
+                if (functionName.StartsWith(verb, StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Get the SupportShouldProcess attribute ast
+        /// </summary>
+        /// <param name="attributeAsts"></param>
+        /// <returns>Returns SupportShouldProcess attribute ast if it exists, otherwise returns null</returns>
+        public NamedAttributeArgumentAst GetShouldProcessAttributeAst(IEnumerable<AttributeAst> attributeAsts)
+        {
+            if (attributeAsts == null)
+            {
+                throw new ArgumentNullException("attributeAsts");
+            }
+            var cmdletBindingAttributeAst = this.GetCmdletBindingAttributeAst(attributeAsts);
+            if (cmdletBindingAttributeAst == null
+                || cmdletBindingAttributeAst.NamedArguments == null)
+            {
+                return null;
+            }
+            foreach (var namedAttributeAst in cmdletBindingAttributeAst.NamedArguments)
+            {
+                if (namedAttributeAst != null
+                    && namedAttributeAst.ArgumentName.Equals(
+                        "SupportsShouldProcess",
+                        StringComparison.OrdinalIgnoreCase))
+                {
+                    return namedAttributeAst;
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Get the CmdletBinding attribute ast
+        /// </summary>
+        /// <param name="attributeAsts"></param>
+        /// <returns>Returns CmdletBinding attribute ast if it exists, otherwise returns null</returns>
+        public AttributeAst GetCmdletBindingAttributeAst(IEnumerable<AttributeAst> attributeAsts)
+        {
+            if (attributeAsts == null)
+            {
+                throw new ArgumentNullException("attributeAsts");
+            }
+            foreach (var attributeAst in attributeAsts)
+            {
+                if (attributeAst == null || attributeAst.NamedArguments == null)
+                {
+                    continue;
+                }
+                if (attributeAst.TypeName.GetReflectionAttributeType()
+                    == typeof(CmdletBindingAttribute))
+                {
+                    return attributeAst;
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Get the boolean value of the named attribute argument
+        /// </summary>
+        /// <param name="namedAttributeArgumentAst"></param>
+        /// <returns>Boolean value of the named attribute argument</returns>
+        public bool GetNamedArgumentAttributeValue(NamedAttributeArgumentAst namedAttributeArgumentAst)
+        {
+            if (namedAttributeArgumentAst == null)
+            {
+                throw new ArgumentNullException("namedAttributeArgumentAst");
+            }
+            if (namedAttributeArgumentAst.ExpressionOmitted)
+            {
+                return true;
+            }
+            else
+            {
+                var varExpAst = namedAttributeArgumentAst.Argument as VariableExpressionAst;
+                if (varExpAst == null)
+                {
+                    var constExpAst = namedAttributeArgumentAst.Argument as ConstantExpressionAst;
+                    if (constExpAst == null)
+                    {
+                        return false;
+                    }
+                    bool constExpVal;
+                    if (LanguagePrimitives.TryConvertTo<bool>(constExpAst.Value, out constExpVal))
+                    {
+                        return constExpVal;
+                    }
+                }
+                else if (varExpAst.VariablePath.UserPath.Equals(
+                    bool.TrueString,
+                    StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
 
         #endregion
     }

Rules/UseShouldProcessForStateChangingFunctions.cs

@@ -75,88 +75,25 @@ private bool IsStateChangingFunctionWithNoShouldProcessAttribute(Ast ast)
             {
                 return false;
             }
-            string funcName = funcDefAst.Name;
-            var targetFuncName = this.stateChangingVerbs.Where(
-                elem => funcName.StartsWith(
-                    elem,
-                    StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
-            if (targetFuncName == null                
-                || funcDefAst.Body.ParamBlock == null
-                || funcDefAst.Body.ParamBlock.Attributes == null)
-            {
-                return false;
-            }
-            return !HasShouldProcessTrue(funcDefAst.Body.ParamBlock.Attributes);
+            return Helper.Instance.IsStateChangingFunctionName(funcDefAst.Name) 
+                    && (funcDefAst.Body.ParamBlock == null
+                        || funcDefAst.Body.ParamBlock.Attributes == null
+                        || !HasShouldProcessTrue(funcDefAst.Body.ParamBlock.Attributes));
         }
-        
+
         /// <summary>
         /// Checks if an attribute has SupportShouldProcess set to $true
         /// </summary>
         /// <param name="attributeAsts"></param>
         /// <returns>Returns true or false</returns>
         private bool HasShouldProcessTrue(IEnumerable<AttributeAst> attributeAsts)
         {
-            foreach (var attributeAst in attributeAsts)
-            {                
-                if (attributeAst == null || attributeAst.NamedArguments == null)
-                {
-                    continue;
-                }
-                if (attributeAst.TypeName.GetReflectionAttributeType() 
-                    == typeof(CmdletBindingAttribute))
-                {
-                    foreach (var namedAttributeAst in attributeAst.NamedArguments)
-                    {
-                        if (namedAttributeAst == null
-                            || !namedAttributeAst.ArgumentName.Equals(
-                                "SupportsShouldProcess", 
-                                StringComparison.OrdinalIgnoreCase))
-                        {
-                            continue;
-                        }
-                        return IsShouldProcessTrue(namedAttributeAst);                        
-                    }
-                }
-            }
-            // Cannot find any SupportShouldProcess attribute   
-            return false;
-        }
-
-        /// <summary>
-        /// Checks if the SupportShouldProcess attribute is true
-        /// </summary>
-        /// <param name="namedAttributeArgumentAst"></param>
-        /// <returns>Returns true or false</returns>
-        private bool IsShouldProcessTrue(NamedAttributeArgumentAst namedAttributeArgumentAst)
-        {
-            if (namedAttributeArgumentAst.ExpressionOmitted)
+            var shouldProcessAttributeAst = Helper.Instance.GetShouldProcessAttributeAst(attributeAsts);
+            if (shouldProcessAttributeAst == null)
             {
-                return true;
-            }
-            else
-            {
-                var varExpAst = namedAttributeArgumentAst.Argument as VariableExpressionAst;
-                if (varExpAst == null)
-                {
-                    var constExpAst = namedAttributeArgumentAst.Argument as ConstantExpressionAst;
-                    if (constExpAst == null)
-                    {
-                        return false;
-                    }
-                    bool constExpVal;
-                    if (LanguagePrimitives.TryConvertTo<bool>(constExpAst.Value, out constExpVal))
-                    {
-                        return constExpVal;
-                    }                    
-                }
-                else if (varExpAst.VariablePath.UserPath.Equals(
-                    bool.TrueString, 
-                    StringComparison.OrdinalIgnoreCase))
-                {
-                    return true;
-                }                
+                return false;
             }
-            return false;
+            return Helper.Instance.GetNamedArgumentAttributeValue(shouldProcessAttributeAst);
         }
 
         /// <summary>