yaml-language-server 1.2.2 → 1.3.0

package/lib/esm/languageservice/services/yamlCompletion.js

@@ -11,20 +11,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { CompletionItem, CompletionItemKind, CompletionList, InsertTextFormat, InsertTextMode, MarkupKind, Range, TextEdit, } from 'vscode-languageserver/node';
+import { CompletionItem as CompletionItemBase, CompletionItemKind, CompletionList, InsertTextFormat, InsertTextMode, MarkupKind, Range, TextEdit, } from 'vscode-languageserver/node';
 import { isPair, isScalar, isMap, isSeq, isNode } from 'yaml';
 import { filterInvalidCustomTags, matchOffsetToDocument } from '../utils/arrUtils';
 import { guessIndentation } from '../utils/indentationGuesser';
 import { TextBuffer } from '../utils/textBuffer';
 import { stringifyObject } from '../utils/json';
-import { isDefined, isString } from '../utils/objects';
+import { convertErrorToTelemetryMsg, isDefined, isString } from '../utils/objects';
 import * as nls from 'vscode-nls';
 import { setKubernetesParserOption } from '../parser/isKubernetes';
 import { isInComment, isMapContainsEmptyPair } from '../utils/astUtils';
 import { indexOf } from '../utils/astUtils';
 import { isModeline } from './modelineUtil';
+import { getSchemaTypeName } from '../utils/schemaUtils';
 const localize = nls.loadMessageBundle();
 const doubleQuotesEscapeRegExp = /[\\]+"/g;
