Extract rules from settings hashtable type input

Author: Kapil Borle

Engine/ScriptAnalyzer.cs

@@ -412,18 +412,19 @@ private Dictionary<string, object> GetDictionaryFromHashTableAst(
             return output;
         }
 
-        private bool ParseProfileHashtable(Hashtable profile, PathIntrinsics path, IOutputWriter writer,
-            List<string> severityList, List<string> includeRuleList, List<string> excludeRuleList)
+        /// <summary>
+        /// Recursively convert hashtable to dictionary
+        /// </summary>
+        /// <param name="hashtable"></param>
+        /// <returns>Dictionary that maps string to object</returns>
+        private Dictionary<string, object> GetDictionaryFromHashtable(
+            Hashtable hashtable,
+            IOutputWriter writer,
+            out bool hasError)
         {
-            bool hasError = false;
-
-            HashSet<string> validKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-            validKeys.Add("severity");
-            validKeys.Add("includerules");
-            validKeys.Add("excluderules");
-            validKeys.Add("rules");
-
-            foreach (var obj in profile.Keys)
+            var dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+            hasError = false;
+            foreach (var obj in hashtable.Keys)
             {
                 string key = obj as string;
                 if (key == null)
@@ -433,13 +434,64 @@ private bool ParseProfileHashtable(Hashtable profile, PathIntrinsics path, IOutp
                             new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.KeyNotString, key)),
                             Strings.ConfigurationKeyNotAString,
                             ErrorCategory.InvalidData,
-                            profile));
+                            hashtable));
                     hasError = true;
-                    continue;
+                    return null;
+                }
+                var valueHashtableObj = hashtable[obj];
+                if (valueHashtableObj == null)
+                {
+                    writer.WriteError(
+                        new ErrorRecord(
+                            new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, valueHashtableObj, key)),
+                            Strings.WrongConfigurationKey,
+                            ErrorCategory.InvalidData,
+                            hashtable));
+                    hasError = true;
+                    return null;
+                }
+                var valueHashtable = valueHashtableObj as Hashtable;
+                if (valueHashtable == null)
+                {
+                    dictionary.Add(key, valueHashtableObj);
+                }
+                else
+                {
+                    var dict = GetDictionaryFromHashtable(valueHashtable, writer, out hasError);
+                    if (dict != null)
+                    {
+                        dictionary.Add(key, dict);
+                    }
+                    else
+                    {
+                        return null;
+                    }
                 }
 
-                key = key.ToLower();
-                object value = profile[obj];
+            }
+            return dictionary;
+        }
+
+        private bool ParseProfileHashtable(Hashtable profile, PathIntrinsics path, IOutputWriter writer,
+            List<string> severityList, List<string> includeRuleList, List<string> excludeRuleList)
+        {
+            bool hasError = false;
+
+            HashSet<string> validKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            validKeys.Add("severity");
+            validKeys.Add("includerules");
+            validKeys.Add("excluderules");
+            validKeys.Add("rules");
+
+            settings = GetDictionaryFromHashtable(profile, writer, out hasError);
+            if (hasError)
+            {
+                return hasError;
+            }
+            foreach (var settingKey in settings.Keys)
+            {
+                var key = settingKey.ToLower();
+                object value = settings[key];
                 switch (key)
                 {
                     case "severity":
@@ -496,19 +548,6 @@ private bool ParseProfileHashtable(Hashtable profile, PathIntrinsics path, IOutp
                         break;
 
                     case "rules":
-                        var ruleDict = value as Dictionary<string, object>;
-                        if (ruleDict == null)
-                        {
-                            writer.WriteError(
-                                new ErrorRecord(
-                                    new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, value, key)),
-                                    Strings.WrongConfigurationKey,
-                                    ErrorCategory.InvalidData,
-                                    profile));
-                            hasError = true;
-                            break;
-                        }
-                        settings[key] = ruleDict;
                         break;
 
                     default: