Hover fails with JSON parse error on YAML 1.1 boolean values (True/False/Yes/No)

[lawrencetroup]

Describe the bug

When hovering over YAML 1.1 boolean values like True, False, Yes, No, on, off, etc., the hover feature fails with a JSON parse error. This is a regression introduced in v1.19.0. This is seen when using the VSCode Yaml Extension (https://github.com/redhat-developer/vscode-yaml)

Error message:

Request textDocument/hover failed.
  Message: Request textDocument/hover failed with message: Unexpected token 'F', "False" is not valid JSON
  Code: -32603

Root cause: The equals() function in src/languageservice/utils/objects.ts uses JSON.parse() to convert boolean source strings, but JSON.parse() only accepts lowercase "true" or "false". YAML 1.1 accepts many boolean representations (True, False, Yes, No, yes, no, on, off, etc.) which cause the parse to fail.

This was introduced by commit e6165e4 (and 4370b5c) which fixed #1078 and #1116 by changing getNodeValue() to return node.source for booleans, but the equals() function wasn't updated to handle all YAML 1.1 boolean string formats.

Example schema:

{
  "type": "object",
  "properties": {
    "enabled": {
      "type": "boolean",
      "enum": [true, false],
      "description": "Enable or disable the feature"
    }
  }
}

Example YAML:

enabled: True

Expected Behavior

Hover should display the schema description and allowed values without error when hovering over YAML 1.1 boolean values like True, False, Yes, No, etc.

Current Behavior

The hover request fails with Unexpected token 'F', "False" is not valid JSON (or similar for other YAML 1.1 boolean representations).

Steps to Reproduce

1. Configure yaml-language-server to use YAML 1.1 mode (yamlVersion: '1.1')

2. Create a YAML file associated with a schema that has a boolean property with enum or const

3. In the YAML file, use a YAML 1.1 boolean representation like enabled: True or enabled: False (capital letters) or enabled: yes/enabled: no

4. Hover over the boolean value - the error appears

Environment

• Linux

Additional environment details:

• yaml-language-server version: v1.19.0+ (regression from v1.18.0)
• vscode-yaml version: v1.19.1 (regression from v1.18.0)
• Node.js version: 18.x

Related issues:

• Using bool values in enum and const generates a validation error for valid values #1078 - Using bool values in enum and const generates a validation error for valid values
• QuickFix not rendering on number/integer allowed values #1116 - Validation shows false negative errors if using boolean with const

[lawrencetroup]

I have a proposed fix for this issue which I have tested resolves the issue, but I don't have permissions to push branches to this repo, so pasting the diff below:

diff --git a/src/languageservice/utils/objects.ts b/src/languageservice/utils/objects.ts
index 5057e5d..24d90a3 100644
--- a/src/languageservice/utils/objects.ts
+++ b/src/languageservice/utils/objects.ts
@@ -3,10 +3,12 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/

+import { parseYamlBoolean } from '../parser/scalar-type';
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
 export function equals(one: any, other: any, type?: any): boolean {
-  if (type === 'boolean') {
-    one = JSON.parse(one);
+  if (type === 'boolean' && typeof one === 'string') {
+    one = parseYamlBoolean(one);
   }
   if (one === other) {
     return true;
diff --git a/test/hover.test.ts b/test/hover.test.ts
index f524a6b..25d71cb 100644
--- a/test/hover.test.ts
+++ b/test/hover.test.ts
@@ -1029,4 +1029,115 @@ Source: [${SCHEMA_ID}](file:///${SCHEMA_ID})`
       expect(result).to.be.null;
     });
   });
+
+  describe('YAML 1.1 boolean hover', () => {
+    let yaml11LanguageHandler: LanguageHandlers;
+    let yaml11Settings: SettingsState;
+    let yaml11SchemaProvider: TestCustomSchemaProvider;
+
+    before(() => {
+      const yaml11Setup = new ServiceSetup().withHover().withYamlVersion('1.1');
+      const {
+        languageHandler: langHandler,
+        yamlSettings: settings,
+        schemaProvider: testSchemaProvider,
+      } = setupLanguageService(yaml11Setup.languageSettings);
+      yaml11LanguageHandler = langHandler;
+      yaml11Settings = settings;
+      yaml11SchemaProvider = testSchemaProvider;
+    });
+
+    afterEach(() => {
+      yaml11SchemaProvider.deleteSchema(SCHEMA_ID);
+    });
+
+    function parseSetupYaml11(content: string, position?: number): Promise<Hover> {
+      if (typeof position === 'undefined') {
+        ({ content, position } = caretPosition(content));
+      }
+      const testTextDocument = setupSchemaIDTextDocument(content);
+      yaml11Settings.documents = new TextDocumentTestManager();
+      (yaml11Settings.documents as TextDocumentTestManager).set(testTextDocument);
+      return yaml11LanguageHandler.hoverHandler({
+        position: testTextDocument.positionAt(position),
+        textDocument: testTextDocument,
+      });
+    }
+
+    it('Hover on YAML 1.1 boolean value "True" with enum schema', async () => {
+      yaml11SchemaProvider.addSchema(SCHEMA_ID, {
+        type: 'object',
+        properties: {
+          enabled: {
+            type: 'boolean',
+            description: 'Enable or disable the feature',
+            enum: [true, false],
+          },
+        },
+      });
+      const content = 'enabled: |T|rue';
+      const result = await parseSetupYaml11(content);
+
+      assert.strictEqual(MarkupContent.is(result.contents), true);
+      assert.notStrictEqual((result.contents as MarkupContent).value, '');
+      expect((result.contents as MarkupContent).value).to.include('Enable or disable the feature');
+    });
+
+    it('Hover on YAML 1.1 boolean value "False" with enum schema', async () => {
+      yaml11SchemaProvider.addSchema(SCHEMA_ID, {
+        type: 'object',
+        properties: {
+          enabled: {
+            type: 'boolean',
+            description: 'Enable or disable the feature',
+            enum: [true, false],
+          },
+        },
+      });
+      const content = 'enabled: |F|alse';
+      const result = await parseSetupYaml11(content);
+
+      assert.strictEqual(MarkupContent.is(result.contents), true);
+      assert.notStrictEqual((result.contents as MarkupContent).value, '');
+      expect((result.contents as MarkupContent).value).to.include('Enable or disable the feature');
+    });
+
+    it('Hover on YAML 1.1 boolean value "yes" with const schema', async () => {
+      yaml11SchemaProvider.addSchema(SCHEMA_ID, {
+        type: 'object',
+        properties: {
+          confirmed: {
+            type: 'boolean',
+            description: 'Confirmation flag',
+            const: true,
+          },
+        },
+      });
+      const content = 'confirmed: |y|es';
+      const result = await parseSetupYaml11(content);
+
+      assert.strictEqual(MarkupContent.is(result.contents), true);
+      assert.notStrictEqual((result.contents as MarkupContent).value, '');
+      expect((result.contents as MarkupContent).value).to.include('Confirmation flag');
+    });
+
+    it('Hover on YAML 1.1 boolean value "no" with const schema', async () => {
+      yaml11SchemaProvider.addSchema(SCHEMA_ID, {
+        type: 'object',
+        properties: {
+          disabled: {
+            type: 'boolean',
+            description: 'Disabled flag',
+            const: false,
+          },
+        },
+      });
+      const content = 'disabled: |n|o';
+      const result = await parseSetupYaml11(content);
+
+      assert.strictEqual(MarkupContent.is(result.contents), true);
+      assert.notStrictEqual((result.contents as MarkupContent).value, '');
+      expect((result.contents as MarkupContent).value).to.include('Disabled flag');
+    });
+  });
 });
