implement auto-diasbling schema detection for Docker DX, GitHub Actions, Azure Piplines if corresponding extension is enabled

Signed-off-by: Morgan Chang <shin19991207@gmail.com>

Author: shin19991207

README.md

@@ -50,6 +50,7 @@ The following settings are supported:
 * `yaml.hoverSchemaSource`: Enable/disable showing the schema source in hover tooltips
 * `yaml.completion`: Enable/disable autocompletion
 * `yaml.schemas`: Helps you associate schemas with files in a glob pattern
+* `yaml.disableSchemaDetection`: Disable schema detection for YAML files matching the configured glob pattern or list of glob patterns. Common patterns are automatically added when another enabled extension provides more specific YAML support, such as [Docker DX](https://marketplace.visualstudio.com/items?itemName=docker.docker), [GitHub Actions](https://marketplace.visualstudio.com/items?itemName=github.vscode-github-actions), or [Azure Pipelines](https://marketplace.visualstudio.com/items?itemName=ms-azure-devops.azure-pipelines). Modelines still apply.
 * `yaml.schemaStore.enable`: When set to true, the YAML language server will pull in all available schemas from [JSON Schema Store](http://schemastore.org/)
 * `yaml.schemaStore.url`: URL of a schema store catalog to use when downloading schemas.
 * `yaml.customTags`: Array of custom tags that the parser will validate against. It has three ways to be used. A tag without a type, such as "!Ref", is treated as a scalar tag. A tag with a node type, such as "!Ref sequence", specifies the YAML node type that the tag is written on. A tag with a node type and return type, such as "!FindInMap sequence:string", also specifies the schema type that the tagged value evaluates to. Supported node types are scalar, sequence, and mapping. Supported return types are string, number, integer, boolean, null, array, and object. The return type aliases scalar, sequence, and mapping are accepted as string, array, and object.

package.json

@@ -153,7 +153,7 @@
             }
           ],
           "default": [],
