Localize settings related error messages

Kapil Borle · Kapil Borle · commit 9375ac373196 · 2017-02-28T11:26:26.000-08:00
diff --git a/Engine/Commands/InvokeScriptAnalyzerCommand.cs b/Engine/Commands/InvokeScriptAnalyzerCommand.cs
@@ -248,25 +248,37 @@ protected override void BeginProcessing()
                 case SettingsMode.Auto:
                     this.WriteVerbose(
                         String.Format(
-                            "Settings not provided. Will look for settings file in the given path {0}.",
+                            CultureInfo.CurrentCulture,
+                            Strings.SettingsNotProvided,
                             path));
                     this.WriteVerbose(
                         String.Format(
-                            "Found {0}. Will use it to provide settings for this invocation.",
+                            CultureInfo.CurrentCulture,
+                            Strings.SettingsAutoDiscovered,
                             (string)settingsFound));
                     break;
 
                 case SettingsMode.Preset:
                 case SettingsMode.File:
-                    this.WriteVerbose(String.Format("Using settings file at {0}", (string)settingsFound));
+                    this.WriteVerbose(
+                        String.Format(
+                            CultureInfo.CurrentCulture,
+                            Strings.SettingsUsingFile,
+                            (string)settingsFound));
                     break;
 
                 case SettingsMode.Hashtable:
-                    this.WriteVerbose(String.Format("Using settings hashtable."));
+                    this.WriteVerbose(
+                        String.Format(
+                            CultureInfo.CurrentCulture,
+                            Strings.SettingsUsingHashtable));
                     break;
 
                 default: // case SettingsMode.None
-                    this.WriteVerbose(String.Format("Cannot find a settings file."));
+                    this.WriteVerbose(
+                        String.Format(
+                            CultureInfo.CurrentCulture,
+                            Strings.SettingsCannotFindFile));
                     break;
             }
 
@@ -279,7 +291,7 @@ protected override void BeginProcessing()
                 }
                 catch
                 {
-                        this.WriteWarning("Cannot parse settings. Will abort the invocation.");
+                        this.WriteWarning(String.Format(CultureInfo.CurrentCulture, Strings.SettingsNotParsable));
                         stopProcessing = true;
                         return;
                 }
@@ -318,7 +330,8 @@ protected override void ProcessRecord()
                         ScriptAnalyzer.Instance.ModuleHandler = moduleHandler;
                         this.WriteVerbose(
                             String.Format(
-                                "Temporary module location: {0}",
+                                CultureInfo.CurrentCulture,
+                                Strings.ModuleDepHandlerTempLocation,
                                 moduleHandler.TempModulePath));
                         ProcessInput();
                     }
diff --git a/Engine/Generic/Settings.cs b/Engine/Generic/Settings.cs
@@ -69,7 +69,11 @@ public Settings(object settings, Func<string, string> presetResolver)
                 }
                 else
                 {
-                    throw new ArgumentException(String.Format("File does not exist: {0}", settingsFilePath));
+                    throw new ArgumentException(
+                        String.Format(
+                            CultureInfo.CurrentCulture,
+                            Strings.InvalidPath,
+                            settingsFilePath));
                 }
             }
             else
@@ -81,7 +85,7 @@ public Settings(object settings, Func<string, string> presetResolver)
                 }
                 else
                 {
-                    throw new ArgumentException("Input object should either be a string or a hashtable");
+                    throw new ArgumentException(Strings.SettingsInvalidType);
                 }
             }
         }