diff --git a/test/schemaValidation.test.ts b/test/schemaValidation.test.ts
index b2ad7bc..cdd41f7 100644
--- a/test/schemaValidation.test.ts
+++ b/test/schemaValidation.test.ts
@@ -225,6 +225,72 @@ describe('Validation Tests', () => {
         })
         .then(done, done);
     });
+
+    it('Test that YAML 1.1 boolean "True" can be used in enum', async () => {
+      // This test requires YAML 1.1 mode where "True" is parsed as a boolean
+      languageService.configure(languageSettingsSetup.withYamlVersion('1.1').languageSettings);
+      schemaProvider.addSchema(SCHEMA_ID, {
+        type: 'object',
+        properties: {
+          enabled: {
+            enum: [true, false],
+          },
+        },
+      });
+      const content = 'enabled: True';
+      const result = await parseSetup(content);
+      assert.deepStrictEqual(result, []);
+      // Reset to default YAML version
+      languageService.configure(languageSettingsSetup.withYamlVersion('1.2').languageSettings);
+    });
+
+    it('Test that YAML 1.1 boolean "False" can be used in enum', async () => {
+      languageService.configure(languageSettingsSetup.withYamlVersion('1.1').languageSettings);
+      schemaProvider.addSchema(SCHEMA_ID, {
+        type: 'object',
+        properties: {
+          enabled: {
+            enum: [true, false],
+          },
+        },
+      });
+      const content = 'enabled: False';
+      const result = await parseSetup(content);
+      assert.deepStrictEqual(result, []);
+      languageService.configure(languageSettingsSetup.withYamlVersion('1.2').languageSettings);
+    });
+
+    it('Test that YAML 1.1 boolean "yes" can be used with const', async () => {
+      languageService.configure(languageSettingsSetup.withYamlVersion('1.1').languageSettings);
+      schemaProvider.addSchema(SCHEMA_ID, {
+        type: 'object',
+        properties: {
+          confirmed: {
+            const: true,
+          },
+        },
+      });
+      const content = 'confirmed: yes';
+      const result = await parseSetup(content);
+      assert.deepStrictEqual(result, []);
+      languageService.configure(languageSettingsSetup.withYamlVersion('1.2').languageSettings);
+    });
+
+    it('Test that YAML 1.1 boolean "no" can be used with const', async () => {
+      languageService.configure(languageSettingsSetup.withYamlVersion('1.1').languageSettings);
+      schemaProvider.addSchema(SCHEMA_ID, {
+        type: 'object',
+        properties: {
+          disabled: {
+            const: false,
+          },
+        },
+      });
+      const content = 'disabled: no';
+      const result = await parseSetup(content);
+      assert.deepStrictEqual(result, []);
+      languageService.configure(languageSettingsSetup.withYamlVersion('1.2').languageSettings);
+    });
   });

   describe('String tests', () => {
diff --git a/test/utils/serviceSetup.ts b/test/utils/serviceSetup.ts
index 1a20386..2bfd68e 100644
--- a/test/utils/serviceSetup.ts
+++ b/test/utils/serviceSetup.ts
@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import { LanguageSettings, SchemasSettings } from '../../src/languageservice/yamlLanguageService';
+import { YamlVersion } from '../../src/languageservice/parser/yamlParser07';

 export class ServiceSetup {
   /*
@@ -75,4 +76,9 @@ export class ServiceSetup {
     this.languageSettings.keyOrdering = order;
     return this;
   }
+
+  withYamlVersion(version: YamlVersion): ServiceSetup {
+    this.languageSettings.yamlVersion = version;
+    return this;
+  }
 }