Merge pull request #691 from p-spacek/feat/select-parent-skeleton-first

Select parent skeleton first before other properties are suggested

Author: msivasubramaniaan

README.md

@@ -49,6 +49,7 @@ The following settings are supported:
 - `http.proxyStrictSSL`: If true the proxy server certificate should be verified against the list of supplied CAs. Default is false.
 - `[yaml].editor.formatOnType`: Enable/disable on type indent and auto formatting array
 - `yaml.disableDefaultProperties`: Disable adding not required properties with default values into completion text
+- `yaml.suggest.parentSkeletonSelectedFirst`: If true, the user must select some parent skeleton first before autocompletion starts to suggest the rest of the properties.\nWhen yaml object is not empty, autocompletion ignores this setting and returns all properties and skeletons.
 
 ##### Adding custom tags
 

src/languageserver/handlers/settingsHandlers.ts

@@ -105,6 +105,10 @@ export class SettingsHandler {
       }
       this.yamlSettings.disableAdditionalProperties = settings.yaml.disableAdditionalProperties;
       this.yamlSettings.disableDefaultProperties = settings.yaml.disableDefaultProperties;
+
+      if (settings.yaml.suggest) {
+        this.yamlSettings.suggest.parentSkeletonSelectedFirst = settings.yaml.suggest.parentSkeletonSelectedFirst;
+      }
     }
 
     this.yamlSettings.schemaConfigurationSettings = [];
@@ -232,6 +236,7 @@ export class SettingsHandler {
       indentation: this.yamlSettings.indentation,
       disableAdditionalProperties: this.yamlSettings.disableAdditionalProperties,
       disableDefaultProperties: this.yamlSettings.disableDefaultProperties,
+      parentSkeletonSelectedFirst: this.yamlSettings.suggest.parentSkeletonSelectedFirst,
       yamlVersion: this.yamlSettings.yamlVersion,
     };
 

src/languageservice/services/yamlCompletion.ts

