atom-languageclient/build/lib/adapters/linter-push-v2-adapter.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const convert_1 = require("../convert");
const languageclient_1 = require("../languageclient");
/**
 * Public: Listen to diagnostics messages from the language server and publish them to the user by way of the Linter
 * Push (Indie) v2 API provided by the Base Linter package.
 */
class LinterPushV2Adapter {
    /**
     * Public: Create a new {LinterPushV2Adapter} that will listen for diagnostics via the supplied {LanguageClientConnection}.
     *
     * @param connection A {LanguageClientConnection} to the language server that will provide diagnostics.
     */
    constructor(connection) {
        /*
         * A map from file path calculated using the LS diagnostic uri to an array of linter messages {linter.Message[]}
         */
        this._diagnosticMap = new Map();
        /**
         * A map from file path {linter.Message["location"]["file"]} to a Map of all Message keys to Diagnostics
         * ${Map<linter.Message["key"], Diagnostic>} It has to be stored separately because a {Message} object cannot hold all
         * of the information that a {Diagnostic} provides, thus we store the original {Diagnostic} object.
         */
        this._lsDiagnosticMap = new Map();
        this._indies = new Set();
        connection.onPublishDiagnostics(this.captureDiagnostics.bind(this));
    }
    /** Dispose this adapter ensuring any resources are freed and events unhooked. */
    dispose() {
        this.detachAll();
    }
    /**
     * Public: Attach this {LinterPushV2Adapter} to a given {V2IndieDelegate} registry.
     *
     * @param indie A {V2IndieDelegate} that wants to receive messages.
     */
    attach(indie) {
        this._indies.add(indie);
        this._diagnosticMap.forEach((value, key) => indie.setMessages(key, value));
        indie.onDidDestroy(() => {
            this._indies.delete(indie);
        });
    }
    /** Public: Remove all {V2IndieDelegate} registries attached to this adapter and clear them. */
    detachAll() {
        this._indies.forEach((i) => i.clearMessages());
        this._indies.clear();
    }
    /**
     * Public: Capture the diagnostics sent from a langguage server, convert them to the Linter V2 format and forward them
     * on to any attached {V2IndieDelegate}s.
     *
     * @param params The {PublishDiagnosticsParams} received from the language server that should be captured and
     *   forwarded on to any attached {V2IndieDelegate}s.
     */
    captureDiagnostics(params) {
        const path = convert_1.default.uriToPath(params.uri);
        const codeMap = new Map();
        const messages = params.diagnostics.map((d) => {
            const linterMessage = lsDiagnosticToV2Message(path, d);
            codeMap.set(getMessageKey(linterMessage), d);
            return linterMessage;
        });
        this._diagnosticMap.set(path, messages);
        this._lsDiagnosticMap.set(path, codeMap);
        this._indies.forEach((i) => i.setMessages(path, messages));
    }
    /**
     * Public: Convert a single {Diagnostic} received from a language server into a single {V2Message} expected by the
     * Linter V2 API.
     *
     * @param path A string representing the path of the file the diagnostic belongs to.
     * @param diagnostics A {Diagnostic} object received from the language server.
     * @returns A {V2Message} equivalent to the {Diagnostic} object supplied by the language server.
     */
    diagnosticToV2Message(path, diagnostic) {
        return {
            location: {
                file: path,
                position: convert_1.default.lsRangeToAtomRange(diagnostic.range),
            },
            excerpt: diagnostic.message,
            linterName: diagnostic.source,
            severity: LinterPushV2Adapter.diagnosticSeverityToSeverity(diagnostic.severity || -1),
        };
    }
    /**
     * Public: get diagnostics for the given linter messages
     *
     * @param linterMessages An array of linter {V2Message}
     * @returns An array of LS {Diagnostic[]}
     */
    getLSDiagnosticsForMessages(linterMessages) {
        return linterMessages
            .map(this.getLSDiagnosticForMessage)
            // filter out undefined
            .filter((diagnostic) => diagnostic !== undefined);
    }
    /**
     * Public: Get the {Diagnostic} that is associated with the given Base Linter v2 {Message}.
     *
     * @param message The {Message} object to fetch the {Diagnostic} for.
     * @returns The associated {Diagnostic}.
     */
    getLSDiagnosticForMessage(message) {
        var _a;
        return (_a = this._lsDiagnosticMap.get(message.location.file)) === null || _a === void 0 ? void 0 : _a.get(getMessageKey(message));
    }
    /**
     * Public: Convert a diagnostic severity number obtained from the language server into the textual equivalent for a
     * Linter {V2Message}.
     *
     * @param severity A number representing the severity of the diagnostic.
     * @returns A string of 'error', 'warning' or 'info' depending on the severity.
     */
    static diagnosticSeverityToSeverity(severity) {
        switch (severity) {
            case languageclient_1.DiagnosticSeverity.Error:
                return "error";
            case languageclient_1.DiagnosticSeverity.Warning:
                return "warning";
            case languageclient_1.DiagnosticSeverity.Information:
            case languageclient_1.DiagnosticSeverity.Hint:
            default:
                return "info";
        }
    }
}
exports.default = LinterPushV2Adapter;
/**
 * Public: Convert a single {Diagnostic} received from a language server into a single {Message} expected by the Linter V2 API.
 *
 * @param path A string representing the path of the file the diagnostic belongs to.
 * @param diagnostics A {Diagnostic} object received from the language server.
 * @returns A {Message} equivalent to the {Diagnostic} object supplied by the language server.
 */
