[Qute] Add language support for qute

Fixes #178

Signed-off-by: azerr <azerr@redhat.com>

Author: angelozerr

gulpfile.js

@@ -21,6 +21,12 @@ const quarkusServerExt = 'com.redhat.quarkus.ls';
 const quarkusExtensionDir = '../quarkus-ls/quarkus.jdt.ext';
 const quarkusExtension = 'com.redhat.microprofile.jdt.quarkus';
 
+const quteServerDir = '../quarkus-ls/qute.ls/com.redhat.qute.ls'
+const quteServer = 'com.redhat.qute.ls-uber.jar';
+
+const quteExtensionDir = '../quarkus-ls/qute.jdt';
+const quteExtension = 'com.redhat.qute.jdt';
+
 gulp.task('buildServer', (done) => {
   cp.execSync(mvnw() + ' clean verify -DskipTests', { cwd: quarkusServerExtDir , stdio: 'inherit' });
   gulp.src(quarkusServerExtDir + '/target/' + quarkusServerExt + '-!(*sources).jar')
@@ -41,7 +47,22 @@ gulp.task('buildExtension', (done) => {
   done();
 });
 
-gulp.task('build', gulp.series('buildServer', 'buildExtension'));
+gulp.task('buildQuteServer', (done) => {
+  cp.execSync(mvnw() + ' clean install -DskipTests', { cwd: quteServerDir , stdio: 'inherit' });
+  gulp.src(quteServerDir + '/target/' + quteServer)
+    .pipe(gulp.dest('./server'));
+  done();
+});
+
+gulp.task('buildQuteExtension', (done) => {
+  cp.execSync(mvnw() + ' -pl "' + quteExtension + '" clean verify -DskipTests', { cwd: quteExtensionDir, stdio: 'inherit' });
+  gulp.src(quteExtensionDir + '/' + quteExtension + '/target/' + quteExtension + '-!(*sources).jar')
+    .pipe(rename(quteExtension + '.jar'))
+    .pipe(gulp.dest('./jars'));
+  done();
+});
+
+gulp.task('build', gulp.series('buildServer', 'buildExtension','buildQuteServer', 'buildQuteExtension'));
 
 function mvnw() {
 	return isWin() ? 'mvnw.cmd' : './mvnw';

package-lock.json

@@ -57,11 +57,13 @@
   ],
   "contributes": {
     "javaExtensions": [
-      "./jars/com.redhat.microprofile.jdt.quarkus.jar"
+      "./jars/com.redhat.microprofile.jdt.quarkus.jar",
+      "./jars/com.redhat.qute.jdt.jar"
     ],
     "microprofile": {
       "jarExtensions": [
-        "./server/com.redhat.quarkus.ls.jar"
+        "./server/com.redhat.quarkus.ls.jar",
+        "./server/com.redhat.qute.ls.jar"
       ],
       "documentSelector": [
         {
@@ -290,6 +292,8 @@
     "build": "./node_modules/.bin/gulp build",
     "build-server": "./node_modules/.bin/gulp buildServer",
     "build-ext": "./node_modules/.bin/gulp buildExtension",
+    "build-qute-server": "./node_modules/.bin/gulp buildQuteServer",
+    "build-qute-ext": "./node_modules/.bin/gulp buildQuteExtension",
     "test-ui": "rm -rf out && npm run test-compile && npm run test-ui-run",
     "test-ui-run": "extest setup-and-run 'out/test/vscodeUiTest/suite/*.js' -u -e 'out/test/vscodeUiTest/extensions'",
     "test-all": "npm test && npm run test-ui-run"
@@ -334,13 +338,15 @@
     "@redhat-developer/vscode-redhat-telemetry": "^0.4.2",
     "ejs": "^2.7.1",
     "expand-home-dir": "0.0.3",
+    "find-java-home": "^1.0.0",
     "find-up": "^4.1.0",
     "fs-extra": "^8.0.1",
     "glob": "^7.1.4",
     "js-yaml": "^4.0.0",
     "lodash": "^4.17.21",
     "request": "^2.88.0",
     "request-promise": "^4.2.4",
+    "vscode-languageclient": "^7.0.0",
     "which": "^2.0.2",
     "yauzl": "^2.10.0"
   }

package.json

@@ -20,6 +20,7 @@ import { ProjectLabelInfo } from './definitions/ProjectLabelInfo';
 import { PropertiesLanguageMismatch, QuarkusConfig } from './QuarkusConfig';
 import { QuarkusContext } from './QuarkusContext';
 import quarkusProjectListener from './QuarkusProjectListener';
+import { connectToQuteLS } from './qute/languageServer/client';
 import { terminalCommandRunner } from './terminal/terminalCommandRunner';
 import { initTelemetryService } from './utils/telemetryUtils';
 import { WelcomeWebview } from './webviews/WelcomeWebview';
@@ -64,6 +65,14 @@ export async function activate(context: ExtensionContext) {
   );
 
   registerVSCodeCommands(context);
+
+  connectToQuteLS(context).catch((error) => {
+    window.showErrorMessage(error.message, error.label).then((selection) => {
+      if (error.label && error.label === selection && error.openUrl) {
+        commands.executeCommand('vscode.open', error.openUrl);
+      }
+    });
+  });
 }
 
 export function deactivate() {

src/extension.ts

@@ -0,0 +1,89 @@
+import * as requirements from './requirements';
+
+import { DidChangeConfigurationNotification, LanguageClientOptions } from 'vscode-languageclient';
+import { LanguageClient } from 'vscode-languageclient/node';
+import { ExtensionContext, commands, window, workspace, Uri } from 'vscode';
+import { prepareExecutable } from './javaServerStarter';
+
+export function connectToQuteLS(context: ExtensionContext) {
+  return requirements.resolveRequirements().then(requirements => {
+    const clientOptions: LanguageClientOptions = {
+      documentSelector: [
+        { scheme: 'file', language: 'qute-html' },
+        { scheme: 'file', language: 'qute-json' },
+        { scheme: 'file', language: 'qute-yaml' },
+        { scheme: 'file', language: 'qute-txt' },
+        { scheme: 'untitled', language: 'qute-html' },
+        { scheme: 'vscode-notebook-cell', language: 'qute-html' },
+        { scheme: 'file', language: 'java' }
+      ],
+      // wrap with key 'settings' so it can be handled same a DidChangeConfiguration
+      initializationOptions: {
+        settings: getQuteSettings()
+      },
+      synchronize: {
+        // preferences starting with these will trigger didChangeConfiguration
+        configurationSection: ['quarkus', '[qute]']
+      },
+      middleware: {
+        workspace: {
+          didChangeConfiguration: () => {
+            quteLanguageClient.sendNotification(DidChangeConfigurationNotification.type, { settings: getQuteSettings() });
+          }
+        }
+      }
+    };
+
+    function bindQuteRequest(request: string) {
+      quteLanguageClient.onRequest(request, async (params: any) =>
+        <any>await commands.executeCommand("java.execute.workspaceCommand", request, params)
+      );
+    }
+
+    function bindQuteNotification(notification: string) {
+      context.subscriptions.push(commands.registerCommand(notification, (event: any) => {
+        quteLanguageClient.sendNotification(notification, event);
+      }));
+    }
+
+    const serverOptions = prepareExecutable(requirements);
+    const quteLanguageClient = new LanguageClient('qute', 'Qute Support', serverOptions, clientOptions);
+    context.subscriptions.push(quteLanguageClient.start());
+    return quteLanguageClient.onReady().then(() => {
+      bindQuteRequest('qute/template/project');
+      bindQuteRequest('qute/template/projectDataModel');
+      bindQuteRequest('qute/template/javaClasses');
+      bindQuteRequest('qute/template/resolvedJavaClass');
+      bindQuteRequest('qute/template/javaDefinition');
+      bindQuteNotification('qute/dataModelChanged');
+      bindQuteRequest('qute/java/codeLens');
+    }
+    )
+  });
+}
+
+/**
+ * Returns a json object with key 'quarkus' and a json object value that
+ * holds all quarkus. settings.
+ *
+ * Returns: {
+ *            'quarkus': {...}
+ *          }
+ */
+function getQuteSettings(): JSON {
+  const configQuarkus = workspace.getConfiguration().get('quarkus');
+  let quarkus;
+  if (!configQuarkus) { // Set default preferences if not provided
+    const defaultValue =
+    {
+      qute: {
+
+      }
+    };
+    quarkus = defaultValue;
+  } else {
+    const x = JSON.stringify(configQuarkus); // configQuarkus is not a JSON type
+    quarkus = { quarkus: JSON.parse(x) };
+  }
+  return quarkus;
+}

src/qute/languageServer/client.ts

@@ -0,0 +1,85 @@
+import * as os from 'os';
+import * as path from 'path';
+import { workspace } from 'vscode';
+import { Executable, ExecutableOptions } from 'vscode-languageclient/node';
+import { RequirementsData } from './requirements';
+import * as glob from 'glob';
+
+const DEBUG = startedInDebugMode();
+const DEBUG_PORT = 1074;
+const QUTE_SERVER_NAME = 'com.redhat.qute.ls-uber.jar';
+const QUTE_SERVER_MAIN_CLASS = 'com.redhat.qute.ls.QuteServerLauncher';
+
+export function prepareExecutable(requirements: RequirementsData): Executable {
+  const executable: Executable = Object.create(null);
+  const options: ExecutableOptions = Object.create(null);
+  options.env = process.env;
+  executable.options = options;
+  executable.command = path.resolve(requirements.java_home + '/bin/java');
+  executable.args = prepareParams();
+  return executable;
+}
+
+function prepareParams(): string[] {
+  const params: string[] = [];
+  if (DEBUG) {
+    if (process.env.SUSPEND_SERVER === 'true') {
+      params.push(`-agentlib:jdwp=transport=dt_socket,server=y,address=${DEBUG_PORT}`);
+    } else {
+      params.push(`-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=${DEBUG_PORT},quiet=y`);
+    }
+  }
+
+  const vmargs = workspace.getConfiguration("quarkus.tools").get("server.vmargs", '');
+  if (os.platform() === 'win32') {
+    const watchParentProcess = '-DwatchParentProcess=';
+    if (vmargs.indexOf(watchParentProcess) < 0) {
+      params.push(watchParentProcess + 'false');
+    }
+  }
+  parseVMargs(params, vmargs);
+  const serverHome: string = path.resolve(__dirname, '../server');
+  const microprofileServerFound: Array<string> = glob.sync(`**/${QUTE_SERVER_NAME}`, { cwd: serverHome });
+  if (microprofileServerFound.length) {
+    let mpJavaExtensionsClasspath = microprofileServerFound[0];
+    params.push('-cp');
+    params.push(`${serverHome}/` + mpJavaExtensionsClasspath);
+    params.push(QUTE_SERVER_MAIN_CLASS);
+  } else {
+    throw new Error('Unable to find required Language Server JARs');
+  }
+  return params;
+}
+
+function hasDebugFlag(args: string[]): boolean {
+  if (args) {
+    // See https://nodejs.org/en/docs/guides/debugging-getting-started/
+    return args.some(arg => /^--inspect/.test(arg) || /^--debug/.test(arg));
+  }
+  return false;
+}
+
+function startedInDebugMode(): boolean {
+  const args: string[] = process.execArgv;
+  return hasDebugFlag(args);
+}
+
+// exported for tests
+export function parseVMargs(params: string[], vmargsLine: string): void {
+  if (!vmargsLine) {
+    return;
+  }
+  const vmargs = vmargsLine.match(/(?:[^\s"]+|"[^"]*")+/g);
+  if (vmargs === null) {
+    return;
+  }
+  vmargs.forEach(arg => {
+    // remove all standalone double quotes
+    arg = arg.replace(/(\\)?"/g, ($0, $1) => { return ($1 ? $0 : ''); });
+    // unescape all escaped double quotes
+    arg = arg.replace(/(\\)"/g, '"');
+    if (params.indexOf(arg) < 0) {
+      params.push(arg);
+    }
+  });
+}