@@ -73,6 +73,7 @@ export class YamlCompletion {
   private indentation: string;
   private supportsMarkdown: boolean | undefined;
   private disableDefaultProperties: boolean;
+  private parentSkeletonSelectedFirst: boolean;
 
   constructor(
     private schemaService: YAMLSchemaService,
@@ -89,6 +90,7 @@ export class YamlCompletion {
     this.yamlVersion = languageSettings.yamlVersion;
     this.configuredIndentation = languageSettings.indentation;
     this.disableDefaultProperties = languageSettings.disableDefaultProperties;
+    this.parentSkeletonSelectedFirst = languageSettings.parentSkeletonSelectedFirst;
   }
 
   async doComplete(document: TextDocument, position: Position, isKubernetes = false): Promise<CompletionList> {
@@ -589,7 +591,6 @@ export class YamlCompletion {
     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) {
@@ -676,14 +677,19 @@ export class YamlCompletion {
                       identCompensation + this.indentation
                     );
                   }
-
-                  collector.add({
-                    kind: CompletionItemKind.Property,
-                    label: key,
-                    insertText,
-                    insertTextFormat: InsertTextFormat.Snippet,
-                    documentation: this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || '',
-                  });
+                  const isNodeNull =
+                    (isScalar(originalNode) && originalNode.value === null) ||
+                    (isMap(originalNode) && originalNode.items.length === 0);
+                  const existsParentCompletion = schema.schema.required?.length > 0;
+                  if (!this.parentSkeletonSelectedFirst || !isNodeNull || !existsParentCompletion) {
+                    collector.add({
+                      kind: CompletionItemKind.Property,
+                      label: key,
+                      insertText,
+                      insertTextFormat: InsertTextFormat.Snippet,
+                      documentation: this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || '',
+                    });
+                  }
                   // if the prop is required add it also to parent suggestion
                   if (schema.schema.required?.includes(key)) {
                     collector.add({

src/languageservice/yamlLanguageService.ts

@@ -98,6 +98,12 @@ export interface LanguageSettings {
    */
   disableDefaultProperties?: boolean;
 
+  /**
+   * If true, the user must select some parent skeleton first before autocompletion starts to suggest the rest of the properties.
+   * When yaml object is not empty, autocompletion ignores this setting and returns all properties and skeletons.
+   */
+  parentSkeletonSelectedFirst?: boolean;
+
   /**
    * Default yaml lang version
    */

src/yamlSettings.ts

@@ -22,6 +22,9 @@ export interface Settings {
     };
     disableDefaultProperties: boolean;
     disableAdditionalProperties: boolean;
+    suggest: {
+      parentSkeletonSelectedFirst: boolean;
+    };
     maxItemsComputed: number;
     yamlVersion: YamlVersion;
   };
@@ -69,6 +72,9 @@ export class SettingsState {
   indentation: string | undefined = undefined;
   disableAdditionalProperties = false;
   disableDefaultProperties = false;
+  suggest = {
+    parentSkeletonSelectedFirst: false,
+  };
   maxItemsComputed = 5000;
 
   // File validation helpers

test/autoCompletion.test.ts

@@ -2795,5 +2795,108 @@ describe('Auto Completion Tests', () => {
         })
       );
     });
+    describe('Select parent skeleton first', () => {
+      beforeEach(() => {
+        const languageSettingsSetup = new ServiceSetup().withCompletion();
+        languageSettingsSetup.languageSettings.parentSkeletonSelectedFirst = true;
+        languageService.configure(languageSettingsSetup.languageSettings);
+      });
+      it('Should suggest complete object skeleton', async () => {
+        const schema = {
+          definitions: { obj1, obj2 },
+          anyOf: [
+            {
+              $ref: '#/definitions/obj1',
+            },
+            {
+              $ref: '#/definitions/obj2',
+            },
+          ],
+        };
+        languageService.addSchema(SCHEMA_ID, schema);
+        const content = '';
+        const result = await parseSetup(content, content.length);
+
+        expect(result.items.map((i) => i.label)).to.have.members(['Object1', 'obj2']);
+      });
+      it('Should suggest complete object skeleton - nested', async () => {
+        const schema = {
+          definitions: { obj1, obj2 },
+          properties: {
+            name: {
+              anyOf: [
+                {
+                  $ref: '#/definitions/obj1',
+                },
+                {
+                  $ref: '#/definitions/obj2',
+                },
+              ],
+            },
+          },
+        };
+        languageService.addSchema(SCHEMA_ID, schema);
+        const content = 'name:\n  ';
+        const result = await parseSetup(content, content.length);
+
+        expect(result.items.map((i) => i.label)).to.have.members(['Object1', 'obj2']);
+      });
+      it('Should suggest complete object skeleton - array', async () => {
+        const schema = {
+          definitions: { obj1, obj2 },
+          items: {
+            anyOf: [
+              {
+                $ref: '#/definitions/obj1',
+              },
+              {
+                $ref: '#/definitions/obj2',
+              },
+            ],
+          },
+          type: 'array',
+        };
+        languageService.addSchema(SCHEMA_ID, schema);
+        const content = '- ';
+        const result = await parseSetup(content, content.length);
+
+        expect(result.items.map((i) => i.label)).to.have.members(['Object1', 'obj2']);
+      });
+      it('Should suggest rest of the parent object', async () => {
+        const schema = {
+          definitions: { obj1 },
+          $ref: '#/definitions/obj1',
+        };
+        languageService.addSchema(SCHEMA_ID, schema);
+        const content = 'type: typeObj1\n';
+        const result = await parseSetup(content, content.length);
+
+        expect(result.items.map((i) => i.label)).to.have.members(['options', 'Object1']);
+      });
+      it('Should suggest all feature when user is typing', async () => {
+        const schema = {
+          definitions: { obj1 },
+          $ref: '#/definitions/obj1',
+        };
+        languageService.addSchema(SCHEMA_ID, schema);
+        const content = 'ty';
+        const result = await parseSetup(content, content.length);
+
+        expect(result.items.map((i) => i.label)).to.have.members(['type', 'options', 'Object1']);
+      });
+      it('Should suggest all properties in empty yaml with now required props', async () => {
+        const schema = {
+          properties: {
+            fruit: {},
+            vegetable: {},
+          },
+        };
+        languageService.addSchema(SCHEMA_ID, schema);
+        const content = '';
+        const result = await parseSetup(content, content.length);
+
+        expect(result.items.map((i) => i.label)).to.have.members(['fruit', 'vegetable']);
+      });
+    });
   });
 });