@@ -168,29 +172,24 @@ private Dictionary<string, object> GetDictionaryFromHashtable(Hashtable hashtabl
                 string key = obj as string;
                 if (key == null)
                 {
-                    // TODO localize
-                    throw new InvalidDataException("key not string");
-                    // writer.WriteError(
-                    //     new ErrorRecord(
-                    //         new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.KeyNotString, key)),
-                    //         Strings.ConfigurationKeyNotAString,
-                    //         ErrorCategory.InvalidData,
-                    //         hashtable));
-                    // hasError = true;
+                    throw new InvalidDataException(
+                        string.Format(
+                            CultureInfo.CurrentCulture,
+                            Strings.KeyNotString,
+                            key));
                 }
+
                 var valueHashtableObj = hashtable[obj];
                 if (valueHashtableObj == null)
                 {
-                    throw new InvalidDataException("wrong hash table value");
-                    // writer.WriteError(
-                    //     new ErrorRecord(
-                    //         new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, valueHashtableObj, key)),
-                    //         Strings.WrongConfigurationKey,
-                    //         ErrorCategory.InvalidData,
-                    //         hashtable));
-                    // hasError = true;
-                    // return null;
+                    throw new InvalidDataException(
+                        string.Format(
+                            CultureInfo.CurrentCulture,
+                            Strings.WrongValueHashTable,
+                            "",
+                            key));
                 }
+
                 var valueHashtable = valueHashtableObj as Hashtable;
                 if (valueHashtable == null)
                 {
@@ -221,17 +220,11 @@ private List<string> GetData(object val, string key)
             if (val == null)
             {
                 throw new InvalidDataException(
-                    String.Format(
-                        "value should be a string or string array for {0} key",
+                    string.Format(
+                        CultureInfo.CurrentCulture,
+                        Strings.WrongValueHashTable,
+                        "",
                         key));
-                // writer.WriteError(
-                //     new ErrorRecord(
-                //         new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, value, key)),
-                //         Strings.WrongConfigurationKey,
-                //         ErrorCategory.InvalidData,
-                //         profile));
-                // hasError = true;
-                // break;
             }
 
             List<string> values = new List<string>();
@@ -260,21 +253,23 @@ private List<string> GetData(object val, string key)
                         }
                         else
                         {
-                            throw new InvalidDataException("array items should be of string type");
-                            // writer.WriteError(
-                            //     new ErrorRecord(
-                            //         new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, val, key)),
-                            //         Strings.WrongConfigurationKey,
-                            //         ErrorCategory.InvalidData,
-                            //         profile));
-                            // hasError = true;
-                            // break;
+                            throw new InvalidDataException(
+                                string.Format(
+                                    CultureInfo.CurrentCulture,
+                                    Strings.WrongValueHashTable,
+                                    val,
+                                    key));
                         }
                     }
                 }
                 else
                 {
-                    throw new InvalidDataException("array items should be of string type");
+                    throw new InvalidDataException(
+                            string.Format(
+                                CultureInfo.CurrentCulture,
+                                Strings.WrongValueHashTable,
+                                val,
+                                key));
                 }
             }
 
@@ -285,21 +280,17 @@ private List<string> GetData(object val, string key)
         /// Sets the arguments for consumption by rules
         /// </summary>
         /// <param name="ruleArgs">A hashtable with rule names as keys</param>
-        private  Dictionary<string, Dictionary<string, object>> ConvertToRuleArgumentType(object ruleArguments)
+        private Dictionary<string, Dictionary<string, object>> ConvertToRuleArgumentType(object ruleArguments)
         {
             var ruleArgs = ruleArguments as Dictionary<string, object>;
             if (ruleArgs == null)
             {
-                throw new ArgumentException(
-                    "input should be a dictionary",
-                    "ruleArguments");
+                throw new ArgumentException(Strings.SettingsInputShouldBeDictionary, nameof(ruleArguments));
             }
 
             if (ruleArgs.Comparer != StringComparer.OrdinalIgnoreCase)
             {
-                throw new ArgumentException(
-                    "Input dictionary should have OrdinalIgnoreCase comparer.",
-                    "ruleArguments");
+                throw new ArgumentException(Strings.SettingsDictionaryShouldBeCaseInsesitive, nameof(ruleArguments));
             }
 
             var ruleArgsDict = new Dictionary<string, Dictionary<string, object>>(StringComparer.OrdinalIgnoreCase);
@@ -308,9 +299,7 @@ private  Dictionary<string, Dictionary<string, object>> ConvertToRuleArgumentTyp
                 var argsDict = ruleArgs[rule] as Dictionary<string, object>;
                 if (argsDict == null)
                 {
-                    throw new ArgumentException(
-                        "input should be a dictionary",
-                        "ruleArguments");
+                    throw new InvalidDataException(Strings.SettingsInputShouldBeDictionary);
                 }
                 ruleArgsDict[rule] = argsDict;
             }