function lsDiagnosticToV2Message(path, diagnostic) {
    var _a, _b, _c;
    return {
        location: {
            file: path,
            position: convert_1.default.lsRangeToAtomRange(diagnostic.range),
        },
        reference: relatedInformationToReference(diagnostic.relatedInformation),
        url: (_a = diagnostic.codeDescription) === null || _a === void 0 ? void 0 : _a.href,
        icon: iconForLSSeverity((_b = diagnostic.severity) !== null && _b !== void 0 ? _b : languageclient_1.DiagnosticSeverity.Error),
        excerpt: diagnostic.message,
        linterName: diagnostic.source,
        severity: lsSeverityToV2MessageSeverity((_c = diagnostic.severity) !== null && _c !== void 0 ? _c : languageclient_1.DiagnosticSeverity.Error),
        // BLOCKED: on steelbrain/linter#1722
        solutions: undefined,
    };
}
/**
 * Convert a severity level of an LSP {Diagnostic} to that of a Base Linter v2 {Message}. Note: this conversion is lossy
 * due to the v2 Message not being able to represent hints.
 *
 * @param severity A severity level of of an LSP {Diagnostic} to be converted.
 * @returns A severity level a Base Linter v2 {Message}.
 */
function lsSeverityToV2MessageSeverity(severity) {
    switch (severity) {
        case languageclient_1.DiagnosticSeverity.Error:
            return "error";
        case languageclient_1.DiagnosticSeverity.Warning:
            return "warning";
        case languageclient_1.DiagnosticSeverity.Information:
        case languageclient_1.DiagnosticSeverity.Hint:
            return "info";
        default:
            throw Error(`Unexpected diagnostic severity '${severity}'`);
    }
}
/**
 * Convert a diagnostic severity number obtained from the language server into an Octicon icon.
 *
 * @param severity A number representing the severity of the diagnostic.
 * @returns An Octicon name.
 */
function iconForLSSeverity(severity) {
    switch (severity) {
        case languageclient_1.DiagnosticSeverity.Error:
            return "stop";
        case languageclient_1.DiagnosticSeverity.Warning:
            return "warning";
        case languageclient_1.DiagnosticSeverity.Information:
            return "info";
        case languageclient_1.DiagnosticSeverity.Hint:
            return "light-bulb";
        default:
            return undefined;
    }
}
/**
 * Convert the related information from a diagnostic into a reference point for a Linter {V2Message}.
 *
 * @param relatedInfo Several related information objects (only the first is used).
 * @returns A value that is suitable for using as {V2Message}.reference.
 */
function relatedInformationToReference(relatedInfo) {
    if (relatedInfo === undefined || relatedInfo.length === 0) {
        return undefined;
    }
    const location = relatedInfo[0].location;
    return {
        file: convert_1.default.uriToPath(location.uri),
        position: convert_1.default.lsRangeToAtomRange(location.range).start,
    };
}
/**
 * Get a unique key for a Linter v2 Message
 *
 * @param message A {Message} object
 * @returns ${string} a unique key
 */
