Allow graceful matching by parameter and repair null values matching

Author: brian-mulier-p

src/languageserver/handlers/languageHandlers.ts

@@ -156,7 +156,7 @@ export class LanguageHandlers {
    * Called when auto-complete is triggered in an editor
    * Returns a list of valid completion items
    */
-  completionHandler(textDocumentPosition: TextDocumentPositionParams): Promise<CompletionList> {
+  completionHandler(textDocumentPosition: TextDocumentPositionParams, gracefulMatches = false): Promise<CompletionList> {
     const textDocument = this.yamlSettings.documents.get(textDocumentPosition.textDocument.uri);
 
     const result: CompletionList = {
@@ -170,7 +170,9 @@ export class LanguageHandlers {
     return this.languageService.doComplete(
       textDocument,
       textDocumentPosition.position,
-      isKubernetesAssociatedDocument(textDocument, this.yamlSettings.specificValidatorPaths)
+      isKubernetesAssociatedDocument(textDocument, this.yamlSettings.specificValidatorPaths),
+      true,
+      gracefulMatches
     );
   }
 

src/languageservice/parser/jsonParser07.ts

@@ -614,13 +614,15 @@ export class JSONDocument {
    * @param focusOffset  offsetValue
    * @param exclude excluded Node
    * @param didCallFromAutoComplete true if method called from AutoComplete
+   * @param gracefulMatches true if graceful matching should be done, meaning that if at least one property is validated in a sub schema, it's kept as a candidate
    * @returns array of applicable schemas
    */
   public getMatchingSchemas(
     schema: JSONSchema,
     focusOffset = -1,
     exclude: ASTNode = null,
-    didCallFromAutoComplete?: boolean
+    didCallFromAutoComplete?: boolean,
+    gracefulMatches?: boolean
   ): IApplicableSchema[] {
     const matchingSchemas = new SchemaCollector(focusOffset, exclude);
     if (this.root && schema) {
@@ -629,6 +631,7 @@ export class JSONDocument {
         disableAdditionalProperties: this.disableAdditionalProperties,
         uri: this.uri,
         callFromAutoComplete: didCallFromAutoComplete,
+        gracefulMatches: gracefulMatches,
       });
     }
     return matchingSchemas.schemas;
@@ -639,6 +642,7 @@ interface Options {
   disableAdditionalProperties: boolean;
   uri: string;
   callFromAutoComplete?: boolean;
+  gracefulMatches?: boolean;
 }
 function validate(
   node: ASTNode,
@@ -649,7 +653,7 @@ function validate(
   options: Options
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ): any {
-  const { isKubernetes, callFromAutoComplete } = options;
+  const { isKubernetes, callFromAutoComplete, gracefulMatches } = options;
   if (!node) {
     return;
   }
@@ -870,7 +874,7 @@ function validate(
       const val = getNodeValue(node);
       let enumValueMatch = false;
       for (const e of schema.enum) {
-        if (val === e || (callFromAutoComplete && isString(val) && isString(e) && val && e.startsWith(val))) {
+        if (val === e || (callFromAutoComplete && (val === null || (isString(val) && isString(e) && val && e.startsWith(val))))) {
           enumValueMatch = true;
           break;
         }
@@ -904,7 +908,7 @@ function validate(
       const val = getNodeValue(node);
       if (
         !equals(val, schema.const) &&
-        !(callFromAutoComplete && isString(val) && isString(schema.const) && schema.const.startsWith(val))
+        !(callFromAutoComplete && (val === null || (isString(val) && isString(schema.const) && schema.const.startsWith(val))))
       ) {
         validationResult.problems.push({
           location: { offset: node.offset, length: node.length },
@@ -1503,10 +1507,14 @@ function validate(
     return bestMatch;
   }
 
+  function gracefulMatchFilter(maxOneMatch: boolean, propertiesValueMatches: number): boolean {
+    return gracefulMatches && !maxOneMatch && callFromAutoComplete && propertiesValueMatches > 0;
+  }
+
   //genericComparison tries to find the best matching schema using a generic comparison
   function genericComparison(
     node: ASTNode,
-    maxOneMatch,
+    maxOneMatch: boolean,
     subValidationResult: ValidationResult,
     bestMatch: {
       schema: JSONSchema;
@@ -1520,11 +1528,7 @@ function validate(
     validationResult: ValidationResult;
     matchingSchemas: ISchemaCollector;
   } {
-    if (
-      !maxOneMatch &&
-      !subValidationResult.hasProblems() &&
-      (!bestMatch.validationResult.hasProblems() || callFromAutoComplete)
-    ) {
+    if (!maxOneMatch && !subValidationResult.hasProblems() && !bestMatch.validationResult.hasProblems()) {
       // no errors, both are equally good matches
       bestMatch.matchingSchemas.merge(subMatchingSchemas);
       bestMatch.validationResult.propertiesMatches += subValidationResult.propertiesMatches;
@@ -1545,7 +1549,11 @@ function validate(
           validationResult: subValidationResult,
           matchingSchemas: subMatchingSchemas,
         };
-      } else if (compareResult === 0) {
+      } else if (
+        compareResult === 0 ||
+        ((node.value === null || node.type === 'null') && node.length === 0) ||
+        gracefulMatchFilter(maxOneMatch, subValidationResult.propertiesValueMatches)
+      ) {
         // there's already a best matching but we are as good
         bestMatch.matchingSchemas.merge(subMatchingSchemas);
         bestMatch.validationResult.mergeEnumValues(subValidationResult);

src/languageservice/services/yamlCompletion.ts

@@ -101,7 +101,13 @@ export class YamlCompletion {
     this.parentSkeletonSelectedFirst = languageSettings.parentSkeletonSelectedFirst;
   }
 
-  async doComplete(document: TextDocument, position: Position, isKubernetes = false, doComplete = true): Promise<CompletionList> {
+  async doComplete(
+    document: TextDocument,
+    position: Position,
+    isKubernetes = false,
+    doComplete = true,
+    gracefulMatches = false
+  ): Promise<CompletionList> {
     const result = CompletionList.create([], false);
     if (!this.completionEnabled) {
       return result;
@@ -519,7 +525,8 @@ export class YamlCompletion {
           collector,
           textBuffer,
           overwriteRange,
-          doComplete
+          doComplete,
+          gracefulMatches
         );
 
         if (!schema && currentWord.length > 0 && text.charAt(offset - currentWord.length - 1) !== '"') {
@@ -534,7 +541,7 @@ export class YamlCompletion {
 
       // proposals for values
       const types: { [type: string]: boolean } = {};
-      this.getValueCompletions(schema, currentDoc, node, offset, document, collector, types, doComplete);
+      this.getValueCompletions(schema, currentDoc, node, offset, document, collector, types, doComplete, gracefulMatches);
     } catch (err) {
       this.telemetry?.sendError('yaml.completion.error', err);
     }
@@ -674,9 +681,10 @@ export class YamlCompletion {
     collector: CompletionsCollector,
     textBuffer: TextBuffer,
     overwriteRange: Range,
-    doComplete: boolean
+    doComplete: boolean,
+    gracefulMatches: boolean
   ): void {
-    const matchingSchemas = doc.getMatchingSchemas(schema.schema, -1, null, doComplete);
+    const matchingSchemas = doc.getMatchingSchemas(schema.schema, -1, null, doComplete, gracefulMatches);
     const existingKey = textBuffer.getText(overwriteRange);
     const lineContent = textBuffer.getLineContent(overwriteRange.start.line);
     const hasOnlyWhitespace = lineContent.trim().length === 0;
@@ -874,7 +882,8 @@ export class YamlCompletion {
     document: TextDocument,
     collector: CompletionsCollector,
     types: { [type: string]: boolean },
-    doComplete: boolean
+    doComplete: boolean,
+    gracefulMatches: boolean
   ): void {
     let parentKey: string = null;
 
@@ -898,7 +907,7 @@ export class YamlCompletion {
 
     if (node && (parentKey !== null || isSeq(node))) {
       const separatorAfter = '';
-      const matchingSchemas = doc.getMatchingSchemas(schema.schema, -1, null, doComplete);
+      const matchingSchemas = doc.getMatchingSchemas(schema.schema, -1, null, doComplete, gracefulMatches);
       for (const s of matchingSchemas) {
         if (s.node.internalNode === node && !s.inverted && s.schema) {
           if (s.schema.items) {

src/languageservice/yamlLanguageService.ts

@@ -159,7 +159,13 @@ export interface CustomFormatterOptions {
 export interface LanguageService {
   configure: (settings: LanguageSettings) => void;
   registerCustomSchemaProvider: (schemaProvider: CustomSchemaProvider) => void;
-  doComplete: (document: TextDocument, position: Position, isKubernetes: boolean) => Promise<CompletionList>;
+  doComplete: (
+    document: TextDocument,
+    position: Position,
+    isKubernetes: boolean,
+    doComplete?: boolean,
+    gracefulMatches?: boolean
+  ) => Promise<CompletionList>;
   doValidation: (document: TextDocument, isKubernetes: boolean) => Promise<Diagnostic[]>;
   doHover: (document: TextDocument, position: Position) => Promise<Hover | null>;
   findDocumentSymbols: (document: TextDocument, context?: DocumentSymbolsContext) => SymbolInformation[];

test/autoCompletion.test.ts

@@ -52,20 +52,24 @@ describe('Auto Completion Tests', () => {
    * @param position The position of the caret in the document.
    * Alternatively, `position` can be omitted if the caret is located in the content using `|` bookends.
    * For example, `content = 'ab|c|d'` places the caret over the `'c'`, at `position = 2`
+   * @param gracefulMatches are worse matches allowed
    * @returns A list of valid completions.
    */
-  function parseSetup(content: string, position?: number): Promise<CompletionList> {
+  function parseSetup(content: string, position?: number, gracefulMatches?: boolean): Promise<CompletionList> {
     if (typeof position === 'undefined') {
       ({ content, position } = caretPosition(content));
     }
 
     const testTextDocument = setupSchemaIDTextDocument(content);
     yamlSettings.documents = new TextDocumentTestManager();
     (yamlSettings.documents as TextDocumentTestManager).set(testTextDocument);
-    return languageHandler.completionHandler({
-      position: testTextDocument.positionAt(position),
-      textDocument: testTextDocument,
-    });
+    return languageHandler.completionHandler(
+      {
+        position: testTextDocument.positionAt(position),
+        textDocument: testTextDocument,
+      },
+      gracefulMatches
+    );
   }
 
   afterEach(() => {
@@ -2217,6 +2221,69 @@ describe('Auto Completion Tests', () => {
       expect(completion.items[0].insertText).eq('fooBar:\n    name: $1\n    aaa:\n      - $2');
     });
 
+    it('graceful matching should give multiple matches with anyOf where at least one property is matching', async () => {
+      schemaProvider.addSchema(SCHEMA_ID, {
+        anyOf: [
+          {
+            type: 'object',
+            properties: {
+              type: {
+                const: 'a.a',
+              },
+              maybeProp: {
+                type: 'string',
+              },
+            },
+            required: ['type'],
+          },
+          {
+            type: 'object',
+            properties: {
+              type: {
+                const: 'a.b',
+              },
+              field: {
+                type: 'string',
+              },
+            },
+            required: ['type', 'field'],
+          },
+          {
+            type: 'object',
+            properties: {
+              type: {
+                const: 'a.c',
+              },
+              mandatoryProp: {
+                type: 'string',
+              },
+            },
+            required: ['type', 'mandatoryProp'],
+          },
+        ],
+      });
+
+      async function expectCompletionsOrAll(
+        content: string,
+        gracefulMatches: boolean,
+        expectedCompletions = ['a.a', 'a.b', 'a.c']
+      ): Promise<void> {
+        const completion = await parseSetup(content, undefined, gracefulMatches);
+        expect(completion.items).lengthOf(expectedCompletions.length);
+        expect(completion.items.map(({ label }) => label)).eql(expectedCompletions);
+      }
+
+      await expectCompletionsOrAll('type: |\n|', false, ['a.a']);
+      await expectCompletionsOrAll('type: a.|\n|', false, ['a.a']);
+      await expectCompletionsOrAll('type: |\n|field: "a"', false, ['a.a', 'a.b']);
+      await expectCompletionsOrAll('type: |\n|mandatoryProp: "a"', false, ['a.a', 'a.c']);
+
+      await expectCompletionsOrAll('type: |\n|', true);
+      await expectCompletionsOrAll('type: a.|\n|', true);
+      await expectCompletionsOrAll('type: |\n|field: "a"', true);
+      await expectCompletionsOrAll('type: |\n|mandatoryProp: "a"', true);
+    });
+
     it('auto completion based on the list indentation', async () => {
       schemaProvider.addSchema(SCHEMA_ID, {
         type: 'array',