@@ -341,19 +330,25 @@ private void parseSettingsHashtable(Hashtable settingsHashtable)
                         break;
 
                     case "rules":
-                        ruleArguments = ConvertToRuleArgumentType(val);
+                        try
+                        {
+                            ruleArguments = ConvertToRuleArgumentType(val);
+                        }
+                        catch (ArgumentException argumentException)
+                        {
+                            throw new InvalidDataException(
+                                string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, "", key),
+                                argumentException);
+                        }
+
                         break;
 
                     default:
-                        throw new InvalidDataException(String.Format("Invalid key: {0}", key));
-                        // writer.WriteError(
-                        //     new ErrorRecord(
-                        //         new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongKeyHashTable, key)),
-                        //         Strings.WrongConfigurationKey,
-                        //         ErrorCategory.InvalidData,
-                        //         profile));
-                        // hasError = true;
-                        // break;
+                        throw new InvalidDataException(
+                            string.Format(
+                                CultureInfo.CurrentCulture,
+                                Strings.WrongKeyHashTable,
+                                key));
                 }
             }
         }
@@ -368,10 +363,7 @@ private void parseSettingsFile(string settingsFilePath)
             // no hashtable, raise warning
             if (hashTableAsts.Count() == 0)
             {
-                throw new ArgumentException("Given file does not contain a hashtable");
-                // writer.WriteError(new ErrorRecord(new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.InvalidProfile, profile)),
-                //     Strings.ConfigurationFileHasNoHashTable, ErrorCategory.ResourceUnavailable, profile));
-                // hasError = true;
+                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.InvalidProfile, settingsFilePath));
             }
 
             HashtableAst hashTableAst = hashTableAsts.First() as HashtableAst;
@@ -384,12 +376,16 @@ private void parseSettingsFile(string settingsFilePath)
             }
             catch (InvalidOperationException e)
             {
-                throw new ArgumentException("input file has invalid hashtable", e);
+                throw new ArgumentException(Strings.InvalidProfile, e);
             }
 
             if (hashtable == null)
             {
-                throw new ArgumentException("input file has invalid hashtable");
+                throw new ArgumentException(
+                    String.Format(
+                        CultureInfo.CurrentCulture,
+                        Strings.InvalidProfile,
+                        settingsFilePath));
             }
 
             parseSettingsHashtable(hashtable);
diff --git a/Engine/Strings.resx b/Engine/Strings.resx
@@ -244,7 +244,37 @@
     <value>{0} is not a valid key in the settings hashtable. Valid keys are ExcludeRules, IncludeRules and Severity.</value>
   </data>
   <data name="WrongValueHashTable" xml:space="preserve">
