Fix code completion with object in array (redhat-developer#562)

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

Author: evidolob

src/languageservice/services/yamlCompletion.ts

@@ -31,6 +31,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 { indexOf } from '../utils/astUtils';
 
 const localize = nls.loadMessageBundle();
@@ -242,28 +243,34 @@ export class YamlCompletion {
                   }
                 }
               } else if (node.value === null) {
-                if (isPair(parent) && parent.key === node) {
-                  node = parent;
-                } else if (
-                  isPair(parent) &&
-                  lineContent.trim().length === 0 &&
-                  textBuffer.getLineContent(position.line - 1).indexOf(':') > 0 &&
-                  textBuffer.getLineContent(position.line - 1).indexOf('-') < 0
-                ) {
-                  const map = this.createTempObjNode(currentWord, node, currentDoc);
-
-                  const parentParent = currentDoc.getParent(parent);
-                  if (parentParent && (isMap(parentParent) || isSeq(parentParent))) {
-                    parentParent.set(parent.key, map);
+                if (isPair(parent)) {
+                  if (parent.key === node) {
+                    node = parent;
                   } else {
-                    currentDoc.internalDocument.set(parent.key, map);
-                  }
-                  currentProperty = (map as YAMLMap).items[0];
-                  node = map;
-                } else if (lineContent.trim().length === 0) {
-                  const parentParent = currentDoc.getParent(parent);
-                  if (parentParent) {
-                    node = parentParent;
+                    if (isNode(parent.key) && parent.key.range) {
+                      const parentParent = currentDoc.getParent(parent);
+                      if (foundByClosest && parentParent && isMap(parentParent) && isMapContainsEmptyPair(parentParent)) {
+                        node = parentParent;
+                      } else {
+                        const parentPosition = document.positionAt(parent.key.range[0]);
+                        //if cursor has bigger indentation that parent key, then we need to complete new empty object
+                        if (position.character > parentPosition.character && position.line !== parentPosition.line) {
+                          const map = this.createTempObjNode(currentWord, node, currentDoc);
+
+                          if (parentParent && (isMap(parentParent) || isSeq(parentParent))) {
+                            parentParent.set(parent.key, map);
+                          } else {
+                            currentDoc.internalDocument.set(parent.key, map);
+                          }
+                          currentProperty = (map as YAMLMap).items[0];
+                          node = map;
+                        } else if (parentPosition.character === position.character) {
+                          if (parentParent) {
+                            node = parentParent;
+                          }
+                        }
+                      }
+                    }
                   }
                 } else if (isSeq(parent)) {
                   if (lineContent.charAt(position.character - 1) !== '-') {
@@ -373,7 +380,12 @@ export class YamlCompletion {
         const schemaProperties = schema.schema.properties;
         if (schemaProperties) {
           const maxProperties = schema.schema.maxProperties;
-          if (maxProperties === undefined || node.items === undefined || node.items.length < maxProperties) {
+          if (
+            maxProperties === undefined ||
+            node.items === undefined ||
+            node.items.length < maxProperties ||
+            isMapContainsEmptyPair(node)
+          ) {
             for (const key in schemaProperties) {
               if (Object.prototype.hasOwnProperty.call(schemaProperties, key)) {
                 const propertySchema = schemaProperties[key];

src/languageservice/utils/astUtils.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Document, isDocument, Node, visit, YAMLSeq } from 'yaml';
+import { Document, isDocument, isScalar, Node, visit, YAMLMap, YAMLSeq } from 'yaml';
 
 export function getParent(doc: Document, nodeToFind: Node): Node | undefined {
   let parentNode: Node;
@@ -20,6 +20,18 @@ export function getParent(doc: Document, nodeToFind: Node): Node | undefined {
 
   return parentNode;
 }
+export function isMapContainsEmptyPair(map: YAMLMap): boolean {
+  if (map.items.length > 1) {
+    return false;
+  }
+
+  const pair = map.items[0];
+  if (isScalar(pair.key) && isScalar(pair.value) && pair.key.value === '' && !pair.value.value) {
+    return true;
+  }
+
+  return false;
+}
 
 export function indexOf(seq: YAMLSeq, item: Node): number | undefined {
   for (const [i, obj] of seq.items.entries()) {

test/autoCompletionFix.test.ts

@@ -10,6 +10,7 @@ import { SettingsState, TextDocumentTestManager } from '../src/yamlSettings';
 import { ServiceSetup } from './utils/serviceSetup';
 import { SCHEMA_ID, setupLanguageService, setupSchemaIDTextDocument } from './utils/testHelper';
 import { expect } from 'chai';
+import { createExpectedCompletion } from './utils/verifyError';
 
 describe('Auto Completion Fix Tests', () => {
   let languageSettingsSetup: ServiceSetup;
@@ -45,6 +46,60 @@ describe('Auto Completion Fix Tests', () => {
     languageService.configure(languageSettingsSetup.languageSettings);
   });
 
+  it('should show completion on map under array', async () => {
+    languageService.addSchema(SCHEMA_ID, {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          from: {
+            type: 'object',
+            properties: {
+              foo: {
+                type: 'boolean',
+              },
+            },
+          },
+        },
+      },
+    });
+    const content = '- from:\n    ';
+    const completion = await parseSetup(content, 1, 3);
+    expect(completion.items).lengthOf(1);
+    expect(completion.items[0]).eql(
+      createExpectedCompletion('foo', 'foo: $1', 1, 3, 1, 3, 10, 2, {
+        documentation: '',
+      })
+    );
+  });
+
+  it('should show completion on array empty array item', async () => {
+    languageService.addSchema(SCHEMA_ID, {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          from: {
+            type: 'object',
+            properties: {
+              foo: {
+                type: 'boolean',
+              },
+            },
+          },
+        },
+      },
+    });
+    const content = '- ';
+    const completion = await parseSetup(content, 0, 2);
+    expect(completion.items).lengthOf(1);
+    expect(completion.items[0]).eql(
+      createExpectedCompletion('from', 'from:\n    $1', 0, 2, 0, 2, 10, 2, {
+        documentation: '',
+      })
+    );
+  });
+
   it('should show completion items in the middle of map in array', async () => {
     const content = `apiVersion: v1
 kind: Pod