fish-lsp/out/utils/symbol-documentation-builder.js

LSP implementation for fish/fish-shell

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DocumentSymbolDetail = exports.DocumentationStringBuilder = void 0;
const os_1 = __importDefault(require("os"));
const node_types_1 = require("./node-types");
const translation_1 = require("./translation");
const markdown_builder_1 = require("./markdown-builder");
const snippets_1 = require("./snippets");
class DocumentationStringBuilder {
    name;
    uri;
    kind;
    inner;
    constructor(name = name, uri = uri, kind = kind, inner = inner) {
        this.name = name;
        this.uri = uri;
        this.kind = kind;
        this.inner = inner;
    }
    get outer() {
        if ((0, node_types_1.isFunctionDefinitionName)(this.inner) || (0, node_types_1.isVariableDefinitionName)(this.inner)) {
            return this.inner.parent;
        }
        return this.inner.previousSibling || null;
    }
    get precedingComments() {
        if (this.outer && (0, node_types_1.isProgram)(this.outer)) {
            return getPrecedingCommentString(this.inner);
        }
        if (hasPrecedingFunctionDefinition(this.inner) &&
            (0, node_types_1.isVariableDefinition)(this.inner)) {
            return this.outer?.firstNamedChild?.text + ' ' + this.inner.text;
        }
        return getPrecedingCommentString(this.outer || this.inner);
    }
    get text() {
        const text = this.precedingComments;
        const lines = text.split('\n');
        if (lines.length > 1 && this.outer) {
            const lastLine = this.outer.lastChild?.startPosition.column || 0;
            return lines
                .map((line) => line.replace(' '.repeat(lastLine), ''))
                .join('\n')
                .trimEnd();
        }
        return text;
    }
    get shortenedUri() {
        const uriPath = (0, translation_1.uriToPath)(this.uri);
        return uriPath.replace(os_1.default.homedir(), '~');
    }
    toString() {
        const symbolString = (0, translation_1.symbolKindToString)(this.kind);
        const prebuiltType = symbolString === 'function' ? 'command' : 'variable';
        const prebuiltMatch = snippets_1.PrebuiltDocumentationMap.getByType(prebuiltType)
            .find(({ name }) => name === this.name);
        const info = prebuiltMatch?.description ?
            [
                `defined in file: ${this.shortenedUri}`,
                markdown_builder_1.md.separator(),
                prebuiltMatch.description,
            ].join('\n')
            : `defined in file: ${this.shortenedUri}`;
        return new markdown_builder_1.MarkdownBuilder()
            .fromMarkdown([
            `(${markdown_builder_1.md.italic(symbolString)})`, markdown_builder_1.md.bold(this.name)
        ], info, markdown_builder_1.md.separator(), markdown_builder_1.md.codeBlock('fish', this.text))
            .toString();
    }
}
exports.DocumentationStringBuilder = DocumentationStringBuilder;
var DocumentSymbolDetail;
(function (DocumentSymbolDetail) {
    function create(name, uri, kind, inner, _outer = inner.parent || inner.previousSibling || null) {
        return new DocumentationStringBuilder(name, uri, kind, inner).toString();
    }
    DocumentSymbolDetail.create = create;
})(DocumentSymbolDetail || (exports.DocumentSymbolDetail = DocumentSymbolDetail = {}));
function getPrecedingCommentString(node) {
    const comments = [node.text];
    let current = node.previousNamedSibling;
    while (current && current.type === 'comment') {
        comments.unshift(current.text);
        current = current.previousSibling;
    }
    return comments.join('\n');
}
function hasPrecedingFunctionDefinition(node) {
    let current = node.previousSibling;
    while (current) {
        if ((0, node_types_1.isFunctionDefinitionName)(current)) {
            return true;
        }
        current = current.previousSibling;
    }
    return false;
}