Adding OptionsSchema generation (#1937)

* Adding OptionsSchema generation

This is to prevent repetitive fields from being copy and pasted
improperly.

* Move tslint to be after compile

* Address PR issues

Author: WardenGnaw

.travis.yml

@@ -31,8 +31,8 @@ script:
   # Build and then run tests
   - cd Extension
   - npm install
-  - npm run tslint
   - npm run compile
+  - npm run tslint
   # pr-check needs to run before test. test modifies package.json.
   - npm run pr-check
   - npm run test

Extension/.vscodeignore

@@ -11,4 +11,5 @@ CMakeLists.txt
 debugAdapters/install.lock*
 out/src/Debugger/copyScript.js
 tools/**
+out/tools/**
 notices/**

Extension/gulpfile.js

@@ -10,6 +10,7 @@ const env = require('gulp-env')
 const tslint = require('gulp-tslint');
 const mocha = require('gulp-mocha');
 const fs = require('fs');
+const optionsSchemaGenerator = require('./out/tools/GenerateOptionsSchema');
 
 gulp.task('allTests', () => {
     gulp.start('unitTests');
@@ -82,4 +83,8 @@ gulp.task('pr-check', () => {
         console.log('Please make sure to not check in package.json that has been rewritten by the extension activation. If you intended to have changes in package.json, please only check-in your changes. If you did not, please run `git checkout -- package.json`.');
         process.exit(1);
     }
+});
+
+gulp.task('generateOptionsSchema', () => {
+    optionsSchemaGenerator.GenerateOptionsSchema();
 });

Extension/package.json

@@ -533,6 +533,7 @@
         },
         "configurationAttributes": {
           "launch": {
+            "type": "object",
             "required": [
               "program"
             ],
@@ -719,8 +720,8 @@
                 }
               },
               "logging": {
-                "type": "object",
                 "description": "Optional flags to determine what types of messages should be logged to the Debug Console.",
+                "type": "object",
                 "default": {},
                 "properties": {
                   "exceptions": {
@@ -759,10 +760,10 @@
                 "description": "When present, this tells the debugger to connect to a remote computer using another executable as a pipe that will relay standard input/output between VS Code and the MI-enabled debugger backend executable (such as gdb).",
                 "type": "object",
                 "default": {
-                  "pipeCwd": "${workspaceRoot}",
+                  "pipeCwd": "/usr/bin",
                   "pipeProgram": "enter the fully qualified path for the pipe program name, for example '/usr/bin/ssh'",
                   "pipeArgs": [],
-                  "debuggerPath": "enter the path for the debugger on the target machine, for example /usr/bin/gdb"
+                  "debuggerPath": "The full path to the debugger on the target machine, for example /usr/bin/gdb."
                 },
                 "properties": {
                   "pipeCwd": {
@@ -801,6 +802,7 @@
             }
           },
           "attach": {
+            "type": "object",
             "required": [
               "program",
               "processId"
@@ -883,8 +885,8 @@
                 }
               },
               "logging": {
-                "type": "object",
                 "description": "Optional flags to determine what types of messages should be logged to the Debug Console.",
+                "type": "object",
                 "default": {},
                 "properties": {
                   "exceptions": {
@@ -923,10 +925,10 @@
                 "description": "When present, this tells the debugger to connect to a remote computer using another executable as a pipe that will relay standard input/output between VS Code and the MI-enabled debugger backend executable (such as gdb).",
                 "type": "object",
                 "default": {
-                  "pipeCwd": "${workspaceRoot}",
+                  "pipeCwd": "/usr/bin",
                   "pipeProgram": "enter the fully qualified path for the pipe program name, for example '/usr/bin/ssh'",
                   "pipeArgs": [],
-                  "debuggerPath": "enter the path for the debugger on the target machine, for example /usr/bin/gdb"
+                  "debuggerPath": "The full path to the debugger on the target machine, for example /usr/bin/gdb."
                 },
                 "properties": {
                   "pipeCwd": {
@@ -1007,6 +1009,7 @@
         },
         "configurationAttributes": {
           "launch": {
+            "type": "object",
             "required": [
               "program",
               "cwd"
@@ -1109,6 +1112,7 @@
             }
           },
           "attach": {
+            "type": "object",
             "required": [
               "processId"
             ],
@@ -1272,6 +1276,7 @@
   },
   "scripts": {
     "compile": "npm run vscode:prepublish",
+    "generateOptionsSchema": "gulp generateOptionsSchema",
     "integrationTests": "gulp integrationTests",
     "postinstall": "node ./node_modules/vscode/bin/install",
     "pretest": "tsc -p ./",

Extension/tools/GenerateOptionsSchema.ts

@@ -0,0 +1,133 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'fs';
+import * as os from 'os';
+
+function AppendFieldsToObject(reference: any, obj: any) {
+
+    // Make sure it is an object type
+    if (typeof obj == 'object') {
+        for (let referenceKey in reference) {
+            // If key exists in original object and is an object. 
+            if (obj.hasOwnProperty(referenceKey)) {
+                obj[referenceKey] = AppendFieldsToObject(reference[referenceKey], obj[referenceKey]);
+            } else {
+                // Does not exist in current object context
+                obj[referenceKey] = reference[referenceKey];
+            }
+        }
+    }
+
+    return obj;
+}
+
+// Combines two object's fields, giving the parentDefault a higher precedence. 
+function MergeDefaults(parentDefault: any, childDefault: any) {
+    let newDefault: any = {};
+
+    for (let attrname in childDefault) {
+        newDefault[attrname] = childDefault[attrname];
+    }
+
+    for (let attrname in parentDefault) {
+        newDefault[attrname] = parentDefault[attrname];
+    }
+
+    return newDefault;
+}
+
+function UpdateDefaults(object: any, defaults: any) {
+    if (defaults != null) {
+        for (let key in object) {
+            if (object[key].hasOwnProperty('type') && object[key].type === 'object' && object[key].properties !== null) {
+                object[key].properties = UpdateDefaults(object[key].properties, MergeDefaults(defaults, object[key].default));
+            } else if (key in defaults) {
+                object[key].default = defaults[key];
+            }
+        }
+    }
+
+    return object;
+}
+
+function RefReplace(definitions: any, ref: any): any {
+// $ref is formatted as "#/definitions/ObjectName"
+    let referenceStringArray: string[] = ref['$ref'].split('/');
+
+    // Getting "ObjectName"
+    let referenceName: string = referenceStringArray[referenceStringArray.length - 1];
+
+    // Make sure reference has replaced its own $ref fields and hope there are no recursive references.
+    definitions[referenceName] = ReplaceReferences(definitions, definitions[referenceName]);
+
+    // Retrieve ObjectName from definitions. (TODO: Does not retrieve inner objects)
+    // Need to deep copy, there are no functions in these objects.
+    let reference: any = JSON.parse(JSON.stringify(definitions[referenceName]));
+
+    ref = AppendFieldsToObject(reference, ref);
+
+    // Remove $ref field
+    delete ref['$ref'];
+
+    return ref;
+}
+
+function ReplaceReferences(definitions: any, objects: any) {
+    for (let key in objects) {
+        if (objects[key].hasOwnProperty('$ref')) {
+            objects[key] = RefReplace(definitions, objects[key]);
+        }
+
+        // Recursively replace references if this object has properties. 
+        if (objects[key].hasOwnProperty('type') && objects[key].type === 'object' && objects[key].properties !== null) {
+            objects[key].properties = ReplaceReferences(definitions, objects[key].properties);
+            objects[key].properties = UpdateDefaults(objects[key].properties, objects[key].default);
+        }
+
+        // Recursively replace references if the array has objects in items.
+        if (objects[key].hasOwnProperty('type') && objects[key].type === "array" && objects[key].items != null && objects[key].items.hasOwnProperty('$ref')) {
+            objects[key].items = RefReplace(definitions, objects[key].items);
+        }
+    }
+
+    return objects;
+}
+
+function MergeReferences(baseDefinitions: any, additionalDefinitions: any) : void {
+    for (let key in additionalDefinitions) {
+        if (baseDefinitions[key]) {
+            throw `Error: '${key}' defined in multiple schema files.`;
+        }
+        baseDefinitions[key] = additionalDefinitions[key];
+    }
+}
+
+export function GenerateOptionsSchema() {
+    let packageJSON: any = JSON.parse(fs.readFileSync('package.json').toString());
+    let schemaJSON: any = JSON.parse(fs.readFileSync('tools/OptionsSchema.json').toString());
+
+    schemaJSON.definitions = ReplaceReferences(schemaJSON.definitions, schemaJSON.definitions);
+
+    // Hard Code adding in configurationAttributes launch and attach.
+    // cppdbg
+    packageJSON.contributes.debuggers[0].configurationAttributes.launch = schemaJSON.definitions.CppdbgLaunchOptions;
+    packageJSON.contributes.debuggers[0].configurationAttributes.attach = schemaJSON.definitions.CppdbgAttachOptions;
+
+    // cppvsdbg
+    packageJSON.contributes.debuggers[1].configurationAttributes.launch = schemaJSON.definitions.CppvsdbgLaunchOptions;
+    packageJSON.contributes.debuggers[1].configurationAttributes.attach = schemaJSON.definitions.CppvsdbgAttachOptions;
+
+    let content = JSON.stringify(packageJSON, null, 2);
+    if (os.platform() === 'win32') {
+        content = content.replace(/\n/gm, "\r\n");
+    }
+    
+    // We use '\u200b' (unicode zero-length space character) to break VS Code's URL detection regex for URLs that are examples. This process will
+    // convert that from the readable espace sequence, to just an invisible character. Convert it back to the visible espace sequence.
+    content = content.replace(/\u200b/gm, "\\u200b");
+
+    fs.writeFileSync('package.json', content);
+}