function getMessageKey(message) {
    if (typeof message.key !== "string") {
        updateMessageKey(message);
    }
    return message.key; // updateMessageKey adds message.key string
}
/**
 * Construct an unique key for a Linter v2 Message and store it in `Message.key`
 *
 * @param message A {Message} object to serialize.
 * @returns ${string} a unique key
 */
function updateMessageKey(message) {
    // From https://github.com/steelbrain/linter/blob/fadd462914ef0a8ed5b73a489f662a9393bdbe9f/lib/helpers.ts#L50-L64
    const { reference, location } = message;
    const nameStr = `$LINTER:${message.linterName}`;
    const locationStr = `$LOCATION:${location.file}$${location.position.start.row}$${location.position.start.column}$${location.position.end.row}$${location.position.end.column}`;
    const referenceStr = reference
        ? `$REFERENCE:${reference.file}$${reference.position ? `${reference.position.row}$${reference.position.column}` : ""}`
        : "$REFERENCE:null";
    const excerptStr = `$EXCERPT:${message.excerpt}`;
    const severityStr = `$SEVERITY:${message.severity}`;
    const iconStr = message.icon ? `$ICON:${message.icon}` : "$ICON:null";
    const urlStr = message.url ? `$URL:${message.url}` : "$URL:null";
    const descriptionStr = typeof message.description === "string" ? `$DESCRIPTION:${message.description}` : "$DESCRIPTION:null";
    message.key = `${nameStr}${locationStr}${referenceStr}${excerptStr}${severityStr}${iconStr}${urlStr}${descriptionStr}`;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"linter-push-v2-adapter.js","sourceRoot":"","sources":["../../../lib/adapters/linter-push-v2-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import * as linter from \"atom/linter\"\nimport Convert from \"../convert\"\nimport {\n  Diagnostic,\n  DiagnosticSeverity,\n  DiagnosticRelatedInformation,\n  LanguageClientConnection,\n  PublishDiagnosticsParams,\n} from \"../languageclient\"\n\n/**\n * Public: Listen to diagnostics messages from the language server and publish them to the user by way of the Linter\n * Push (Indie) v2 API provided by the Base Linter package.\n */\nexport default class LinterPushV2Adapter {\n  /*\n   * A map from file path calculated using the LS diagnostic uri to an array of linter messages {linter.Message[]}\n   */\n  protected _diagnosticMap: Map<string, linter.Message[]> = new Map()\n  /**\n   * A map from file path {linter.Message[\"location\"][\"file\"]} to a Map of all Message keys to Diagnostics\n   * ${Map<linter.Message[\"key\"], Diagnostic>} It has to be stored separately because a {Message} object cannot hold all\n   * of the information that a {Diagnostic} provides, thus we store the original {Diagnostic} object.\n   */\n  protected _lsDiagnosticMap: Map<linter.Message[\"location\"][\"file\"], Map<linter.Message[\"key\"], Diagnostic>> =\n    new Map()\n  protected _indies: Set<linter.IndieDelegate> = new Set()\n\n  /**\n   * Public: Create a new {LinterPushV2Adapter} that will listen for diagnostics via the supplied {LanguageClientConnection}.\n   *\n   * @param connection A {LanguageClientConnection} to the language server that will provide diagnostics.\n   */\n  constructor(connection: LanguageClientConnection) {\n    connection.onPublishDiagnostics(this.captureDiagnostics.bind(this))\n  }\n\n  /** Dispose this adapter ensuring any resources are freed and events unhooked. */\n  public dispose(): void {\n    this.detachAll()\n  }\n\n  /**\n   * Public: Attach this {LinterPushV2Adapter} to a given {V2IndieDelegate} registry.\n   *\n   * @param indie A {V2IndieDelegate} that wants to receive messages.\n   */\n  public attach(indie: linter.IndieDelegate): void {\n    this._indies.add(indie)\n    this._diagnosticMap.forEach((value, key) => indie.setMessages(key, value))\n    indie.onDidDestroy(() => {\n      this._indies.delete(indie)\n    })\n  }\n\n  /** Public: Remove all {V2IndieDelegate} registries attached to this adapter and clear them. */\n  public detachAll(): void {\n    this._indies.forEach((i) => i.clearMessages())\n    this._indies.clear()\n  }\n\n  /**\n   * Public: Capture the diagnostics sent from a langguage server, convert them to the Linter V2 format and forward them\n   * on to any attached {V2IndieDelegate}s.\n   *\n   * @param params The {PublishDiagnosticsParams} received from the language server that should be captured and\n   *   forwarded on to any attached {V2IndieDelegate}s.\n   */\n  public captureDiagnostics(params: PublishDiagnosticsParams): void {\n    const path = Convert.uriToPath(params.uri)\n    const codeMap = new Map<string, Diagnostic>()\n    const messages = params.diagnostics.map((d) => {\n      const linterMessage = lsDiagnosticToV2Message(path, d)\n      codeMap.set(getMessageKey(linterMessage), d)\n      return linterMessage\n    })\n    this._diagnosticMap.set(path, messages)\n    this._lsDiagnosticMap.set(path, codeMap)\n    this._indies.forEach((i) => i.setMessages(path, messages))\n  }\n\n  /**\n   * Public: Convert a single {Diagnostic} received from a language server into a single {V2Message} expected by the\n   * Linter V2 API.\n   *\n   * @param path A string representing the path of the file the diagnostic belongs to.\n   * @param diagnostics A {Diagnostic} object received from the language server.\n   * @returns A {V2Message} equivalent to the {Diagnostic} object supplied by the language server.\n   */\n  public diagnosticToV2Message(path: string, diagnostic: Diagnostic): linter.Message {\n    return {\n      location: {\n        file: path,\n        position: Convert.lsRangeToAtomRange(diagnostic.range),\n      },\n      excerpt: diagnostic.message,\n      linterName: diagnostic.source,\n      severity: LinterPushV2Adapter.diagnosticSeverityToSeverity(diagnostic.severity || -1),\n    }\n  }\n\n  /**\n   * Public: get diagnostics for the given linter messages\n   *\n   * @param linterMessages An array of linter {V2Message}\n   * @returns An array of LS {Diagnostic[]}\n   */\n  public getLSDiagnosticsForMessages(linterMessages: linter.Message[]): Diagnostic[] {\n    return (\n      linterMessages\n        .map(this.getLSDiagnosticForMessage)\n        // filter out undefined\n        .filter((diagnostic) => diagnostic !== undefined) as Diagnostic[]\n    )\n  }\n\n  /**\n   * Public: Get the {Diagnostic} that is associated with the given Base Linter v2 {Message}.\n   *\n   * @param message The {Message} object to fetch the {Diagnostic} for.\n   * @returns The associated {Diagnostic}.\n   */\n  public getLSDiagnosticForMessage(message: linter.Message): Diagnostic | undefined {\n    return this._lsDiagnosticMap.get(message.location.file)?.get(getMessageKey(message))\n  }\n\n  /**\n   * Public: Convert a diagnostic severity number obtained from the language server into the textual equivalent for a\n   * Linter {V2Message}.\n   *\n   * @param severity A number representing the severity of the diagnostic.\n   * @returns A string of 'error', 'warning' or 'info' depending on the severity.\n   */\n  public static diagnosticSeverityToSeverity(severity: number): \"error\" | \"warning\" | \"info\" {\n    switch (severity) {\n      case DiagnosticSeverity.Error:\n        return \"error\"\n      case DiagnosticSeverity.Warning:\n        return \"warning\"\n      case DiagnosticSeverity.Information:\n      case DiagnosticSeverity.Hint:\n      default:\n        return \"info\"\n    }\n  }\n}\n\n/**\n * Public: Convert a single {Diagnostic} received from a language server into a single {Message} expected by the Linter V2 API.\n *\n * @param path A string representing the path of the file the diagnostic belongs to.\n * @param diagnostics A {Diagnostic} object received from the language server.\n * @returns A {Message} equivalent to the {Diagnostic} object supplied by the language server.\n */\nfunction lsDiagnosticToV2Message(path: string, diagnostic: Diagnostic): linter.Message {\n  return {\n    location: {\n      file: path,\n      position: Convert.lsRangeToAtomRange(diagnostic.range),\n    },\n    reference: relatedInformationToReference(diagnostic.relatedInformation),\n    url: diagnostic.codeDescription?.href,\n    icon: iconForLSSeverity(diagnostic.severity ?? DiagnosticSeverity.Error),\n    excerpt: diagnostic.message,\n    linterName: diagnostic.source,\n    severity: lsSeverityToV2MessageSeverity(diagnostic.severity ?? DiagnosticSeverity.Error),\n    // BLOCKED: on steelbrain/linter#1722\n    solutions: undefined,\n  }\n}\n\n/**\n * Convert a severity level of an LSP {Diagnostic} to that of a Base Linter v2 {Message}. Note: this conversion is lossy\n * due to the v2 Message not being able to represent hints.\n *\n * @param severity A severity level of of an LSP {Diagnostic} to be converted.\n * @returns A severity level a Base Linter v2 {Message}.\n */\nfunction lsSeverityToV2MessageSeverity(severity: DiagnosticSeverity): linter.Message[\"severity\"] {\n  switch (severity) {\n    case DiagnosticSeverity.Error:\n      return \"error\"\n    case DiagnosticSeverity.Warning:\n      return \"warning\"\n    case DiagnosticSeverity.Information:\n    case DiagnosticSeverity.Hint:\n      return \"info\"\n    default:\n      throw Error(`Unexpected diagnostic severity '${severity}'`)\n  }\n}\n\n/**\n * Convert a diagnostic severity number obtained from the language server into an Octicon icon.\n *\n * @param severity A number representing the severity of the diagnostic.\n * @returns An Octicon name.\n */\nfunction iconForLSSeverity(severity: DiagnosticSeverity): string | undefined {\n  switch (severity) {\n    case DiagnosticSeverity.Error:\n      return \"stop\"\n    case DiagnosticSeverity.Warning:\n      return \"warning\"\n    case DiagnosticSeverity.Information:\n      return \"info\"\n    case DiagnosticSeverity.Hint:\n      return \"light-bulb\"\n    default:\n      return undefined\n  }\n}\n\n/**\n * Convert the related information from a diagnostic into a reference point for a Linter {V2Message}.\n *\n * @param relatedInfo Several related information objects (only the first is used).\n * @returns A value that is suitable for using as {V2Message}.reference.\n */\nfunction relatedInformationToReference(\n  relatedInfo: DiagnosticRelatedInformation[] | undefined\n): linter.Message[\"reference\"] {\n  if (relatedInfo === undefined || relatedInfo.length === 0) {\n    return undefined\n  }\n\n  const location = relatedInfo[0].location\n  return {\n    file: Convert.uriToPath(location.uri),\n    position: Convert.lsRangeToAtomRange(location.range).start,\n  }\n}\n\n/**\n * Get a unique key for a Linter v2 Message\n *\n * @param message A {Message} object\n * @returns ${string} a unique key\n */\nfunction getMessageKey(message: linter.Message): string {\n  if (typeof message.key !== \"string\") {\n    updateMessageKey(message)\n  }\n  return message.key as string // updateMessageKey adds message.key string\n}\n\n/**\n * Construct an unique key for a Linter v2 Message and store it in `Message.key`\n *\n * @param message A {Message} object to serialize.\n * @returns ${string} a unique key\n */\nfunction updateMessageKey(message: linter.Message): void {\n  // From https://github.com/steelbrain/linter/blob/fadd462914ef0a8ed5b73a489f662a9393bdbe9f/lib/helpers.ts#L50-L64\n  const { reference, location } = message\n  const nameStr = `$LINTER:${message.linterName}`\n  const locationStr = `$LOCATION:${location.file}$${location.position.start.row}$${location.position.start.column}$${location.position.end.row}$${location.position.end.column}`\n  const referenceStr = reference\n    ? `$REFERENCE:${reference.file}$${\n        reference.position ? `${reference.position.row}$${reference.position.column}` : \"\"\n      }`\n    : \"$REFERENCE:null\"\n  const excerptStr = `$EXCERPT:${message.excerpt}`\n  const severityStr = `$SEVERITY:${message.severity}`\n  const iconStr = message.icon ? `$ICON:${message.icon}` : \"$ICON:null\"\n  const urlStr = message.url ? `$URL:${message.url}` : \"$URL:null\"\n  const descriptionStr =\n    typeof message.description === \"string\" ? `$DESCRIPTION:${message.description}` : \"$DESCRIPTION:null\"\n  message.key = `${nameStr}${locationStr}${referenceStr}${excerptStr}${severityStr}${iconStr}${urlStr}${descriptionStr}`\n}\n"]}