+const parentCompletionKind = CompletionItemKind.Class;
 export class YamlCompletion {
     constructor(schemaService, clientCapabilities = {}, yamlDocument, telemetry) {
         this.schemaService = schemaService;
@@ -40,6 +42,7 @@ export class YamlCompletion {
         this.customTags = languageSettings.customTags;
         this.yamlVersion = languageSettings.yamlVersion;
         this.configuredIndentation = languageSettings.indentation;
+        this.disableDefaultProperties = languageSettings.disableDefaultProperties;
     }
     doComplete(document, position, isKubernetes = false) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -90,8 +93,34 @@ export class YamlCompletion {
                 overwriteRange = Range.create(document.positionAt(overwriteStart), position);
             }
             const proposed = {};
+            const existingProposeItem = '__';
             const collector = {
                 add: (completionItem) => {
+                    const addSuggestionForParent = function (completionItem) {
+                        var _a;
+                        const existsInYaml = ((_a = proposed[completionItem.label]) === null || _a === void 0 ? void 0 : _a.label) === existingProposeItem;
+                        //don't put to parent suggestion if already in yaml
+                        if (existsInYaml) {
+                            return;
+                        }
+                        const schemaType = completionItem.parent.schemaType;
+                        let parentCompletion = result.items.find((item) => item.label === schemaType && item.kind === parentCompletionKind);
+                        if (parentCompletion && parentCompletion.parent.insertTexts.includes(completionItem.insertText)) {
+                            // already exists in the parent
+                            return;
+                        }
+                        else if (!parentCompletion) {
+                            // create a new parent
+                            parentCompletion = Object.assign(Object.assign({}, completionItem), { label: schemaType, sortText: '_' + schemaType, kind: parentCompletionKind });
+                            parentCompletion.parent.insertTexts = [completionItem.insertText];
+                            result.items.push(parentCompletion);
+                        }
+                        else {
+                            // add to the existing parent
+                            parentCompletion.parent.insertTexts.push(completionItem.insertText);
+                        }
+                    };
+                    const isForParentCompletion = !!completionItem.parent;
                     let label = completionItem.label;
                     if (!label) {
                         // we receive not valid CompletionItem as `label` is mandatory field, so just ignore it
@@ -102,7 +131,7 @@ export class YamlCompletion {
                         label = String(label);
                     }
                     const existing = proposed[label];
-                    if (!existing) {
+                    if (!existing || isForParentCompletion) {
                         label = label.replace(/[\n]/g, '↵');
                         if (label.length > 60) {
                             const shortendedLabel = label.substr(0, 57).trim() + '...';
@@ -110,17 +139,28 @@ export class YamlCompletion {
                                 label = shortendedLabel;
                             }
                         }
+                        // trim $1 from end of completion
+                        if (completionItem.insertText.endsWith('$1') && !isForParentCompletion) {
+                            completionItem.insertText = completionItem.insertText.substr(0, completionItem.insertText.length - 2);
+                        }
                         if (overwriteRange && overwriteRange.start.line === overwriteRange.end.line) {
                             completionItem.textEdit = TextEdit.replace(overwriteRange, completionItem.insertText);
                         }
                         completionItem.label = label;
-                        proposed[label] = completionItem;
-                        result.items.push(completionItem);
+                        if (isForParentCompletion) {
+                            addSuggestionForParent(completionItem);
+                        }
+                        if (!existing) {
+                            proposed[label] = completionItem;
+                            result.items.push(completionItem);
+                        }
+                    }
+                    else if (!existing.documentation && completionItem.documentation) {
+                        existing.documentation = completionItem.documentation;
                     }
                 },
                 error: (message) => {
-                    console.error(message);
-                    this.telemetry.sendError('yaml.completion.error', { error: message });
+                    this.telemetry.sendError('yaml.completion.error', { error: convertErrorToTelemetryMsg(message) });
                 },
                 log: (message) => {
                     console.log(message);
@@ -185,6 +225,7 @@ export class YamlCompletion {
                         foundByClosest = true;
                     }
                 }
+                const originalNode = node;
                 if (node) {
                     if (lineContent.length === 0) {
                         node = currentDoc.internalDocument.contents;
@@ -329,11 +370,11 @@ export class YamlCompletion {
                     for (const p of properties) {
                         if (!currentProperty || currentProperty !== p) {
                             if (isScalar(p.key)) {
-                                proposed[p.key.value.toString()] = CompletionItem.create('__');
+                                proposed[p.key.value.toString()] = CompletionItemBase.create(existingProposeItem);
                             }
                         }
                     }
-                    this.addPropertyCompletions(schema, currentDoc, node, '', collector, textBuffer, overwriteRange);
+                    this.addPropertyCompletions(schema, currentDoc, node, originalNode, '', collector, textBuffer, overwriteRange);
                     if (!schema && currentWord.length > 0 && document.getText().charAt(offset - currentWord.length - 1) !== '"') {
                         collector.add({
                             kind: CompletionItemKind.Property,
@@ -348,15 +389,54 @@ export class YamlCompletion {
                 this.getValueCompletions(schema, currentDoc, node, offset, document, collector, types);
             }
             catch (err) {
-                if (err.stack) {
-                    console.error(err.stack);
+                this.telemetry.sendError('yaml.completion.error', { error: convertErrorToTelemetryMsg(err) });
+            }
+            this.finalizeParentCompletion(result);
+            return result;
+        });
+    }
+    finalizeParentCompletion(result) {
+        const reindexText = (insertTexts) => {
+            //modify added props to have unique $x
+            let max$index = 0;
+            return insertTexts.map((text) => {
+                const match = text.match(/\$([0-9]+)|\${[0-9]+:/g);
+                if (!match) {
+                    return text;
                 }
-                else {
-                    console.error(err);
+                const max$indexLocal = match
+                    .map((m) => +m.replace(/\${([0-9]+)[:|]/g, '$1').replace('$', '')) // get numbers form $1 or ${1:...}
+                    .reduce((p, n) => (n > p ? n : p), 0); // find the max one
+                const reindexedStr = text
+                    .replace(/\$([0-9]+)/g, (s, args) => '$' + (+args + max$index)) // increment each by max$index
+                    .replace(/\${([0-9]+)[:|]/g, (s, args) => '${' + (+args + max$index) + ':'); // increment each by max$index
+                max$index += max$indexLocal;
+                return reindexedStr;
+            });
+        };
+        result.items.forEach((completionItem) => {
+            if (isParentCompletionItem(completionItem)) {
+                const indent = completionItem.parent.indent || '';
+                const reindexedTexts = reindexText(completionItem.parent.insertTexts);
+                // add indent to each object property and join completion item texts
+                let insertText = reindexedTexts.join(`\n${indent}`);
+                // trim $1 from end of completion
+                if (insertText.endsWith('$1')) {
+                    insertText = insertText.substring(0, insertText.length - 2);
+                }
+                completionItem.insertText = insertText;
+                if (completionItem.textEdit) {
+                    completionItem.textEdit.newText = insertText;
                 }
-                this.telemetry.sendError('yaml.completion.error', { error: err });
+                // remove $x or use {$x:value} in documentation
+                const mdText = insertText.replace(/\${[0-9]+[:|](.*)}/g, (s, arg) => arg).replace(/\$([0-9]+)/g, '');
+                const originalDocumentation = completionItem.documentation ? [completionItem.documentation, '', '----', ''] : [];
+                completionItem.documentation = {
+                    kind: MarkupKind.Markdown,
+                    value: [...originalDocumentation, '```yaml', indent + mdText, '```'].join('\n'),
+                };
+                delete completionItem.parent;
             }
-            return result;
         });
     }
     createTempObjNode(currentWord, node, currentDoc) {
@@ -368,13 +448,18 @@ export class YamlCompletion {
         map.items[0].value.range = node.range;
         return map;
     }
-    addPropertyCompletions(schema, doc, node, separatorAfter, collector, textBuffer, overwriteRange) {
+    addPropertyCompletions(schema, doc, node, originalNode, separatorAfter, collector, textBuffer, overwriteRange) {
+        var _a;
         const matchingSchemas = doc.getMatchingSchemas(schema.schema);
         const existingKey = textBuffer.getText(overwriteRange);
-        const hasColumn = textBuffer.getLineContent(overwriteRange.start.line).indexOf(':') === -1;
+        const lineContent = textBuffer.getLineContent(overwriteRange.start.line);
+        const hasOnlyWhitespace = lineContent.trim().length === 0;
+        const hasColon = lineContent.indexOf(':') !== -1;
         const nodeParent = doc.getParent(node);
+        const matchOriginal = matchingSchemas.find((it) => it.node.internalNode === originalNode && it.schema.properties);
         for (const schema of matchingSchemas) {
-            if (schema.node.internalNode === node && !schema.inverted) {
+            if (((schema.node.internalNode === node && !matchOriginal) || schema.node.internalNode === originalNode) &&
+                !schema.inverted) {
                 this.collectDefaultSnippets(schema.schema, separatorAfter, collector, {
                     newLineFirst: false,
                     indentFirstObject: false,
@@ -386,13 +471,13 @@ export class YamlCompletion {
                     if (maxProperties === undefined ||
                         node.items === undefined ||
                         node.items.length < maxProperties ||
-                        isMapContainsEmptyPair(node)) {
+                        (node.items.length === maxProperties && !hasOnlyWhitespace)) {
                         for (const key in schemaProperties) {
                             if (Object.prototype.hasOwnProperty.call(schemaProperties, key)) {
                                 const propertySchema = schemaProperties[key];
                                 if (typeof propertySchema === 'object' && !propertySchema.deprecationMessage && !propertySchema['doNotSuggest']) {
                                     let identCompensation = '';
-                                    if (nodeParent && isSeq(nodeParent) && node.items.length <= 1) {
+                                    if (nodeParent && isSeq(nodeParent) && node.items.length <= 1 && !hasOnlyWhitespace) {
                                         // because there is a slash '-' to prevent the properties generated to have the correct
                                         // indent
                                         const sourceText = textBuffer.getText();
@@ -417,17 +502,19 @@ export class YamlCompletion {
                                             this.addSchemaValueCompletions(propertySchema.items[0], separatorAfter, collector, {});
                                         }
                                         else if (typeof propertySchema.items === 'object' && propertySchema.items.type === 'object') {
+                                            const insertText = `- ${this.getInsertTextForObject(propertySchema.items, separatorAfter, '  ').insertText.trimLeft()}`;
+                                            const documentation = this.getDocumentationWithMarkdownText(`Create an item of an array${propertySchema.description ? ' (' + propertySchema.description + ')' : ''}`, insertText);
                                             collector.add({
                                                 kind: this.getSuggestionKind(propertySchema.items.type),
                                                 label: '- (array item)',
-                                                documentation: `Create an item of an array${propertySchema.description === undefined ? '' : '(' + propertySchema.description + ')'}`,
-                                                insertText: `- ${this.getInsertTextForObject(propertySchema.items, separatorAfter, '  ').insertText.trimLeft()}`,
+                                                documentation,
+                                                insertText,
                                                 insertTextFormat: InsertTextFormat.Snippet,
                                             });
                                         }
                                     }
                                     let insertText = key;
-                                    if (!key.startsWith(existingKey) || hasColumn) {
+                                    if (!key.startsWith(existingKey) || !hasColon) {
                                         insertText = this.getInsertTextForProperty(key, propertySchema, separatorAfter, identCompensation + this.indentation);
                                     }
                                     collector.add({
@@ -437,6 +524,20 @@ export class YamlCompletion {
                                         insertTextFormat: InsertTextFormat.Snippet,
                                         documentation: this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || '',
                                     });
+                                    // if the prop is required add it also to parent suggestion
+                                    if ((_a = schema.schema.required) === null || _a === void 0 ? void 0 : _a.includes(key)) {
+                                        const schemaType = getSchemaTypeName(schema.schema);
+                                        collector.add({
+                                            label: key,
+                                            insertText: this.getInsertTextForProperty(key, propertySchema, separatorAfter, identCompensation + this.indentation),
+                                            insertTextFormat: InsertTextFormat.Snippet,
+                                            documentation: this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || '',
+                                            parent: {
+                                                schemaType,
+                                                indent: identCompensation,
+                                            },
+                                        });
+                                    }
                                 }
                             }
                         }
@@ -507,11 +608,13 @@ export class YamlCompletion {
                                 }
                             }
                             else if (typeof s.schema.items === 'object' && s.schema.items.type === 'object') {
+                                const insertText = `- ${this.getInsertTextForObject(s.schema.items, separatorAfter, '  ').insertText.trimLeft()}`;
+                                const documentation = this.getDocumentationWithMarkdownText(`Create an item of an array${s.schema.description ? ' (' + s.schema.description + ')' : ''}`, insertText);
                                 collector.add({
                                     kind: this.getSuggestionKind(s.schema.items.type),
                                     label: '- (array item)',
-                                    documentation: `Create an item of an array${s.schema.description === undefined ? '' : '(' + s.schema.description + ')'}`,
-                                    insertText: `- ${this.getInsertTextForObject(s.schema.items, separatorAfter, '  ').insertText.trimLeft()}`,
+                                    documentation,
+                                    insertText,
                                     insertTextFormat: InsertTextFormat.Snippet,
                                 });
                                 this.addSchemaValueCompletions(s.schema.items, separatorAfter, collector, types);
@@ -520,12 +623,15 @@ export class YamlCompletion {
                                 s.schema.items.anyOf
                                     .filter((i) => typeof i === 'object')
                                     .forEach((i, index) => {
+                                    const schemaType = getSchemaTypeName(i);
                                     const insertText = `- ${this.getInsertTextForObject(i, separatorAfter).insertText.trimLeft()}`;
                                     //append insertText to documentation
-                                    const documentation = this.getDocumentationWithMarkdownText(`Create an item of an array${s.schema.description === undefined ? '' : '(' + s.schema.description + ')'}`, insertText);
+                                    const schemaTypeTitle = schemaType ? ' type `' + schemaType + '`' : '';
+                                    const schemaDescription = s.schema.description ? ' (' + s.schema.description + ')' : '';
+                                    const documentation = this.getDocumentationWithMarkdownText(`Create an item of an array${schemaTypeTitle}${schemaDescription}`, insertText);
                                     collector.add({
                                         kind: this.getSuggestionKind(i.type),
-                                        label: '- (array item) ' + (index + 1),
+                                        label: '- (array item) ' + (schemaType || index + 1),
                                         documentation: documentation,
                                         insertText: insertText,
                                         insertTextFormat: InsertTextFormat.Snippet,
@@ -555,7 +661,7 @@ export class YamlCompletion {
             }
         }
     }
-    getInsertTextForProperty(key, propertySchema, separatorAfter, ident = this.indentation) {
+    getInsertTextForProperty(key, propertySchema, separatorAfter, indent = this.indentation) {
         const propertyText = this.getInsertTextForValue(key, '', 'string');
         const resultText = propertyText + ':';
         let value;
@@ -569,6 +675,9 @@ export class YamlCompletion {
                 else if (propertySchema.items) {
                     type = 'array';
                 }
+                else if (propertySchema.anyOf) {
+                    type = 'anyOf';
+                }
             }
             if (Array.isArray(propertySchema.defaultSnippets)) {
                 if (propertySchema.defaultSnippets.length === 1) {
@@ -593,6 +702,14 @@ export class YamlCompletion {
                 }
                 nValueProposals += propertySchema.enum.length;
             }
+            if (propertySchema.const) {
+                if (!value) {
+                    value = this.getInsertTextForGuessedValue(propertySchema.const, '', type);
+                    value = evaluateTab1Symbol(value); // prevent const being selected after snippet insert
+                    value = ' ' + value;
+                }
+                nValueProposals++;
+            }
             if (isDefined(propertySchema.default)) {
                 if (!value) {
                     value = ' ' + this.getInsertTextForGuessedValue(propertySchema.default, '', type);
@@ -606,10 +723,10 @@ export class YamlCompletion {
                 nValueProposals += propertySchema.examples.length;
             }
             if (propertySchema.properties) {
-                return `${resultText}\n${this.getInsertTextForObject(propertySchema, separatorAfter, ident).insertText}`;
+                return `${resultText}\n${this.getInsertTextForObject(propertySchema, separatorAfter, indent).insertText}`;
             }
             else if (propertySchema.items) {
-                return `${resultText}\n${this.indentation}- ${this.getInsertTextForArray(propertySchema.items, separatorAfter).insertText}`;
+                return `${resultText}\n${indent}- ${this.getInsertTextForArray(propertySchema.items, separatorAfter, 1, indent).insertText}`;
             }
             if (nValueProposals === 0) {
                 switch (type) {
@@ -620,10 +737,10 @@ export class YamlCompletion {
                         value = ' $1';
                         break;
                     case 'object':
-                        value = `\n${ident}`;
+                        value = `\n${indent}`;
                         break;
                     case 'array':
-                        value = `\n${ident}- `;
+                        value = `\n${indent}- `;
                         break;
                     case 'number':
                     case 'integer':
@@ -632,6 +749,9 @@ export class YamlCompletion {
                     case 'null':
                         value = ' ${1:null}';
                         break;
+                    case 'anyOf':
+                        value = ' $1';
+                        break;
                     default:
                         return propertyText;
                 }
@@ -652,6 +772,9 @@ export class YamlCompletion {
             const propertySchema = schema.properties[key];
             let type = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;
             if (!type) {
+                if (propertySchema.anyOf) {
+                    type = 'anyOf';
+                }
                 if (propertySchema.properties) {
                     type = 'object';
                 }
@@ -665,11 +788,22 @@ export class YamlCompletion {
                     case 'string':
                     case 'number':
                     case 'integer':
-                        insertText += `${indent}${key}: $${insertIndex++}\n`;
+                    case 'anyOf': {
+                        let value = propertySchema.default || propertySchema.const;
+                        if (value) {
+                            if (type === 'string') {
+                                value = convertToStringValue(value);
+                            }
+                            insertText += `${indent}${key}: \${${insertIndex++}:${value}}\n`;
+                        }
+                        else {
+                            insertText += `${indent}${key}: $${insertIndex++}\n`;
+                        }
                         break;
+                    }
                     case 'array':
                         {
-                            const arrayInsertResult = this.getInsertTextForArray(propertySchema.items, separatorAfter, insertIndex++);
+                            const arrayInsertResult = this.getInsertTextForArray(propertySchema.items, separatorAfter, insertIndex++, indent);
                             const arrayInsertLines = arrayInsertResult.insertText.split('\n');
                             let arrayTemplate = arrayInsertResult.insertText;
                             if (arrayInsertLines.length > 1) {
@@ -692,7 +826,7 @@ export class YamlCompletion {
                         break;
                 }
             }
-            else if (propertySchema.default !== undefined) {
+            else if (!this.disableDefaultProperties && propertySchema.default !== undefined) {
                 switch (type) {
                     case 'boolean':
                     case 'number':
@@ -716,7 +850,7 @@ export class YamlCompletion {
         return { insertText, insertIndex };
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    getInsertTextForArray(schema, separatorAfter, insertIndex = 1) {
+    getInsertTextForArray(schema, separatorAfter, insertIndex = 1, indent = this.indentation) {
         let insertText = '';
         if (!schema) {
             insertText = `$${insertIndex++}`;
@@ -744,7 +878,7 @@ export class YamlCompletion {
                 break;
             case 'object':
                 {
-                    const objectInsertResult = this.getInsertTextForObject(schema, separatorAfter, `${this.indentation}  `, insertIndex++);
+                    const objectInsertResult = this.getInsertTextForObject(schema, separatorAfter, `${indent}  `, insertIndex++);
                     insertText = objectInsertResult.insertText.trimLeft();
                     insertIndex = objectInsertResult.insertIndex;
                 }
@@ -915,7 +1049,7 @@ export class YamlCompletion {
             collector.add({
                 kind: this.getSuggestionKind(schema.type),
                 label: this.getLabelForValue(schema.const),
-                insertText: this.getInsertTextForValue(schema.const, separatorAfter, undefined),
+                insertText: this.getInsertTextForValue(schema.const, separatorAfter, schema.type),
                 insertTextFormat: InsertTextFormat.Snippet,
                 documentation: this.fromMarkup(schema.markdownDescription) || schema.description,
             });
@@ -1140,8 +1274,7 @@ function convertToStringValue(value) {
     if (value === 'true' || value === 'false' || value === 'null' || isNumberExp.test(value)) {
         return `"${value}"`;
     }
-    // eslint-disable-next-line prettier/prettier, no-useless-escape
-    if (value.indexOf('\"') !== -1) {
+    if (value.indexOf('"') !== -1) {
         value = value.replace(doubleQuotesEscapeRegExp, '"');
     }
     let doQuote = value.charAt(0) === '@';
@@ -1169,4 +1302,14 @@ function convertToStringValue(value) {
     }
     return value;
 }
+/**
+ * simplify `{$1:value}` to `value`
+ */
+function evaluateTab1Symbol(value) {
+    const result = value.replace(/\$\{1:(.*)\}/, '$1');
+    return result;
+}
+function isParentCompletionItem(item) {
+    return 'parent' in item;
+}
 //# sourceMappingURL=yamlCompletion.js.map