Merge branch 'main' into feat/property-snippets

p-spacek · web-flow · commit 4e05825ea242 · 2025-04-29T09:47:11.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,16 @@
+### 1.18.0
+- Feat: Do not suggest propertyNames if doNotSuggest is true [#1045](https://github.com/redhat-developer/yaml-language-server/pull/1045)
+- Feat: Exclude not suggest properties from possible properties error [#1051](https://github.com/redhat-developer/yaml-language-server/pull/1051)
+- Feat: Fix enum values to be unique [#1028](https://github.com/redhat-developer/yaml-language-server/pull/1028)
+- Fix: URL-encoded characters in $ref paths break schema resolution [#1082](https://github.com/redhat-developer/vscode-yaml/issues/1082)
+- Fix: Tests fail with Node.JS 23.7.x [#1018](https://github.com/redhat-developer/yaml-language-server/issues/1018)
+- Fix: Autocompletion problem when value is null inside anyOf object [#684](https://github.com/redhat-developer/yaml-language-server/issues/684)
+- Fix: Enum strings YES / NO are converted to boolean incorrectly [#1036](https://github.com/redhat-developer/yaml-language-server/issues/1036)
+- Fix: Autocompletion with escape sequence chars [#1040](https://github.com/redhat-developer/yaml-language-server/pull/1040)
+- Fix: multipleOf does not work for floats [#985](https://github.com/redhat-developer/yaml-language-server/issues/985)
+
+Thanks to [Petr Spacek](https://github.com/p-spacek), [Kosta](https://github.com/Kosta-Github) and [Willem Jan](https://github.com/Willem-J-an) for your contributions.
+
 ### 1.17.0
 - Feat: Supported docker arm64 image [#1027](https://github.com/redhat-developer/yaml-language-server/pull/1027)
 - Fix: Reverted ajv-draft04 as it not support HTTPS [#1026](https://github.com/redhat-developer/yaml-language-server/pull/1026)
diff --git a/src/languageservice/parser/jsonParser07.ts b/src/languageservice/parser/jsonParser07.ts
@@ -537,6 +537,12 @@ export function findNodeAtOffset(node: ASTNode, offset: number, includeRightBoun
   return undefined;
 }
 
+interface IValidationMatch {
+  schema: JSONSchema;
+  validationResult: ValidationResult;
+  matchingSchemas: ISchemaCollector;
+}
+
 export class JSONDocument {
   public isKubernetes: boolean;
   public disableAdditionalProperties: boolean;
@@ -870,7 +876,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 || isAutoCompleteEqualMaybe(callFromAutoComplete, node, val, e)) {
           enumValueMatch = true;
           break;
         }
@@ -902,10 +908,7 @@ function validate(
 
     if (isDefined(schema.const)) {
       const val = getNodeValue(node);
-      if (
-        !equals(val, schema.const) &&
-        !(callFromAutoComplete && isString(val) && isString(schema.const) && schema.const.startsWith(val))
-      ) {
+      if (!equals(val, schema.const) && !isAutoCompleteEqualMaybe(callFromAutoComplete, node, val, schema.const)) {
         validationResult.problems.push({
           location: { offset: node.offset, length: node.length },
           severity: DiagnosticSeverity.Warning,
@@ -1374,7 +1377,21 @@ function validate(
       (schema.type === 'object' && schema.additionalProperties === undefined && options.disableAdditionalProperties === true)
     ) {
       if (unprocessedProperties.length > 0) {
-        const possibleProperties = schema.properties && Object.keys(schema.properties).filter((prop) => !seenKeys[prop]);
+        const possibleProperties =
+          schema.properties &&
+          Object.entries(schema.properties)
+            .filter(([key, property]) => {
+              // don't include existing properties
+              if (seenKeys[key]) {
+                return false;
+              }
+              // don't include properties that are not suggested in completion
+              if (property && typeof property === 'object' && (property.doNotSuggest || property.deprecationMessage)) {
+                return false;
+              }
+              return true;
+            })
+            .map(([key]) => key);
 
         for (const propertyName of unprocessedProperties) {
           const child = seenKeys[propertyName];
@@ -1508,23 +1525,11 @@ function validate(
     node: ASTNode,
     maxOneMatch,
     subValidationResult: ValidationResult,
-    bestMatch: {
-      schema: JSONSchema;
-      validationResult: ValidationResult;
-      matchingSchemas: ISchemaCollector;
-    },
+    bestMatch: IValidationMatch,
     subSchema,
     subMatchingSchemas
-  ): {
-    schema: JSONSchema;
-    validationResult: ValidationResult;
-    matchingSchemas: ISchemaCollector;
-  } {
-    if (
-      !maxOneMatch &&
-      !subValidationResult.hasProblems() &&
-      (!bestMatch.validationResult.hasProblems() || callFromAutoComplete)
-    ) {
+  ): IValidationMatch {
+    if (!maxOneMatch && !subValidationResult.hasProblems() && !bestMatch.validationResult.hasProblems()) {
       // no errors, both are equally good matches
       bestMatch.matchingSchemas.merge(subMatchingSchemas);
       bestMatch.validationResult.propertiesMatches += subValidationResult.propertiesMatches;
@@ -1545,19 +1550,30 @@ function validate(
           validationResult: subValidationResult,
           matchingSchemas: subMatchingSchemas,
         };
-      } else if (compareResult === 0) {
+      } else if (
+        compareResult === 0 ||
+        ((node.value === null || node.type === 'null') && node.length === 0) // node with no value can match any schema potentially
+      ) {
         // there's already a best matching but we are as good
-        bestMatch.matchingSchemas.merge(subMatchingSchemas);
-        bestMatch.validationResult.mergeEnumValues(subValidationResult);
-        bestMatch.validationResult.mergeWarningGeneric(subValidationResult, [
-          ProblemType.missingRequiredPropWarning,
-          ProblemType.typeMismatchWarning,
-          ProblemType.constWarning,
-        ]);
+        mergeValidationMatches(bestMatch, subMatchingSchemas, subValidationResult);
       }
     }
     return bestMatch;
   }
+
+  function mergeValidationMatches(
+    bestMatch: IValidationMatch,
+    subMatchingSchemas: ISchemaCollector,
+    subValidationResult: ValidationResult
+  ): void {
+    bestMatch.matchingSchemas.merge(subMatchingSchemas);
+    bestMatch.validationResult.mergeEnumValues(subValidationResult);
+    bestMatch.validationResult.mergeWarningGeneric(subValidationResult, [
+      ProblemType.missingRequiredPropWarning,
+      ProblemType.typeMismatchWarning,
+      ProblemType.constWarning,
+    ]);
+  }
 }
 
 function getSchemaSource(schema: JSONSchema, originalSchema: JSONSchema): string | undefined {
@@ -1595,3 +1611,26 @@ function getSchemaUri(schema: JSONSchema, originalSchema: JSONSchema): string[]
 function getWarningMessage(problemType: ProblemType, args: string[]): string {
   return localize(problemType, ProblemTypeMessages[problemType], args.join(' | '));
 }
+
+/**
+ * if callFromAutoComplete than compare value from yaml and value from schema (s.const | s.enum[i])
+ * allows partial match for autocompletion
+ */
+function isAutoCompleteEqualMaybe(
+  callFromAutoComplete: boolean,
+  node: ASTNode,
+  nodeValue: unknown,
+  schemaValue: unknown
+): boolean {
+  if (!callFromAutoComplete) {
+    return false;
+  }
+
+  // if autocompletion property doesn't have value, then it could be a match
+  const isWithoutValue = nodeValue === null && node.length === 0; // allows `prop: ` but ignore `prop: null`
+  if (isWithoutValue) {
+    return true;
+  }
+
+  return isString(nodeValue) && isString(schemaValue) && schemaValue.startsWith(nodeValue);
+}
diff --git a/src/languageservice/services/yamlCompletion.ts b/src/languageservice/services/yamlCompletion.ts
@@ -862,14 +862,16 @@ export class YamlCompletion {
 
         if (schema.schema.propertyNames && schema.schema.additionalProperties && schema.schema.type === 'object') {
           const propertyNameSchema = asSchema(schema.schema.propertyNames);
-          const label = propertyNameSchema.title || 'property';
-          collector.add({
-            kind: CompletionItemKind.Property,
-            label,
-            insertText: '$' + `{1:${label}}: `,
-            insertTextFormat: InsertTextFormat.Snippet,
-            documentation: this.fromMarkup(propertyNameSchema.markdownDescription) || propertyNameSchema.description || '',
-          });
+          if (!propertyNameSchema.deprecationMessage && !propertyNameSchema.doNotSuggest) {
+            const label = propertyNameSchema.title || 'property';
+            collector.add({
+              kind: CompletionItemKind.Property,
+              label,
+              insertText: '$' + `{1:${label}}: `,
+              insertTextFormat: InsertTextFormat.Snippet,
+              documentation: this.fromMarkup(propertyNameSchema.markdownDescription) || propertyNameSchema.description || '',
+            });
+          }
         }
       }
 
diff --git a/test/autoCompletionFix.test.ts b/test/autoCompletionFix.test.ts
@@ -792,6 +792,157 @@ objB:
       expect(completion.items[0].label).to.be.equal('prop');
       expect(completion.items[0].insertText).to.be.equal('prop: ${1|const value,null|}');
     });
+    it('should take all sub-schemas when value has not been set (cursor in the middle of the empty space)', async () => {
+      const schema: JSONSchema = {
+        anyOf: [
+          {
+            properties: {
+              prop: { type: 'null' },
+            },
+          },
+          {
+            properties: {
+              prop: { const: 'const value' },
+            },
+          },
+          {
+            properties: {
+              prop: { const: 5 },
+            },
+          },
+        ],
+      };
+      schemaProvider.addSchema(SCHEMA_ID, schema);
+      const content = 'prop: | | ';
+      const completion = await parseCaret(content);
+      expect(completion.items.map((i) => i.label)).to.be.deep.eq(['const value', '5', 'null']);
+    });
+    it('should take only null sub-schema when value is "null"', async () => {
+      const schema: JSONSchema = {
+        anyOf: [
+          {
+            properties: {
+              prop: { type: 'null' },
+            },
+          },
+          {
+            properties: {
+              prop: { const: 'const value' },
+            },
+          },
+        ],
+      };
+      schemaProvider.addSchema(SCHEMA_ID, schema);
+      const content = 'prop: null';
+      const completion = await parseSetup(content, 0, content.length);
+      expect(completion.items.map((i) => i.label)).to.be.deep.eq(['null']);
+    });
+    it('should take only one sub-schema because first sub-schema does not match', async () => {
+      const schema: JSONSchema = {
+        anyOf: [
+          {
+            properties: {
+              prop: { const: 'const value' },
+            },
+          },
+          {
+            properties: {
+              prop: { const: 'const value2' },
+            },
+          },
+        ],
+      };
+      schemaProvider.addSchema(SCHEMA_ID, schema);
+      const content = 'prop: const value2';
+      const completion = await parseSetup(content, 0, content.length);
+      expect(completion.items.map((i) => i.label)).to.be.deep.eq(['const value2']);
+    });
+    it('should match only second sub-schema because the first one does not match', async () => {
+      const schema: JSONSchema = {
+        anyOf: [
+          {
+            properties: {
+              prop: {
+                const: 'typeA',
+              },
+              propA: {},
+            },
+          },
+          {
+            properties: {
+              prop: {
+                const: 'typeB',
+              },
+              propB: {},
+            },
+          },
+        ],
+      };
+      schemaProvider.addSchema(SCHEMA_ID, schema);
+      const content = 'prop: typeB\n|\n|';
+      const completion = await parseCaret(content);
+      expect(completion.items.map((i) => i.label)).to.be.deep.eq(['propB']);
+    });
+    it('should suggest from all sub-schemas even if nodes properties match better other schema', async () => {
+      // this is a case when we have a better match in the second schema but we should still suggest from the first one
+      // it works because `prop: ` will evaluate to `enumValueMatch = true` for both schemas
+      const schema: JSONSchema = {
+        anyOf: [
+          {
+            properties: {
+              prop: {
+                const: 'typeA',
+              },
+            },
+          },
+          {
+            properties: {
+              prop: {
+                const: 'typeB',
+              },
+              propB: {},
+            },
+          },
+        ],
+      };
+      schemaProvider.addSchema(SCHEMA_ID, schema);
+      const content = 'prop: |\n|\npropB: B';
+      const completion = await parseCaret(content);
+      expect(completion.items.map((i) => i.label)).to.be.deep.eq(['typeA', 'typeB'], 'with null value');
+
+      const content2 = 'prop: typ|\n|\npropB: B';
+      const completion2 = await parseCaret(content2);
+      expect(completion2.items.map((i) => i.label)).to.be.deep.eq(['typeA', 'typeB'], 'with prefix value');
+    });
+
+    it('should suggest both sub-schemas for anyof array', async () => {
+      const schema: JSONSchema = {
+        properties: {
+          entities: {
+            type: 'array',
+            items: {
+              anyOf: [
+                {
+                  enum: ['enum1'],
+                },
+                {
+                  type: 'object',
+                  title: 'entity object',
+                  properties: {
+                    entityProp: { type: 'string' },
+                  },
+                  required: ['entityProp'],
+                },
+              ],
+            },
+          },
+        },
+      };
+      schemaProvider.addSchema(SCHEMA_ID, schema);
+      const content = 'entities:\n  - |\n|';
+      const completion = await parseCaret(content);
+      expect(completion.items.map((i) => i.label)).to.be.deep.eq(['enum1', 'entityProp', 'entity object']);
+    });
   });
 
   describe('extra space after cursor', () => {
@@ -1362,6 +1513,22 @@ test1:
     expect(completion.items[0].insertText).to.be.equal('${1:property}: ');
     expect(completion.items[0].documentation).to.be.equal('Property Description');
   });
+  it('should not suggest propertyNames with doNotSuggest', async () => {
+    const schema: JSONSchema = {
+      type: 'object',
+      additionalProperties: true,
+      propertyNames: {
+        title: 'property',
+        doNotSuggest: true,
+      },
+    };
+    schemaProvider.addSchema(SCHEMA_ID, schema);
+    const content = '';
+    const completion = await parseSetup(content, 0, content.length);
+
+    expect(completion.items.length).equal(0);
+  });
+
   it('should suggest enum based on type', async () => {
     const schema: JSONSchema = {
       type: 'object',
diff --git a/test/schemaValidation.test.ts b/test/schemaValidation.test.ts
