Added qute.templates.languageMismatch to avoid reuse of quarkus.tools.propertiesLanguageMismatch

Signed-off-by: Alexander Chen <alchen@redhat.com>

Author: Alexander Chen

package.json

@@ -206,18 +206,34 @@
           "type": "string",
           "enum": [
             "ignore",
-            "forceQuarkus",
+            "force",
             "prompt"
           ],
           "enumDescriptions": [
-            "ignore language mismatch for Quarkus properties",
+            "Ignore language mismatch for Quarkus properties",
             "Automatically correct the language for mismatched Quarkus properties",
             "Prompt correcting the language for mismatched Quarkus properties"
           ],
-          "default": "forceQuarkus",
+          "default": "force",
           "description": "Action performed when detected Quarkus properties have an incorrect language.",
           "scope": "window"
         },
+        "qute.templates.languageMismatch": {
+          "type": "string",
+          "enum": [
+            "ignore",
+            "force",
+            "prompt"
+          ],
+          "enumDescriptions": [
+            "Ignore language mismatch for Qute templates",
+            "Automatically correct the language for mismatched Qute templates",
+            "Prompt correcting the language for mismatched Qute templates"
+          ],
+          "default": "force",
+          "description": "Action performed when detected Qute templates have an incorrect language.",
+          "scope": "window"
+        },
         "qute.trace.server": {
           "type": "string",
           "enum": [

src/QuarkusConfig.ts

@@ -17,6 +17,7 @@ import {
   DEFAULT_API_URL,
 } from './definitions/constants';
 import { ConfigurationTarget, workspace } from 'vscode';
+import { LanguageMismatch } from './utils/languageMismatch';
 
 /**
  * This class manages the extension's interaction with
@@ -30,7 +31,7 @@ export namespace QuarkusConfig {
   export const STARTER_SHOW_EXT_DESC = 'quarkus.tools.starter.showExtensionDescriptions';
   export const ALWAYS_SHOW_WELCOME_PAGE = 'quarkus.tools.alwaysShowWelcomePage';
   export const DEBUG_TERMINATE_ON_EXIT = 'quarkus.tools.debug.terminateProcessOnExit';
-  export const PROPERTIES_LANGUAGE_MISMATCH = "quarkus.tools.propertiesLanguageMismatch";
+  export const QUARKUS_PROPERTIES_LANGUAGE_MISMATCH = "quarkus.tools.propertiesLanguageMismatch";
   export const QUARKUS_OVERRIDE_LANGUAGE_ID = 'quarkus.tools.override.languageId';
 
   export function getApiUrl(): string {
@@ -52,8 +53,8 @@ export namespace QuarkusConfig {
     return workspace.getConfiguration().get<TerminateProcessConfig>(DEBUG_TERMINATE_ON_EXIT);
   }
 
-  export function getPropertiesLanguageMismatch(): PropertiesLanguageMismatch {
-    return workspace.getConfiguration().get<PropertiesLanguageMismatch>(PROPERTIES_LANGUAGE_MISMATCH);
+  export function getPropertiesLanguageMismatch(): QuarkusPropertiesLanguageMismatch {
+    return workspace.getConfiguration().get<QuarkusPropertiesLanguageMismatch>(QUARKUS_PROPERTIES_LANGUAGE_MISMATCH);
   }
 
   export function setAlwaysShowWelcomePage(value: boolean): void {
@@ -68,8 +69,8 @@ export namespace QuarkusConfig {
     saveToQuarkusConfig(DEBUG_TERMINATE_ON_EXIT, value);
   }
 
-  export function setPropertiesLanguageMismatch(value: PropertiesLanguageMismatch): Thenable<void> {
-    return saveToQuarkusConfig(PROPERTIES_LANGUAGE_MISMATCH, value);
+  export function setPropertiesLanguageMismatch(value: QuarkusPropertiesLanguageMismatch): Thenable<void> {
+    return saveToQuarkusConfig(QUARKUS_PROPERTIES_LANGUAGE_MISMATCH, value);
   }
 
   export function saveToQuarkusConfig<T>(configName: string, value: T): Thenable<void> {
@@ -83,8 +84,4 @@ export enum TerminateProcessConfig {
   DontTerminate = "Never terminate"
 }
 
-export enum PropertiesLanguageMismatch {
-  ignore = "ignore",
-  forceQuarkus = "forceQuarkus",
-  prompt = "prompt"
-}
+export class QuarkusPropertiesLanguageMismatch extends LanguageMismatch {}

src/extension.ts

@@ -17,11 +17,12 @@ import * as path from 'path';
 import { commands, ConfigurationChangeEvent, Disposable, ExtensionContext, extensions, languages, Terminal, TextDocument, window, workspace } from 'vscode';
 import { registerVSCodeCommands } from './commands/registerCommands';
 import { ProjectLabelInfo } from './definitions/ProjectLabelInfo';
-import { PropertiesLanguageMismatch, QuarkusConfig } from './QuarkusConfig';
+import { QuarkusPropertiesLanguageMismatch, QuarkusConfig } from './QuarkusConfig';
 import { QuarkusContext } from './QuarkusContext';
 import quarkusProjectListener from './QuarkusProjectListener';
 import { connectToQuteLS } from './qute/languageServer/client';
 import { terminalCommandRunner } from './terminal/terminalCommandRunner';
+import { tryToForceLanguageId } from './utils/languageMismatch';
 import { JAVA_EXTENSION_ID } from './utils/requestStandardMode';
 import { initTelemetryService } from './utils/telemetryUtils';
 import { WelcomeWebview } from './webviews/WelcomeWebview';
@@ -51,13 +52,13 @@ export async function activate(context: ExtensionContext) {
 
   // When extension is started, loop for each text documents which are opened to update their language ID.
   workspace.textDocuments.forEach(document => {
-    updateLanguageId(document, false);
+    updateLanguageId(context, document, false);
   });
   // When a text document is opened, update their language ID.
   context.subscriptions.push(
     workspace.onDidOpenTextDocument(async (document) => {
       if (!(document.uri.scheme === 'git')) {
-        await updateLanguageId(document, true);
+        await updateLanguageId(context, document, true);
       }
     })
   );
@@ -84,80 +85,18 @@ function displayWelcomePageIfNeeded(context: ExtensionContext): void {
   }
 }
 
-/**
- * Try to force the document language ID to the given language ID.
- *
- * @param document the text document.
- * @param languageId the language ID.
- * @param notifyUser if a notification should appear when the language ID is updated
- */
-function tryToForceLanguageId(document: TextDocument, fileName: string, propertiesLanguageMismatch: PropertiesLanguageMismatch, languageId: string, notifyUser: boolean): Promise<void> {
-  // Get project label information for the given file URI
-  const labelInfo = ProjectLabelInfo.getProjectLabelInfo(document.uri.toString());
-  return labelInfo.then(l => {
-    if (l.isQuarkusProject()) {
-      if (propertiesLanguageMismatch === PropertiesLanguageMismatch.prompt) {
-        const YES = "Yes", NO = "No";
-        const supportType = languageId.indexOf('qute') > -1 ? 'Qute' : 'Quarkus';
-        const response: Thenable<string> = window.showInformationMessage(`The language ID for '${fileName}' must be '${languageId}' to receive ${supportType} support. Set the language ID to '${languageId}?'`, YES, NO);
-        response.then(result => {
-          if (result === YES) {
-            // The application.properties file belong to a Quarkus project, force to the quarkus-properties language
-            languages.setTextDocumentLanguage(document, languageId);
-          }
-        });
-      } else {
-        // The application.properties file belong to a Quarkus project, force to the quarkus-properties language
-        const oldLanguageId: string = document.languageId;
-        languages.setTextDocumentLanguage(document, languageId);
-        if (notifyUser) {
-          const context = QuarkusContext.getExtensionContext();
-          if (!hasShownSetLanguagePopUp(context)) {
-            const CONFIGURE_IN_SETTINGS = "Configure in Settings";
-            const DISABLE_IN_SETTINGS = "Disable Language Updating";
-            const response: Thenable<string> = window.showInformationMessage(
-              `Quarkus Tools for Visual Studio Code automatically switched the language ID of '${fileName}' `
-              + `to be '${languageId}' in order to provide language support. `
-              + `This behavior can be configured in settings.`, DISABLE_IN_SETTINGS, CONFIGURE_IN_SETTINGS);
-            response.then(result => {
-              if (result === CONFIGURE_IN_SETTINGS) {
-                commands.executeCommand('workbench.action.openSettings', QuarkusConfig.PROPERTIES_LANGUAGE_MISMATCH);
-              } else if (result === DISABLE_IN_SETTINGS) {
-                QuarkusConfig.setPropertiesLanguageMismatch(PropertiesLanguageMismatch.ignore).then(() => {
-                  languages.setTextDocumentLanguage(document, oldLanguageId);
-                });
-              }
-            });
-            context.globalState.update(QuarkusConfig.QUARKUS_OVERRIDE_LANGUAGE_ID, 'true');
-          }
-        }
-      }
-    }
-  });
-}
-
-function hasShownSetLanguagePopUp(context: ExtensionContext): boolean {
-  return context.globalState.get(QuarkusConfig.QUARKUS_OVERRIDE_LANGUAGE_ID, false);
-}
-
 const APP_PROPERTIES_PATTERN = /^application(?:-[A-Za-z]+)\.properties$/;
 
-const LANGUAGE_MAP = new Map<string, string>([
-  [".html", "qute-html"],
-  [".txt", "qute-txt"],
-  [".yaml", "qute-yaml"],
-  [".json", "qute-json"]
-]);
-
 /**
  * Update if required the language ID to 'quarkus-properties' if needed.
  *
+ * @param context the extension context
  * @param document the text document.
  * @param onExtensionLoad if the user manually changed the language id.
  */
-async function updateLanguageId(document: TextDocument, onExtensionLoad: boolean) {
-  const propertiesLanguageMismatch: PropertiesLanguageMismatch = QuarkusConfig.getPropertiesLanguageMismatch();
-  if (propertiesLanguageMismatch === PropertiesLanguageMismatch.ignore) {
+async function updateLanguageId(context: ExtensionContext, document: TextDocument, onExtensionLoad: boolean) {
+  const propertiesLanguageMismatch: QuarkusPropertiesLanguageMismatch = QuarkusConfig.getPropertiesLanguageMismatch();
+  if (propertiesLanguageMismatch === QuarkusPropertiesLanguageMismatch.ignore) {
     // Do nothing
     return;
   }
@@ -167,21 +106,13 @@ async function updateLanguageId(document: TextDocument, onExtensionLoad: boolean
       // the language ID is already quarkus-properties do nothing.
       return;
     }
-    tryToForceLanguageId(document, fileName, propertiesLanguageMismatch, 'quarkus-properties', onExtensionLoad);
+    tryToForceLanguageId(context, document, fileName, propertiesLanguageMismatch, 'quarkus-properties', onExtensionLoad, QuarkusConfig.QUARKUS_OVERRIDE_LANGUAGE_ID, QuarkusConfig.QUARKUS_PROPERTIES_LANGUAGE_MISMATCH);
   } else if (fileName === 'application.yaml' || fileName === 'application.yml') {
     if (document.languageId === 'yaml') {
       // the language ID is already yaml do nothing.
       return;
     }
-    tryToForceLanguageId(document, fileName, propertiesLanguageMismatch, 'yaml', onExtensionLoad);
-  } else if (document.fileName.includes(`resources${path.sep}templates${path.sep}`)) {
-    for (const extension of LANGUAGE_MAP.keys()) {
-      if (path.extname(document.fileName) === extension) {
-        const quteLanguageId = LANGUAGE_MAP.get(extension);
-        tryToForceLanguageId(document, fileName, propertiesLanguageMismatch, quteLanguageId, onExtensionLoad);
-        break;
-      }
-    }
+    tryToForceLanguageId(context, document, fileName, propertiesLanguageMismatch, 'yaml', onExtensionLoad, QuarkusConfig.QUARKUS_OVERRIDE_LANGUAGE_ID, QuarkusConfig.QUARKUS_PROPERTIES_LANGUAGE_MISMATCH);
   }
 }
 

src/qute/commands/registerCommands.ts

@@ -1,10 +1,12 @@
+import * as path from 'path';
 import { TextEncoder } from "util";
-import { commands, ConfigurationTarget, ExtensionContext, Position, Range, Selection, TextDocument, TextEditor, Uri, window, workspace, WorkspaceConfiguration } from "vscode";
+import { commands, ConfigurationTarget, ExtensionContext, Position, Range, Selection, TextDocument, TextEditor, Uri, window, workspace, WorkspaceConfiguration, languages } from "vscode";
 import { ConfigurationItem, Location } from "vscode-languageclient";
-import { QuteSettings } from "../languageServer/settings";
+import { QuteSettings, QuteTemplateLanguageMismatch } from "../languageServer/settings";
 import { QuteClientCommandConstants, QuteJdtLsServerCommandConstants, QuteServerCommandConstants } from "./commandConstants";
 import { CancellationToken, ExecuteCommandParams, ExecuteCommandRequest } from "vscode-languageclient";
 import { LanguageClient } from "vscode-languageclient/node";
+import { tryToForceLanguageId } from '../../utils/languageMismatch';
 
 /**
  * Register custom vscode command for Qute support.
@@ -17,6 +19,17 @@ export function registerVSCodeQuteCommands(context: ExtensionContext) {
   registerJavaDefinitionCommand(context);
   registerConfigurationUpdateCommand(context);
   registerQuteValidationToggleCommand(context);
+  context.subscriptions.push(
+    workspace.onDidOpenTextDocument((document) => {
+      if (!(document.uri.scheme === 'git')) {
+        updateQuteLanguageId(context, document, true);
+      }
+    })
+  );
+  // When extension is started, loop for each text documents which are opened to update their language ID.
+  workspace.textDocuments.forEach(document => {
+    updateQuteLanguageId(context, document, false);
+  });
 }
 
 export function registerQuteExecuteWorkspaceCommand(context: ExtensionContext, languageClient: LanguageClient) {
@@ -214,6 +227,42 @@ function getSettingsValue(value: any, section: string, editType: ConfigurationIt
   return value;
 }
 
+const LANGUAGE_MAP = new Map<string, string>([
+  [".html", "qute-html"],
+  [".htm", "qute-html"],
+  [".txt", "qute-txt"],
+  [".yaml", "qute-yaml"],
+  [".yml", "qute-yaml"],
+  [".json", "qute-json"]
+]);
+
+/**
+ * Update the language ID to a supported Qute language id if needed.
+ *
+ * @param context the extension context
+ * @param document the text document.
+ * @param onExtensionLoad if the user manually changed the language id.
+ */
+ async function updateQuteLanguageId(context: ExtensionContext, document: TextDocument, onExtensionLoad: boolean) {
+  const propertiesLanguageMismatch: QuteTemplateLanguageMismatch = QuteSettings.getQuteTemplatesLanguageMismatch();
+  // Check if the setting is set to ignore or if the language ID is already set to Qute
+  if (propertiesLanguageMismatch === QuteTemplateLanguageMismatch.ignore || document.languageId.startsWith('qute-')) {
+    // Do nothing
+    return;
+  }
+  const fileName: string = path.basename(document.fileName);
+  if (document.fileName.includes(`resources${path.sep}templates${path.sep}`)) {
+    for (const extension of LANGUAGE_MAP.keys()) {
+      if (path.extname(document.fileName) === extension) {
+        const quteLanguageId = LANGUAGE_MAP.get(extension);
+
+        tryToForceLanguageId(context, document, fileName, propertiesLanguageMismatch, quteLanguageId, onExtensionLoad, QuteSettings.QUTE_OVERRIDE_LANGUAGE_ID, QuteSettings.QUTE_TEMPLATES_LANGUAGE_MISMATCH);
+        break;
+      }
+    }
+  }
+}
+
 interface IConfiguration {
   workspaceConfiguration: WorkspaceConfiguration;
   target: ConfigurationTarget;

src/qute/languageServer/settings.ts

@@ -1,3 +1,5 @@
+import { ConfigurationTarget, workspace } from 'vscode';
+import { LanguageMismatch } from '../../utils/languageMismatch';
 /**
  * VScode Qute settings.
  */
@@ -17,4 +19,20 @@ export namespace QuteSettings {
    * Disable Qute validation for the given file name patterns settings.
    */
   export const QUTE_VALIDATION_EXCLUDED = 'qute.validation.excluded';
+
+  /**
+   * Action performed when detected Qute templates have an incorrect language.
+   */
+  export const QUTE_TEMPLATES_LANGUAGE_MISMATCH = "qute.templates.languageMismatch";
+
+  /**
+   * Flag for enabling forcing Qute language id setting
+   */
+  export const QUTE_OVERRIDE_LANGUAGE_ID = 'qute.templates.override.languageId';
+
+  export function getQuteTemplatesLanguageMismatch(): QuteTemplateLanguageMismatch {
+    return workspace.getConfiguration().get<QuteTemplateLanguageMismatch>(QUTE_TEMPLATES_LANGUAGE_MISMATCH);
+  }
 }
+
+export class QuteTemplateLanguageMismatch extends LanguageMismatch {}