validate advanced settings input (#3838)

Author: michelleangela

Extension/src/LanguageServer/configurations.ts

@@ -68,6 +68,11 @@ export interface ConfigurationErrors {
     compilerPath?: string;
     includePath?: string;
     intelliSenseMode?: string;
+    macFrameworkPath?: string;
+    forcedInclude?: string;
+    compileCommands?: string;
+    browsePath?: string;
+    databaseFilename?: string;
 }
 
 export interface Browse {
@@ -907,7 +912,6 @@ export class CppProperties {
     private getErrorsForConfigUI(configIndex: number): ConfigurationErrors {
         let errors: ConfigurationErrors = {};
         const isWindows: boolean = os.platform() === 'win32';
-
         let config: Configuration = this.configurationJson.configurations[configIndex];
 
         // Validate compilerPath
@@ -971,51 +975,79 @@ export class CppProperties {
             }
         }
 
-        // Validate includePath
-        let includePathErrors: string[] = [];
-        if (config.includePath) {
-            for (let includePath of config.includePath) {
-                let pathExists: boolean = true;
-                let resolvedIncludePath: string = this.resolvePath(includePath, isWindows);
-                if (!resolvedIncludePath) {
-                    continue;
-                }
+        // Validate paths (directories)
+        errors.includePath = this.validatePath(config.includePath);
+        errors.macFrameworkPath = this.validatePath(config.macFrameworkPath);
+        errors.browsePath = this.validatePath(config.browse ? config.browse.path : undefined);
 
-                // Check if resolved path exists
-                if (!fs.existsSync(resolvedIncludePath)) {
-                    // Check for relative path if resolved path does not exists
-                    const relativePath: string = this.rootUri.fsPath + path.sep + resolvedIncludePath;
-                    if (!fs.existsSync(relativePath)) {
-                        pathExists = false;
-                    } else {
-                        resolvedIncludePath = relativePath;
-                    }
-                }
+        // Validate files
+        errors.forcedInclude = this.validatePath(config.forcedInclude, false);
+        errors.compileCommands = this.validatePath(config.compileCommands, false);
+        errors.databaseFilename = this.validatePath((config.browse ? config.browse.databaseFilename : undefined), false);
 
-                if (!pathExists) {
-                    let message: string = `Cannot find: ${resolvedIncludePath}`;
-                    includePathErrors.push(message);
-                    continue;
-                }
+        // Validate intelliSenseMode
+        if (isWindows && !this.isCompilerIntelliSenseModeCompatible(config)) {
+            errors.intelliSenseMode = `IntelliSense mode ${config.intelliSenseMode} is incompatible with compiler path.`;
+        }
+
+        return errors;
+    }
 
-                // Check if path is a directory
-                if (!util.checkDirectoryExistsSync(resolvedIncludePath)) {
-                    let message: string = `Path is not a directory: ${resolvedIncludePath}`;
-                    includePathErrors.push(message);
+    private validatePath(input: string|string[], isDirectory: boolean = true): string {
+        if (!input) {
+            return undefined;
+        }
+
+        const isWindows: boolean = os.platform() === 'win32';
+        let errorMsg: string = undefined;
+        let errors: string[] = [];
+        let paths: string[] = [];
+
+        if (util.isString(input)) {
+            paths.push(input);
+        } else {
+            paths = input;
+        }
+
+        for (let p of paths) {
+            let pathExists: boolean = true;
+            let resolvedPath: string = this.resolvePath(p, isWindows);
+            if (!resolvedPath) {
+                continue;
+            }
+
+            // Check if resolved path exists
+            if (!fs.existsSync(resolvedPath)) {
+                // Check for relative path if resolved path does not exists
+                const relativePath: string = this.rootUri.fsPath + path.sep + resolvedPath;
+                if (!fs.existsSync(relativePath)) {
+                    pathExists = false;
+                } else {
+                    resolvedPath = relativePath;
                 }
             }
 
-            if (includePathErrors.length > 0) {
-                errors.includePath = includePathErrors.join('\n');
+            if (!pathExists) {
+                let message: string = `Cannot find: ${resolvedPath}`;
+                errors.push(message);
+                continue;
+            }
+
+            // Check if path is a directory or file
+            if (isDirectory && !util.checkDirectoryExistsSync(resolvedPath)) {
+                let message: string = `Path is not a directory: ${resolvedPath}`;
+                errors.push(message);
+            } else if (!isDirectory && !util.checkFileExistsSync(resolvedPath)) {
+                let message: string = `Path is not a file: ${resolvedPath}`;
+                errors.push(message);
             }
         }
 
-        // Validate intelliSenseMode
-        if (isWindows && !this.isCompilerIntelliSenseModeCompatible(config)) {
-            errors.intelliSenseMode = `IntelliSense mode ${config.intelliSenseMode} is incompatible with compiler path.`;
+        if (errors.length > 0) {
+            errorMsg = errors.join('\n');
         }
 
-        return errors;
+        return errorMsg;
     }
 
     private handleSquiggles(): void {

Extension/ui/settings.html

@@ -597,6 +597,7 @@
             <div>
                 <div class="section-note">One path per line.</div>
                 <textarea name="inputValue" id="macFrameworkPath" rows="4" cols="93" style="width: 800px"></textarea>
+                <div id="macFrameworkPathInvalid" class="error" style="margin-top: -4px; width: 794px"></div>
             </div>
         </div>
 
@@ -608,6 +609,7 @@
             <div>
                 <div class="section-note">One file per line.</div>
                 <textarea name="inputValue" id="forcedInclude" rows="4" cols="93" style="width: 800px"></textarea>
+                <div id="forcedIncludeInvalid" class="error" style="margin-top: -4px; width: 794px"></div>
             </div>
         </div>
 
@@ -618,6 +620,7 @@
             </div>
             <div>
                 <input name="inputValue" id="compileCommands" style="width: 798px"></input>
+                <div id="compileCommandsInvalid" class="error" style="width: 800px"></div>
             </div>
         </div>
 
@@ -631,6 +634,7 @@
             <div>
                 <div class="section-note">One browse path per line.</div>
                 <textarea name="inputValue" id="browsePath" rows="4" cols="93" style="width: 800px"></textarea>
+                <div id="browsePathInvalid" class="error" style="margin-top: -4px; width: 794px"></div>
             </div>
         </div>
 
@@ -651,6 +655,7 @@
             </div>
             <div>
                 <input name="inputValue" id="databaseFilename" style="width: 798px"></input>
+                <div id="databaseFilenameInvalid" class="error" style="width: 800px"></div>
             </div>
         </div>
 

Extension/ui/settings.ts

@@ -30,14 +30,19 @@ const elementId: { [key: string]: string } = {
     // Advanced settings
     windowsSdkVersion: "windowsSdkVersion",
     macFrameworkPath: "macFrameworkPath",
+    macFrameworkPathInvalid: "macFrameworkPathInvalid",
     compileCommands: "compileCommands",
+    compileCommandsInvalid: "compileCommandsInvalid",
     configurationProvider: "configurationProvider",
     forcedInclude: "forcedInclude",
+    forcedIncludeInvalid: "forcedIncludeInvalid",
 
     // Browse properties
     browsePath: "browsePath",
+    browsePathInvalid: "browsePathInvalid",
     limitSymbolsToIncludedHeaders: "limitSymbolsToIncludedHeaders",
     databaseFilename: "databaseFilename",
+    databaseFilenameInvalid: "databaseFilenameInvalid",
 
     // Other
     showAdvanced: "showAdvanced",
@@ -288,6 +293,11 @@ class SettingsApp {
             this.showErrorWithInfo(elementId.intelliSenseModeInvalid, errors.intelliSenseMode);
             this.showErrorWithInfo(elementId.compilerPathInvalid, errors.compilerPath);
             this.showErrorWithInfo(elementId.includePathInvalid, errors.includePath);
+            this.showErrorWithInfo(elementId.macFrameworkPathInvalid, errors.macFrameworkPath);
+            this.showErrorWithInfo(elementId.forcedIncludeInvalid, errors.forcedInclude);
+            this.showErrorWithInfo(elementId.compileCommandsInvalid, errors.compileCommands);
+            this.showErrorWithInfo(elementId.browsePathInvalid, errors.browsePath);
+            this.showErrorWithInfo(elementId.databaseFilenameInvalid, errors.databaseFilename);
         } finally {
             this.updating = false;
         }