-          "markdownDescription": "Disable schema detection for YAML files matching the configured glob pattern or glob patterns. The expected value is a glob pattern or list of glob patterns. Modelines still apply."
+          "markdownDescription": "Disable schema detection for YAML files matching the configured glob pattern or list of glob patterns. Common patterns are automatically added when another enabled extension provides more specific YAML support, such as [Docker DX](https://marketplace.visualstudio.com/items?itemName=docker.docker), [GitHub Actions](https://marketplace.visualstudio.com/items?itemName=github.vscode-github-actions), or [Azure Pipelines](https://marketplace.visualstudio.com/items?itemName=ms-azure-devops.azure-pipelines). Modelines still apply."
         },
         "yaml.kubernetesCRDStore.enable": {
           "type": "boolean",

src/autoDisableSchemaDetection.ts

@@ -0,0 +1,148 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) IBM Corp. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { ConfigurationTarget, extensions, workspace } from 'vscode';
+import type { ExtensionContext, WorkspaceConfiguration } from 'vscode';
+
+interface AutoDisableSchemaDetectionEntry {
+  extensionId: string;
+  configurationKey?: string;
+  fileMatches: string[];
+}
+
+const autoDisableSchemaDetectionEntries: AutoDisableSchemaDetectionEntry[] = [
+  {
+    extensionId: 'docker.docker',
+    configurationKey: 'docker.extension.enableComposeLanguageServer',
+    fileMatches: [
+      '**/docker-compose.yml',
+      '**/docker-compose.yaml',
+      '**/docker-compose.*.yml',
+      '**/docker-compose.*.yaml',
+      '**/compose.yml',
+      '**/compose.yaml',
+      '**/compose.*.yml',
+      '**/compose.*.yaml',
+    ],
+  },
+  {
+    extensionId: 'github.vscode-github-actions',
+    fileMatches: [
+      '**/.github/workflows/*.yml',
+      '**/.github/workflows/*.yaml',
+      '**/.gitea/workflows/*.yml',
+      '**/.gitea/workflows/*.yaml',
+      '**/.forgejo/workflows/*.yml',
+      '**/.forgejo/workflows/*.yaml',
+    ],
+  },
+  {
+    extensionId: 'ms-azure-devops.azure-pipelines',
+    fileMatches: ['azure-pipelines.yml', 'azure-pipelines.yaml'],
+  },
+];
+
+export async function initializeAutoDisableSchemaDetection(context: ExtensionContext): Promise<void> {
+  await updateAutoDisableSchemaDetectionSetting();
+  context.subscriptions.push(
+    extensions.onDidChange(() => {
+      updateAutoDisableSchemaDetectionSetting();
+    }),
+    workspace.onDidChangeConfiguration((event) => {
+      if (
+        event.affectsConfiguration('docker.extension.enableComposeLanguageServer') ||
+        event.affectsConfiguration('yaml.disableSchemaDetection')
+      ) {
+        updateAutoDisableSchemaDetectionSetting();
+      }
+    })
+  );
+}
+
+async function updateAutoDisableSchemaDetectionSetting(): Promise<void> {
+  const configuration = workspace.getConfiguration('yaml');
+  const currentDisableSchemaDetection = getDisableSchemaDetectionSetting(configuration);
+  const update = computeAutoDisableSchemaDetectionUpdate(
+    currentDisableSchemaDetection.value,
+    getAutoDisabledSchemaDetectionExtensions()
+  );
+  if (
+    !(
+      currentDisableSchemaDetection.value.length === update.length &&
+      currentDisableSchemaDetection.value.every((value, index) => value === update[index])
+    )
+  ) {
+    await configuration.update('disableSchemaDetection', update, currentDisableSchemaDetection.target);
+  }
+}
+
+function getDisableSchemaDetectionSetting(
+  configuration: WorkspaceConfiguration
+): {
+  value: string[];
+  target: ConfigurationTarget;
+} {
+  const inspected = configuration.inspect<string | string[]>('disableSchemaDetection');
+  if (inspected?.workspaceValue !== undefined) {
+    return {
+      value: toStringArray(inspected.workspaceValue),
+      target: ConfigurationTarget.Workspace,
+    };
+  }
+  return {
+    value: toStringArray(inspected?.globalValue ?? []),
+    target: ConfigurationTarget.Global,
+  };
+}
+
+export function getAutoDisabledSchemaDetectionExtensions(): string[] {
+  const configuration = workspace.getConfiguration();
+  const enabledExtensions: string[] = [];
+  for (const entry of autoDisableSchemaDetectionEntries) {
+    if (
+      !extensions.getExtension(entry.extensionId) ||
+      (entry.configurationKey && configuration.get<boolean>(entry.configurationKey, true) === false)
+    ) {
+      continue;
+    }
+    enabledExtensions.push(entry.extensionId);
+  }
+  return enabledExtensions;
+}
+
+export function computeAutoDisableSchemaDetectionUpdate(
+  currentDisableSchemaDetection: string[],
+  enabledExtensions: string[]
+): string[] {
+  const desiredFileMatches = getFileMatchesForExtensions(enabledExtensions);
+  const disabledExtensions = autoDisableSchemaDetectionEntries
+    .map((entry) => entry.extensionId)
+    .filter((extensionId) => !enabledExtensions.includes(extensionId));
+  const disabledFileMatches = getFileMatchesForExtensions(disabledExtensions);
+  const withoutInactiveManagedFileMatches = currentDisableSchemaDetection.filter(
+    (fileMatch) => !disabledFileMatches.includes(fileMatch) || desiredFileMatches.includes(fileMatch)
+  );
+  const additions = desiredFileMatches.filter((fileMatch) => !withoutInactiveManagedFileMatches.includes(fileMatch));
+  return withoutInactiveManagedFileMatches.concat(additions);
+}
+
+function getFileMatchesForExtensions(extensionIds: string[]): string[] {
+  const fileMatches: string[] = [];
+  for (const entry of autoDisableSchemaDetectionEntries) {
+    if (extensionIds.includes(entry.extensionId)) {
+      fileMatches.push(...entry.fileMatches);
+    }
+  }
+  return fileMatches;
+}
+
+function toStringArray(value: unknown): string[] {
+  if (typeof value === 'string') {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.filter((item): item is string => typeof item === 'string');
+  }
+  return [];
+}

src/extension.ts

@@ -21,6 +21,7 @@ import { getConflictingExtensions, showUninstallConflictsNotification } from './
 import { TelemetryErrorHandler, TelemetryOutputChannel } from './telemetry';
 import { createJSONSchemaStatusBarItem } from './schema-status-bar-item';
 import { initializeRecommendation } from './recommendation';
+import { initializeAutoDisableSchemaDetection } from './autoDisableSchemaDetection';
 
 export interface ISchemaAssociations {
   [pattern: string]: string[];
@@ -107,11 +108,11 @@ export interface TelemetryService {
   sendStartupEvent(): Promise<void>;
 }
 
-export function startClient(
+export async function startClient(
   context: ExtensionContext,
   newLanguageClient: LanguageClientConstructor,
   runtime: RuntimeEnvironment
-): SchemaExtensionAPI {
+): Promise<SchemaExtensionAPI> {
   const telemetryErrorHandler = new TelemetryErrorHandler(runtime.telemetry, lsName, 4);
   const outputChannel = window.createOutputChannel(lsName);
   const l10nPath = context.asAbsolutePath('./dist/l10n');
@@ -144,6 +145,7 @@ export function startClient(
 
   // Create the language client and start it
   client = newLanguageClient('yaml', lsName, clientOptions);
+  await initializeAutoDisableSchemaDetection(context);
 
   const disposable = client.start();