registered "bind to grammer/schema" to command palette

Author: Alexander Chen

package.json

@@ -524,13 +524,22 @@
         "command": "xml.validation.all.files",
         "title": "Revalidate all opened XML files",
         "category": "XML"
+      },
+      {
+        "command": "xml.command.bind.grammar",
+        "title": "Bind to grammar/schema file",
+        "category": "XML"
       }
     ],
     "menus": {
       "commandPalette": [
         {
           "command": "xml.validation.current.file",
           "when": "editorLangId == xml"
+        },
+        {
+          "command": "xml.command.bind.grammar",
+          "when": "resourceFilename =~ /xml/ && editorIsOpen"
         }
       ]
     },

src/commands/commandConstants.ts

@@ -58,6 +58,11 @@ export namespace ClientCommandConstants {
    */
   export const OPEN_BINDING_WIZARD = 'xml.open.binding.wizard';
 
+  /**
+   * VSCode client command to open the grammar/schema binding wizard from command menu.
+   */
+  export const COMMAND_PALETTE_BINDING_WIZARD = 'xml.command.bind.grammar';
+
   /**
    * Client command to execute an XML command on XML Language Server side.
    */
@@ -85,4 +90,9 @@ export namespace ServerCommandConstants {
    * Command to associate a grammar in a XML document
    */
   export const ASSOCIATE_GRAMMAR_INSERT = "xml.associate.grammar.insert";
+
+  /**
+   * Command to check if the current XML document is bound to a grammar
+   */
+  export const CHECK_BOUND_GRAMMAR = "xml.check.bound.grammar"
 }

src/commands/registerCommands.ts

@@ -1,5 +1,5 @@
 import * as path from 'path';
-import { commands, ExtensionContext, OpenDialogOptions, Position, QuickPickItem, Uri, window, workspace, WorkspaceEdit } from "vscode";
+import { commands, ExtensionContext, OpenDialogOptions, Position, QuickPickItem, Uri, window, workspace, WorkspaceEdit, Disposable } from "vscode";
 import { CancellationToken, ExecuteCommandParams, ExecuteCommandRequest, ReferencesRequest, TextDocumentIdentifier, TextDocumentEdit } from "vscode-languageclient";
 import { LanguageClient } from 'vscode-languageclient/node';
 import { markdownPreviewProvider } from "../markdownPreviewProvider";
@@ -25,7 +25,7 @@ export async function registerClientServerCommands(context: ExtensionContext, la
 
   registerCodeLensReferencesCommands(context, languageClient);
   registerValidationCommands(context);
-  registerCodeLensAssociationCommands(context, languageClient);
+  registerAssociationCommands(context, languageClient);
 
   // Register client command to execute custom XML Language Server command
   context.subscriptions.push(commands.registerCommand(ClientCommandConstants.EXECUTE_WORKSPACE_COMMAND, (command, ...rest) => {
@@ -139,49 +139,97 @@ for (const label of bindingTypes.keys()) {
 }
 
 /**
- * Register commands used for associating grammar file (XSD,DTD) to a given XML file
+ * The function passed to context subscriptions for grammar association
  *
- * @param context the extension context
+ * @param uriString the string representing the XML file path
+ * @param languageClient the language server client
  */
-function registerCodeLensAssociationCommands(context: ExtensionContext, languageClient: LanguageClient) {
-  context.subscriptions.push(commands.registerCommand(ClientCommandConstants.OPEN_BINDING_WIZARD, async (uriString: string) => {
-    // A click on Bind to grammar/schema... has been processed in the XML document which is not bound to a grammar
-    const documentURI = Uri.parse(uriString);
-
-    // Step 1 : open a combo to select the binding type ("standard", "xml-model")
-    const pickedBindingTypeOption = await window.showQuickPick(bindingTypeOptions, { placeHolder: "Binding type" });
-    if(!pickedBindingTypeOption) {
-      return;
+async function grammarAssociationCommand (uriString: string, languageClient: LanguageClient) {
+  // A click on Bind to grammar/schema... has been processed in the XML document which is not bound to a grammar
+  const documentURI = Uri.parse(uriString);
+
+  // Step 1 : open a combo to select the binding type ("standard", "xml-model")
+  const pickedBindingTypeOption = await window.showQuickPick(bindingTypeOptions, { placeHolder: "Binding type" });
+  if(!pickedBindingTypeOption) {
+    return;
+  }
+  const bindingType = bindingTypes.get(pickedBindingTypeOption.label);
+
+  // Open a dialog to select the XSD, DTD to bind.
+  const options: OpenDialogOptions = {
+    canSelectMany: false,
+    openLabel: 'Select XSD or DTD file',
+    filters: {
+      'Grammar files': ['xsd', 'dtd']
     }
-    const bindingType = bindingTypes.get(pickedBindingTypeOption.label);
-
-    // Open a dialog to select the XSD, DTD to bind.
-    const options: OpenDialogOptions = {
-      canSelectMany: false,
-      openLabel: 'Select XSD or DTD file',
-      filters: {
-        'Grammar files': ['xsd', 'dtd']
+  };
+
+  const fileUri = await window.showOpenDialog(options);
+  if (fileUri && fileUri[0]) {
+    // The XSD, DTD has been selected, get the proper syntax for binding this grammar file in the XML document.
+    const identifier = TextDocumentIdentifier.create(documentURI.toString());
+    const grammarURI = fileUri[0];
+    try {
+      const result = await commands.executeCommand(ServerCommandConstants.ASSOCIATE_GRAMMAR_INSERT, identifier, grammarURI.toString(), bindingType);
+      // Insert the proper syntax for binding
+      const lspTextDocumentEdit = <TextDocumentEdit>result;
+      const workEdits = new WorkspaceEdit();
+      for (const edit of lspTextDocumentEdit.edits) {
+        workEdits.replace(documentURI, languageClient.protocol2CodeConverter.asRange(edit.range), edit.newText);
       }
+      workspace.applyEdit(workEdits); // apply the edits
+
+      // Hide the "Bind to grammar/schema" command
+      commands.executeCommand('setContext', 'canBindGrammar', false)
+
+    } catch (error) {
+      window.showErrorMessage('Error during grammar binding: ' + error.message);
     };
+  }
+}
 
-    const fileUri = await window.showOpenDialog(options);
-    if (fileUri && fileUri[0]) {
-      // The XSD, DTD has been selected, get the proper syntax for binding this grammar file in the XML document.
-      const identifier = TextDocumentIdentifier.create(documentURI.toString());
-      const grammarURI = fileUri[0];
-      try {
-        const result = await commands.executeCommand(ServerCommandConstants.ASSOCIATE_GRAMMAR_INSERT, identifier, grammarURI.toString(), bindingType);
-        // Insert the proper syntax for binding
-        const lspTextDocumentEdit = <TextDocumentEdit>result;
-        const workEdits = new WorkspaceEdit();
-        for (const edit of lspTextDocumentEdit.edits) {
-          workEdits.replace(documentURI, languageClient.protocol2CodeConverter.asRange(edit.range), edit.newText);
-        }
-        workspace.applyEdit(workEdits); // apply the edits
-      } catch (error) {
-        window.showErrorMessage('Error during grammar binding: ' + error.message);
-      };
+/**
+ * Register commands used for associating grammar file (XSD,DTD) to a given XML file for command menu and CodeLens
+ *
+ * @param context the extension context
+ * @param languageClient the language server client
+ */
+ function registerAssociationCommands(context: ExtensionContext, languageClient: LanguageClient) {
+  // For CodeLens
+  context.subscriptions.push(commands.registerCommand(ClientCommandConstants.OPEN_BINDING_WIZARD, async (uriString: string) => {
+    grammarAssociationCommand(uriString, languageClient)
+  }));
+  // For command menu
+  context.subscriptions.push(commands.registerCommand(ClientCommandConstants.COMMAND_PALETTE_BINDING_WIZARD, async () => {
+    const uriString = window.activeTextEditor.document.fileName;
+    // Run check to ensure available grammar binding command should be executed, or if error is thrown
+    const canBind = await checkCanBindGrammar(window.activeTextEditor.document.uri);
+    if (canBind) {
+      grammarAssociationCommand(uriString, languageClient)
+    } else {
+      window.showErrorMessage(`The document ${uriString} is already bound with a grammar`);
     }
   }));
 
-}
+ }
+
+  /**
+   * Change value of 'canBindGrammar' to determine if grammar/schema can be bound
+   *
+   * @param document the text document
+   * @returns the `hasGrammar` check result from server
+   */
+  async function checkCanBindGrammar(documentURI: Uri) {
+        // Retrieve the document uri and identifier
+        const identifier = TextDocumentIdentifier.create(documentURI.toString());
+
+        // Set the custom condition to watch if file already has bound grammar
+        var result = false;
+        try {
+          result = await commands.executeCommand(ServerCommandConstants.CHECK_BOUND_GRAMMAR, identifier);
+        } catch(error) {
+          console.log(`Error while checking bound grammar : ${error}`);
+        }
+
+        return result
+  }