Add completion for schema URI im modeline comment

Signed-off-by: Yevhen Vydolob <yvydolob@redhat.com>

Author: evidolob

src/languageserver/handlers/settingsHandlers.ts

@@ -195,6 +195,8 @@ export class SettingsHandler {
                 uri: schema.url,
                 fileMatch: [currFileMatch],
                 priority: SchemaPriority.SchemaStore,
+                name: schema.name,
+                description: schema.description,
               });
             }
           }

src/languageservice/parser/yaml-documents.ts

@@ -18,6 +18,7 @@ import { ApplicableSchema, SchemaCollectorImpl, validate } from './json-schema07
 import { JSONSchema } from '../jsonSchema';
 import { TextBuffer } from '../utils/textBuffer';
 import { getIndentation } from '../utils/strings';
+import { Token } from 'yaml/dist/parse/cst';
 
 /**
  * These documents are collected into a final YAMLDocument
@@ -194,12 +195,15 @@ export class SingleYAMLDocument extends JSONDocument {
  * to the `parseYAML` caller.
  */
 export class YAMLDocument {
-  public documents: SingleYAMLDocument[];
+  documents: SingleYAMLDocument[];
+  tokens: Token[];
+
   private errors: YAMLDocDiagnostic[];
   private warnings: YAMLDocDiagnostic[];
 
-  constructor(documents: SingleYAMLDocument[]) {
+  constructor(documents: SingleYAMLDocument[], tokens: Token[]) {
     this.documents = documents;
+    this.tokens = tokens;
     this.errors = [];
     this.warnings = [];
   }
@@ -236,7 +240,7 @@ export class YamlDocuments {
   private ensureCache(document: TextDocument, parserOptions: ParserOptions, addRootObject: boolean): void {
     const key = document.uri;
     if (!this.cache.has(key)) {
-      this.cache.set(key, { version: -1, document: new YAMLDocument([]), parserOptions: defaultOptions });
+      this.cache.set(key, { version: -1, document: new YAMLDocument([], []), parserOptions: defaultOptions });
     }
     const cacheEntry = this.cache.get(key);
     if (

src/languageservice/parser/yamlParser07.ts

@@ -35,13 +35,13 @@ export function parse(text: string, parserOptions: ParserOptions = defaultOption
   const lineCounter = new LineCounter();
   const parser = new Parser(lineCounter.addNewLine);
   const tokens = parser.parse(text);
-  const docs = composer.compose(tokens, true);
-
+  const tokensArr = Array.from(tokens);
+  const docs = composer.compose(tokensArr, true, text.length);
   // Generate the SingleYAMLDocs from the AST nodes
   const yamlDocs: SingleYAMLDocument[] = Array.from(docs, (doc) => parsedDocToSingleYAMLDocument(doc, lineCounter));
 
   // Consolidate the SingleYAMLDocs
-  return new YAMLDocument(yamlDocs);
+  return new YAMLDocument(yamlDocs, tokensArr);
 }
 
 function parsedDocToSingleYAMLDocument(parsedDoc: Document, lineCounter: LineCounter): SingleYAMLDocument {

src/languageservice/services/yamlCompletion.ts

@@ -10,6 +10,7 @@ import {
   CompletionItemKind,
   CompletionList,
   InsertTextFormat,
+  InsertTextMode,
   MarkupContent,
   MarkupKind,
   Position,
@@ -31,7 +32,7 @@ import { stringifyObject, StringifySettings } from '../utils/json';
 import { isDefined, isString } from '../utils/objects';
 import * as nls from 'vscode-nls';
 import { setKubernetesParserOption } from '../parser/isKubernetes';
-import { isMapContainsEmptyPair } from '../utils/astUtils';
+import { isInComment, isMapContainsEmptyPair } from '../utils/astUtils';
 import { indexOf } from '../utils/astUtils';
 import { isModeline } from './modelineUtil';
 
@@ -180,6 +181,7 @@ export class YamlCompletion {
 
     try {
       const schema = await this.schemaService.getSchemaForResource(document.uri, currentDoc);
+
       if (!schema || schema.errors.length) {
         if (position.line === 0 && position.character === 0 && !isModeline(lineContent)) {
           const inlineSchemaCompletion = {
@@ -190,23 +192,30 @@ 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);
-            });
-          }
+      }
+
+      if (isModeline(lineContent) || isInComment(doc.tokens, offset)) {
+        const schemaIndex = lineContent.indexOf('$schema=');
+        if (schemaIndex !== -1 && schemaIndex + '$schema='.length <= position.character) {
+          this.schemaService.getAllSchemas().forEach((schema) => {
+            const schemaIdCompletion: CompletionItem = {
+              kind: CompletionItemKind.Constant,
+              label: schema.name ?? schema.uri,
+              detail: schema.description,
+              insertText: schema.uri,
+              insertTextFormat: InsertTextFormat.PlainText,
+              insertTextMode: InsertTextMode.asIs,
+            };
+            result.items.push(schemaIdCompletion);
+          });
         }
         return result;
       }
 
+      if (!schema || schema.errors.length) {
+        return result;
+      }
+
       let currentProperty: Node = null;
       let foundByClosest = false;
       if (!node) {

src/languageservice/services/yamlSchemaService.ts

@@ -25,6 +25,7 @@ import { JSONDocument } from '../parser/jsonParser07';
 import { parse } from 'yaml';
 import * as path from 'path';
 import { getSchemaFromModeline } from './modelineUtil';
+import { JSONSchemaDescriptionExt } from '../../requestTypes';
 
 const localize = nls.loadMessageBundle();
 
@@ -95,6 +96,8 @@ export class YAMLSchemaService extends JSONSchemaService {
   private requestService: SchemaRequestService;
   public schemaPriorityMapping: Map<string, Set<SchemaPriority>>;
 
+  private schemaUriToNameAndDescription = new Map<string, [string, string]>();
+
   constructor(
     requestService: SchemaRequestService,
     contextService?: WorkspaceContextService,
@@ -110,6 +113,33 @@ export class YAMLSchemaService extends JSONSchemaService {
     this.customSchemaProvider = customSchemaProvider;
   }
 
+  getAllSchemas(): JSONSchemaDescriptionExt[] {
+    const result: JSONSchemaDescriptionExt[] = [];
+    const schemaUris = new Set<string>();
+    for (const filePattern of this.filePatternAssociations) {
+      const schemaUri = filePattern.uris[0];
+      if (schemaUris.has(schemaUri)) {
+        continue;
+      }
+      schemaUris.add(schemaUri);
+      const schemaHandle: JSONSchemaDescriptionExt = {
+        uri: schemaUri,
+        fromStore: false,
+        usedForCurrentFile: false,
+      };
+
+      if (this.schemaUriToNameAndDescription.has(schemaUri)) {
+        const [name, description] = this.schemaUriToNameAndDescription.get(schemaUri);
+        schemaHandle.name = name;
+        schemaHandle.description = description;
+        schemaHandle.fromStore = true;
+      }
+      result.push(schemaHandle);
+    }
+
+    return result;
+  }
+
   async resolveSchemaContent(
     schemaToResolve: UnresolvedSchema,
     schemaURL: string,
@@ -610,11 +640,25 @@ export class YAMLSchemaService extends JSONSchemaService {
         );
       }
       unresolvedJsonSchema.uri = schemaUri;
+      if (this.schemaUriToNameAndDescription.has(schemaUri)) {
+        const [name, description] = this.schemaUriToNameAndDescription.get(schemaUri);
+        unresolvedJsonSchema.schema.title = name ?? unresolvedJsonSchema.schema.title;
+        unresolvedJsonSchema.schema.description = description ?? unresolvedJsonSchema.schema.description;
+      }
       return unresolvedJsonSchema;
     });
   }
 
-  registerExternalSchema(uri: string, filePatterns?: string[], unresolvedSchema?: JSONSchema): SchemaHandle {
+  registerExternalSchema(
+    uri: string,
+    filePatterns?: string[],
+    unresolvedSchema?: JSONSchema,
+    name?: string,
+    description?: string
+  ): SchemaHandle {
+    if (name || description) {
+      this.schemaUriToNameAndDescription.set(uri, [name, description]);
+    }
     return super.registerExternalSchema(uri, filePatterns, unresolvedSchema);
   }
 

src/languageservice/utils/astUtils.ts

@@ -4,6 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Document, isDocument, isScalar, Node, visit, YAMLMap, YAMLSeq } from 'yaml';
+import { CollectionItem, SourceToken, Token } from 'yaml/dist/parse/cst';
+import { VisitPath } from 'yaml/dist/parse/cst-visit';
+
+type Visitor = (item: SourceToken, path: VisitPath) => number | symbol | Visitor | void;
 
 export function getParent(doc: Document, nodeToFind: Node): Node | undefined {
   let parentNode: Node;
@@ -41,3 +45,74 @@ export function indexOf(seq: YAMLSeq, item: Node): number | undefined {
   }
   return undefined;
 }
+
+/**
+ * Check that given offset is in YAML comment
+ * @param doc the yaml document
+ * @param offset the offset to check
+ */
+export function isInComment(tokens: Token[], offset: number): boolean {
+  let inComment = false;
+  for (const token of tokens) {
+    if (token.type === 'document') {
+      _visit([], (token as unknown) as SourceToken, (item) => {
+        if (isCollectionItem(item) && item.value?.type === 'comment') {
+          if (token.offset <= offset && item.value.source.length + item.value.offset >= offset) {
+            inComment = true;
+            return visit.BREAK;
+          }
+        } else if (item.type === 'comment' && item.offset <= offset && item.offset + item.source.length >= offset) {
+          inComment = true;
+          return visit.BREAK;
+        }
+      });
+    } else if (token.type === 'comment') {
+      if (token.offset <= offset && token.source.length + token.offset >= offset) {
+        return true;
+      }
+    }
+    if (inComment) {
+      break;
+    }
+  }
+
+  return inComment;
+}
+
+function isCollectionItem(token: unknown): token is CollectionItem {
+  return token['start'] !== undefined;
+}
+
+function _visit(path: VisitPath, item: SourceToken, visitor: Visitor): number | symbol | Visitor | void {
+  let ctrl = visitor(item, path);
+  if (typeof ctrl === 'symbol') return ctrl;
+  for (const field of ['key', 'value'] as const) {
+    const token = item[field];
+    if (token && 'items' in token) {
+      for (let i = 0; i < token.items.length; ++i) {
+        const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+        if (typeof ci === 'number') i = ci - 1;
+        else if (ci === visit.BREAK) return visit.BREAK;
+        else if (ci === visit.REMOVE) {
+          token.items.splice(i, 1);
+          i -= 1;
+        }
+      }
+      if (typeof ctrl === 'function' && field === 'key') ctrl = ctrl(item, path);
+    }
+  }
+
+  const token = item['sep'];
+  if (token) {
+    for (let i = 0; i < token.length; ++i) {
+      const ci = _visit(Object.freeze(path), token[i], visitor);
+      if (typeof ci === 'number') i = ci - 1;
+      else if (ci === visit.BREAK) return visit.BREAK;
+      else if (ci === visit.REMOVE) {
+        token.items.splice(i, 1);
+        i -= 1;
+      }
+    }
+  }
+  return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;
+}

src/languageservice/yamlLanguageService.ts

@@ -62,6 +62,8 @@ export interface SchemasSettings {
   fileMatch: string[];
   schema?: unknown;
   uri: string;
+  name?: string;
+  description?: string;
 }
 
 export interface LanguageSettings {
@@ -173,7 +175,13 @@ export function getLanguageService(
         settings.schemas.forEach((settings) => {
           const currPriority = settings.priority ? settings.priority : 0;
           schemaService.addSchemaPriority(settings.uri, currPriority);
-          schemaService.registerExternalSchema(settings.uri, settings.fileMatch, settings.schema);
+          schemaService.registerExternalSchema(
+            settings.uri,
+            settings.fileMatch,
+            settings.schema,
+            settings.name,
+            settings.description
+          );
         });
       }
       yamlValidation.configure(settings);

src/requestTypes.ts

@@ -6,6 +6,32 @@ import { SchemaConfiguration } from './languageservice/yamlLanguageService';
 
 export type ISchemaAssociations = Record<string, string[]>;
 
+export interface JSONSchemaDescription {
+  /**
+   * Schema URI
+   */
+  uri: string;
+  /**
+   * Schema name, from schema store
+   */
+  name?: string;
+  /**
+   * Schema description, from schema store
+   */
+  description?: string;
+}
+
+export interface JSONSchemaDescriptionExt extends JSONSchemaDescription {
+  /**
+   * Is schema used for current document
+   */
+  usedForCurrentFile: boolean;
+  /**
+   * Is schema from schema store
+   */
+  fromStore: boolean;
+}
+
 export namespace SchemaAssociationNotification {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   export const type: NotificationType<ISchemaAssociations | SchemaConfiguration[]> = new NotificationType(

test/astUtils.test.ts

@@ -6,7 +6,7 @@
 import * as chai from 'chai';
 import { isPair, isSeq, Pair, YAMLSeq } from 'yaml';
 import { YamlDocuments } from '../src/languageservice/parser/yaml-documents';
-import { getParent } from '../src/languageservice/utils/astUtils';
+import { getParent, isInComment } from '../src/languageservice/utils/astUtils';
 import { setupTextDocument } from './utils/testHelper';
 const expect = chai.expect;
 
@@ -74,4 +74,20 @@ describe('AST Utils Tests', () => {
       expect((result as Pair).key).property('value', 'foo');
     });
   });
+
+  describe('Is Offset in comment', () => {
+    it('should detect that offset in comment', () => {
+      const doc = setupTextDocument('#some comment\nfoo: bar');
+      const yamlDoc = documents.getYamlDocument(doc);
+      const result = isInComment(yamlDoc.tokens, 4);
+      expect(result).to.be.true;
+    });
+
+    it('should detect that comment inside object', () => {
+      const doc = setupTextDocument('obj:\n#some comment\n  foo: bar');
+      const yamlDoc = documents.getYamlDocument(doc);
+      const result = isInComment(yamlDoc.tokens, 12);
+      expect(result).to.be.true;
+    });
+  });
 });