-    <value>Value {0} for key {1} has the wrong data type. Value in the settings hashtable should be a string or an array of strings.</value>
+    <value>Value {0} for key {1} has the wrong data type.</value>
+  </data>
+  <data name="SettingsInputShouldBeDictionary" xml:space="preserve">
+    <value>Input should be a dictionary type.</value>
+  </data>
+  <data name="SettingsDictionaryShouldBeCaseInsesitive" xml:space="preserve">
+    <value>Dictionary should be indexable in a case-insensitive manner.</value>
+  </data>
+  <data name="SettingsInvalidType" xml:space="preserve">
+    <value>Settings should be either a file path, built-in preset or a hashtable.</value>
+  </data>
+  <data name="SettingsNotProvided" xml:space="preserve">
+    <value>Settings not provided. Will look for settings file in the given path {0}.</value>
+  </data>
+  <data name="SettingsAutoDiscovered" xml:space="preserve">
+    <value>Found {0}. Will use it to provide settings for this invocation.</value>
+  </data>
+  <data name="SettingsUsingFile" xml:space="preserve">
+    <value>Using settings file at {0}.</value>
+  </data>
+  <data name="SettingsUsingHashtable" xml:space="preserve">
+    <value>Using settings hashtable.</value>
+  </data>
+  <data name="SettingsCannotFindFile" xml:space="preserve">
+    <value>Cannot find a settings file.</value>
+  </data>
+  <data name="SettingsNotParsable" xml:space="preserve">
+    <value>Cannot parse settings. Will abort the invocation.</value>
+  </data>
+  <data name="ModuleDepHandlerTempLocation" xml:space="preserve">
+    <value>Temporary module location: {0}.</value>
   </data>
   <data name="DigraphVertexAlreadyExists" xml:space="preserve">
     <value>Vertex {0} already exists! Cannot add it to the digraph.</value>

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,11 @@ public Settings(object settings, Func<string, string> presetResolver)`
`69`	`69`	`}`
`70`	`70`	`else`
`71`	`71`	`{`
`72`		`- throw new ArgumentException(String.Format("File does not exist: {0}", settingsFilePath));`
	`72`	`+ throw new ArgumentException(`
	`73`	`+ String.Format(`
	`74`	`+ CultureInfo.CurrentCulture,`
	`75`	`+ Strings.InvalidPath,`
	`76`	`+ settingsFilePath));`
`73`	`77`	`}`
`74`	`78`	`}`
`75`	`79`	`else`
`@@ -81,7 +85,7 @@ public Settings(object settings, Func<string, string> presetResolver)`
`81`	`85`	`}`
`82`	`86`	`else`
`83`	`87`	`{`
`84`		`- throw new ArgumentException("Input object should either be a string or a hashtable");`
	`88`	`+ throw new ArgumentException(Strings.SettingsInvalidType);`
`85`	`89`	`}`
`86`	`90`	`}`
`87`	`91`	`}`
`@@ -168,29 +172,24 @@ private Dictionary<string, object> GetDictionaryFromHashtable(Hashtable hashtabl`
`168`	`172`	`string key = obj as string;`
`169`	`173`	`if (key == null)`
`170`	`174`	`{`
`171`		`- // TODO localize`
`172`		`- throw new InvalidDataException("key not string");`
`173`		`- // writer.WriteError(`
`174`		`- // new ErrorRecord(`
`175`		`- // new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.KeyNotString, key)),`
`176`		`- // Strings.ConfigurationKeyNotAString,`
`177`		`- // ErrorCategory.InvalidData,`
`178`		`- // hashtable));`
`179`		`- // hasError = true;`
	`175`	`+ throw new InvalidDataException(`
	`176`	`+ string.Format(`
	`177`	`+ CultureInfo.CurrentCulture,`
	`178`	`+ Strings.KeyNotString,`
	`179`	`+ key));`
`180`	`180`	`}`
	`181`	`+`
`181`	`182`	`var valueHashtableObj = hashtable[obj];`
`182`	`183`	`if (valueHashtableObj == null)`
`183`	`184`	`{`
`184`		`- throw new InvalidDataException("wrong hash table value");`
`185`		`- // writer.WriteError(`
`186`		`- // new ErrorRecord(`
`187`		`- // new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, valueHashtableObj, key)),`
`188`		`- // Strings.WrongConfigurationKey,`
`189`		`- // ErrorCategory.InvalidData,`
`190`		`- // hashtable));`
`191`		`- // hasError = true;`
`192`		`- // return null;`
	`185`	`+ throw new InvalidDataException(`
	`186`	`+ string.Format(`
	`187`	`+ CultureInfo.CurrentCulture,`
	`188`	`+ Strings.WrongValueHashTable,`
	`189`	`+ "",`
	`190`	`+ key));`
`193`	`191`	`}`
	`192`	`+`
`194`	`193`	`var valueHashtable = valueHashtableObj as Hashtable;`
`195`	`194`	`if (valueHashtable == null)`
`196`	`195`	`{`
`@@ -221,17 +220,11 @@ private List<string> GetData(object val, string key)`
`221`	`220`	`if (val == null)`
`222`	`221`	`{`
`223`	`222`	`throw new InvalidDataException(`
`224`		`- String.Format(`
`225`		`- "value should be a string or string array for {0} key",`
	`223`	`+ string.Format(`
	`224`	`+ CultureInfo.CurrentCulture,`
	`225`	`+ Strings.WrongValueHashTable,`
	`226`	`+ "",`
`226`	`227`	`key));`
`227`		`- // writer.WriteError(`
`228`		`- // new ErrorRecord(`
`229`		`- // new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, value, key)),`
`230`		`- // Strings.WrongConfigurationKey,`
`231`		`- // ErrorCategory.InvalidData,`
`232`		`- // profile));`
`233`		`- // hasError = true;`
`234`		`- // break;`
`235`	`228`	`}`
`236`	`229`
`237`	`230`	`List<string> values = new List<string>();`
`@@ -260,21 +253,23 @@ private List<string> GetData(object val, string key)`
`260`	`253`	`}`
`261`	`254`	`else`
`262`	`255`	`{`
`263`		`- throw new InvalidDataException("array items should be of string type");`
`264`		`- // writer.WriteError(`
`265`		`- // new ErrorRecord(`
`266`		`- // new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, val, key)),`
`267`		`- // Strings.WrongConfigurationKey,`
`268`		`- // ErrorCategory.InvalidData,`
`269`		`- // profile));`
`270`		`- // hasError = true;`
`271`		`- // break;`
	`256`	`+ throw new InvalidDataException(`
	`257`	`+ string.Format(`
	`258`	`+ CultureInfo.CurrentCulture,`
	`259`	`+ Strings.WrongValueHashTable,`
	`260`	`+ val,`
	`261`	`+ key));`
`272`	`262`	`}`
`273`	`263`	`}`
`274`	`264`	`}`
`275`	`265`	`else`
`276`	`266`	`{`
`277`		`- throw new InvalidDataException("array items should be of string type");`
	`267`	`+ throw new InvalidDataException(`
	`268`	`+ string.Format(`
	`269`	`+ CultureInfo.CurrentCulture,`
	`270`	`+ Strings.WrongValueHashTable,`
	`271`	`+ val,`
	`272`	`+ key));`
`278`	`273`	`}`
`279`	`274`	`}`
`280`	`275`
`@@ -285,21 +280,17 @@ private List<string> GetData(object val, string key)`
`285`	`280`	`/// Sets the arguments for consumption by rules`
`286`	`281`	`/// </summary>`
`287`	`282`	`/// <param name="ruleArgs">A hashtable with rule names as keys</param>`
`288`		`- private Dictionary<string, Dictionary<string, object>> ConvertToRuleArgumentType(object ruleArguments)`
	`283`	`+ private Dictionary<string, Dictionary<string, object>> ConvertToRuleArgumentType(object ruleArguments)`
`289`	`284`	`{`
`290`	`285`	`var ruleArgs = ruleArguments as Dictionary<string, object>;`
`291`	`286`	`if (ruleArgs == null)`
`292`	`287`	`{`
`293`		`- throw new ArgumentException(`
`294`		`- "input should be a dictionary",`
`295`		`- "ruleArguments");`
	`288`	`+ throw new ArgumentException(Strings.SettingsInputShouldBeDictionary, nameof(ruleArguments));`
`296`	`289`	`}`
`297`	`290`
`298`	`291`	`if (ruleArgs.Comparer != StringComparer.OrdinalIgnoreCase)`
`299`	`292`	`{`
`300`		`- throw new ArgumentException(`
`301`		`- "Input dictionary should have OrdinalIgnoreCase comparer.",`
`302`		`- "ruleArguments");`
	`293`	`+ throw new ArgumentException(Strings.SettingsDictionaryShouldBeCaseInsesitive, nameof(ruleArguments));`
`303`	`294`	`}`
`304`	`295`
`305`	`296`	`var ruleArgsDict = new Dictionary<string, Dictionary<string, object>>(StringComparer.OrdinalIgnoreCase);`
`@@ -308,9 +299,7 @@ private Dictionary<string, Dictionary<string, object>> ConvertToRuleArgumentTyp`
`308`	`299`	`var argsDict = ruleArgs[rule] as Dictionary<string, object>;`
`309`	`300`	`if (argsDict == null)`
`310`	`301`	`{`
`311`		`- throw new ArgumentException(`
`312`		`- "input should be a dictionary",`
`313`		`- "ruleArguments");`
	`302`	`+ throw new InvalidDataException(Strings.SettingsInputShouldBeDictionary);`
`314`	`303`	`}`
`315`	`304`	`ruleArgsDict[rule] = argsDict;`
`316`	`305`	`}`
`@@ -341,19 +330,25 @@ private void parseSettingsHashtable(Hashtable settingsHashtable)`
`341`	`330`	`break;`
`342`	`331`
`343`	`332`	`case "rules":`
`344`		`- ruleArguments = ConvertToRuleArgumentType(val);`
	`333`	`+ try`
	`334`	`+ {`
	`335`	`+ ruleArguments = ConvertToRuleArgumentType(val);`
	`336`	`+ }`
	`337`	`+ catch (ArgumentException argumentException)`
	`338`	`+ {`
	`339`	`+ throw new InvalidDataException(`
	`340`	`+ string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, "", key),`
	`341`	`+ argumentException);`
	`342`	`+ }`
	`343`	`+`
`345`	`344`	`break;`
`346`	`345`
`347`	`346`	`default:`
`348`		`- throw new InvalidDataException(String.Format("Invalid key: {0}", key));`
`349`		`- // writer.WriteError(`
`350`		`- // new ErrorRecord(`
`351`		`- // new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongKeyHashTable, key)),`
`352`		`- // Strings.WrongConfigurationKey,`
`353`		`- // ErrorCategory.InvalidData,`
`354`		`- // profile));`
`355`		`- // hasError = true;`
`356`		`- // break;`
	`347`	`+ throw new InvalidDataException(`
	`348`	`+ string.Format(`
	`349`	`+ CultureInfo.CurrentCulture,`
	`350`	`+ Strings.WrongKeyHashTable,`
	`351`	`+ key));`
`357`	`352`	`}`
`358`	`353`	`}`
`359`	`354`	`}`
`@@ -368,10 +363,7 @@ private void parseSettingsFile(string settingsFilePath)`
`368`	`363`	`// no hashtable, raise warning`
`369`	`364`	`if (hashTableAsts.Count() == 0)`
`370`	`365`	`{`
`371`		`- throw new ArgumentException("Given file does not contain a hashtable");`
`372`		`- // writer.WriteError(new ErrorRecord(new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.InvalidProfile, profile)),`
`373`		`- // Strings.ConfigurationFileHasNoHashTable, ErrorCategory.ResourceUnavailable, profile));`
`374`		`- // hasError = true;`
	`366`	`+ throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.InvalidProfile, settingsFilePath));`
`375`	`367`	`}`
`376`	`368`
`377`	`369`	`HashtableAst hashTableAst = hashTableAsts.First() as HashtableAst;`
`@@ -384,12 +376,16 @@ private void parseSettingsFile(string settingsFilePath)`
`384`	`376`	`}`
`385`	`377`	`catch (InvalidOperationException e)`
`386`	`378`	`{`
`387`		`- throw new ArgumentException("input file has invalid hashtable", e);`
	`379`	`+ throw new ArgumentException(Strings.InvalidProfile, e);`
`388`	`380`	`}`
`389`	`381`
`390`	`382`	`if (hashtable == null)`
`391`	`383`	`{`
`392`		`- throw new ArgumentException("input file has invalid hashtable");`
	`384`	`+ throw new ArgumentException(`
	`385`	`+ String.Format(`
	`386`	`+ CultureInfo.CurrentCulture,`
	`387`	`+ Strings.InvalidProfile,`
	`388`	`+ settingsFilePath));`
`393`	`389`	`}`
`394`	`390`
`395`	`391`	`parseSettingsHashtable(hashtable);`