Provide completion for schema ids in modeline #560

potential improvements:
- support range when there is already a value provided
- provide completion for local yaml schema files

Extracted a specific file for modeline related things.

fixes #560

Signed-off-by: Aurélien Pupier <apupier@redhat.com>

Author: apupier

src/languageservice/services/modelineUtil.ts

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+import { SingleYAMLDocument } from '../parser/yamlParser07';
+import { JSONDocument } from '../parser/jsonParser07';
+
+/**
+ * Retrieve schema if declared as modeline.
+ * Public for testing purpose, not part of the API.
+ * @param doc
+ */
+export function getSchemaFromModeline(doc: SingleYAMLDocument | JSONDocument): string {
+  if (doc instanceof SingleYAMLDocument) {
+    const yamlLanguageServerModeline = doc.lineComments.find((lineComment) => {
+      return isModeline(lineComment);
+    });
+    if (yamlLanguageServerModeline != undefined) {
+      const schemaMatchs = yamlLanguageServerModeline.match(/\$schema=\S+/g);
+      if (schemaMatchs !== null && schemaMatchs.length >= 1) {
+        if (schemaMatchs.length >= 2) {
+          console.log(
+            'Several $schema attributes have been found on the yaml-language-server modeline. The first one will be picked.'
+          );
+        }
+        return schemaMatchs[0].substring('$schema='.length);
+      }
+    }
+  }
+  return undefined;
+}
+
+export function isModeline(lineText: string): boolean {
+  const matchModeline = lineText.match(/^#\s+yaml-language-server\s*:/g);
+  return matchModeline !== null && matchModeline.length === 1;
+}

src/languageservice/services/yamlCompletion.ts

@@ -33,6 +33,7 @@ import * as nls from 'vscode-nls';
 import { setKubernetesParserOption } from '../parser/isKubernetes';
 import { isMapContainsEmptyPair } from '../utils/astUtils';
 import { indexOf } from '../utils/astUtils';
+import { isModeline } from './modelineUtil';
 
 const localize = nls.loadMessageBundle();
 
@@ -172,10 +173,15 @@ export class YamlCompletion {
       this.getCustomTagValueCompletions(collector);
     }
 
+    let lineContent = textBuffer.getLineContent(position.line);
+    if (lineContent.endsWith('\n')) {
+      lineContent = lineContent.substr(0, lineContent.length - 1);
+    }
+
     try {
       const schema = await this.schemaService.getSchemaForResource(document.uri, currentDoc);
       if (!schema || schema.errors.length) {
-        if (position.line === 0 && position.character === 0 && !textBuffer.getLineContent(0).includes('# yaml-language-server')) {
+        if (position.line === 0 && position.character === 0 && !isModeline(lineContent)) {
           const inlineSchemaCompletion = {
             kind: CompletionItemKind.Text,
             label: 'Inline schema',
@@ -184,6 +190,20 @@ export class YamlCompletion {
           };
           result.items.push(inlineSchemaCompletion);
         }
+        if (isModeline(lineContent)) {
+          const schemaIndex = lineContent.indexOf('$schema=');
+          if (schemaIndex !== -1 && schemaIndex + '$schema='.length === position.character) {
+            this.schemaService.getRegisteredSchemaIds().forEach((schemaId) => {
+              const schemaIdCompletion = {
+                kind: CompletionItemKind.Text,
+                label: schemaId,
+                insertText: schemaId,
+                insertTextFormat: InsertTextFormat.PlainText,
+              };
+              result.items.push(schemaIdCompletion);
+            });
+          }
+        }
         return result;
       }
 
@@ -201,10 +221,6 @@ export class YamlCompletion {
         }
       }
 
-      let lineContent = textBuffer.getLineContent(position.line);
-      if (lineContent.endsWith('\n')) {
-        lineContent = lineContent.substr(0, lineContent.length - 1);
-      }
       if (node) {
         if (lineContent.length === 0) {
           node = currentDoc.internalDocument.contents as Node;

src/languageservice/services/yamlSchemaService.ts

@@ -24,6 +24,7 @@ import { SingleYAMLDocument } from '../parser/yamlParser07';
 import { JSONDocument } from '../parser/jsonParser07';
 import { parse } from 'yaml';
 import * as path from 'path';
+import { getSchemaFromModeline } from './modelineUtil';
 
 const localize = nls.loadMessageBundle();
 
@@ -294,7 +295,7 @@ export class YAMLSchemaService extends JSONSchemaService {
       const seen: { [schemaId: string]: boolean } = Object.create(null);
       const schemas: string[] = [];
 
-      let schemaFromModeline = this.getSchemaFromModeline(doc);
+      let schemaFromModeline = getSchemaFromModeline(doc);
       if (schemaFromModeline !== undefined) {
         if (!schemaFromModeline.startsWith('file:') && !schemaFromModeline.startsWith('http')) {
           if (!path.isAbsolute(schemaFromModeline)) {
@@ -438,32 +439,6 @@ export class YAMLSchemaService extends JSONSchemaService {
     return priorityMapping.get(highestPrio) || [];
   }
 
-  /**
-   * Retrieve schema if declared as modeline.
-   * Public for testing purpose, not part of the API.
-   * @param doc
-   */
-  public getSchemaFromModeline(doc: SingleYAMLDocument | JSONDocument): string {
-    if (doc instanceof SingleYAMLDocument) {
-      const yamlLanguageServerModeline = doc.lineComments.find((lineComment) => {
-        const matchModeline = lineComment.match(/^#\s+yaml-language-server\s*:/g);
-        return matchModeline !== null && matchModeline.length === 1;
-      });
-      if (yamlLanguageServerModeline != undefined) {
-        const schemaMatchs = yamlLanguageServerModeline.match(/\$schema=\S+/g);
-        if (schemaMatchs !== null && schemaMatchs.length >= 1) {
-          if (schemaMatchs.length >= 2) {
-            console.log(
-              'Several $schema attributes have been found on the yaml-language-server modeline. The first one will be picked.'
-            );
-          }
-          return schemaMatchs[0].substring('$schema='.length);
-        }
-      }
-    }
-    return undefined;
-  }
-
   private async resolveCustomSchema(schemaUri, doc): ResolvedSchema {
     const unresolvedSchema = await this.loadSchema(schemaUri);
     const schema = await this.resolveSchemaContent(unresolvedSchema, schemaUri, []);

test/autoCompletion.test.ts

@@ -1625,7 +1625,7 @@ describe('Auto Completion Tests', () => {
     });
 
     it('should not provide modeline completion on first character when modeline already present', async () => {
-      const testTextDocument = setupSchemaIDTextDocument('# yaml-language-server', path.join(__dirname, 'test.yaml'));
+      const testTextDocument = setupSchemaIDTextDocument('# yaml-language-server:', path.join(__dirname, 'test.yaml'));
       yamlSettings.documents = new TextDocumentTestManager();
       (yamlSettings.documents as TextDocumentTestManager).set(testTextDocument);
       const result = await languageHandler.completionHandler({
@@ -1634,6 +1634,19 @@ describe('Auto Completion Tests', () => {
       });
       assert.strictEqual(result.items.length, 0, `Expecting 0 item in completion but found ${result.items.length}`);
     });
+
+    it('should provide schema id completion in modeline', async () => {
+      const modeline = '# yaml-language-server: $schema=';
+      const testTextDocument = setupSchemaIDTextDocument(modeline, path.join(__dirname, 'test.yaml'));
+      yamlSettings.documents = new TextDocumentTestManager();
+      (yamlSettings.documents as TextDocumentTestManager).set(testTextDocument);
+      const result = await languageHandler.completionHandler({
+        position: testTextDocument.positionAt(modeline.length),
+        textDocument: testTextDocument,
+      });
+      assert.strictEqual(result.items.length, 1, `Expecting 1 item in completion but found ${result.items.length}`);
+      assert.strictEqual(result.items[0].label, 'http://google.com/');
+    });
   });
 
   describe('Configuration based indentation', () => {

test/schema.test.ts

@@ -15,6 +15,7 @@ import { setupLanguageService, setupTextDocument, TEST_URI } from './utils/testH
 import { LanguageService, SchemaPriority } from '../src';
 import { Position } from 'vscode-languageserver';
 import { LineCounter } from 'yaml';
+import { getSchemaFromModeline } from '../src/languageservice/services/modelineUtil';
 
 const requestServiceMock = function (uri: string): Promise<string> {
   return Promise.reject<string>(`Resource ${uri} not found.`);
@@ -737,10 +738,9 @@ describe('JSON Schema', () => {
     });
 
     function checkReturnSchemaUrl(modeline: string, expectedResult: string): void {
-      const service = new SchemaService.YAMLSchemaService(schemaRequestServiceForURL, workspaceContext);
       const yamlDoc = new parser.SingleYAMLDocument(new LineCounter());
       yamlDoc.lineComments = [modeline];
-      assert.equal(service.getSchemaFromModeline(yamlDoc), expectedResult);
+      assert.strictEqual(getSchemaFromModeline(yamlDoc), expectedResult);
     }
   });
 });