aboutsummaryrefslogtreecommitdiff
path: root/src/Formats/MarkdownFormatService.kt
blob: a2e3ce551bf4fdc0c8e45084996b9b03da5329cd (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
package org.jetbrains.dokka


public open class MarkdownFormatService(locationService: LocationService,
                                        signatureGenerator: LanguageService)
: StructuredFormatService(locationService, signatureGenerator) {

    override val extension: String = "md"

    override public fun formatBreadcrumbs(items: Iterable<FormatLink>): String {
        return items.map { formatLink(it) }.joinToString(" / ")
    }

    override public fun formatText(text: String): String {
        return text.htmlEscape()
    }

    override fun formatSymbol(text: String): String {
        return text.htmlEscape()
    }

    override fun formatKeyword(text: String): String {
        return text.htmlEscape()
    }
    override fun formatIdentifier(text: String): String {
        return text.htmlEscape()
    }

    override public fun formatCode(code: String): String {
        return "`$code`"
    }

    override public fun formatList(text: String): String {
        return text
    }

    override fun formatListItem(text: String): String {
        return "* $text"
    }

    override public fun formatStrong(text: String): String {
        return "**$text**"
    }

    override fun formatEmphasis(text: String): String {
        return "*$text*"
    }

    override fun formatStrikethrough(text: String): String {
        return "~~$text~~"
    }

    override public fun formatLink(text: String, location: Location): String {
        return "[$text](${location.path})"
    }

    override fun formatLink(text: String, href: String): String {
        return "[$text]($href)"
    }

    override public fun appendLine(to: StringBuilder) {
        to.appendln()
    }

    override public fun appendLine(to: StringBuilder, text: String) {
        to.appendln(text)
    }

    override public fun appendParagraph(to: StringBuilder, text: String) {
        to.appendln()
        to.appendln(text)
        to.appendln()
    }

    override public fun appendHeader(to: StringBuilder, text: String, level: Int) {
        appendLine(to)
        appendLine(to, "${"#".repeat(level)} $text")
        appendLine(to)
    }

    override public fun appendBlockCode(to: StringBuilder, lines: Iterable<String>) {
        appendLine(to)
        appendLine(to, "```")
        for (line in lines)
            to.appendln(line)
        appendLine(to, "```")
        appendLine(to)
    }

    override public fun appendBlockCode(to: StringBuilder, line: String) {
        appendLine(to)
        to.appendln("```")
        to.appendln(line)
        to.appendln("```")
        appendLine(to)
    }

    override fun appendTable(to: StringBuilder, body: () -> Unit) {
        to.appendln()
        body()
        to.appendln()
    }

    override fun appendTableHeader(to: StringBuilder, body: () -> Unit) {
        body()
    }

    override fun appendTableBody(to: StringBuilder, body: () -> Unit) {
        body()
    }

    override fun appendTableRow(to: StringBuilder, body: () -> Unit) {
        to.append("|")
        body()
        to.appendln()
    }

    override fun appendTableCell(to: StringBuilder, body: () -> Unit) {
        to.append(" ")
        body()
        to.append(" |")
    }

    var outlineLevel = 0
    override fun appendOutlineHeader(to: StringBuilder, node: DocumentationNode) {
        val indent = "    ".repeat(outlineLevel)
        appendLine(to, "$indent- title: ${languageService.renderName(node)}")
        appendLine(to, "$indent  url: ${locationService.location(node).path}")
    }

    override fun appendOutlineChildren(to: StringBuilder, nodes: Iterable<DocumentationNode>) {
        val indent = "    ".repeat(outlineLevel)
        appendLine(to, "$indent  content:")
        outlineLevel++
        for (node in nodes) {
            appendOutlineHeader(to, node)
            if (node.members.any()) {
                appendOutlineChildren(to, node.members)
            }
            appendLine(to)
        }
        outlineLevel--
    }
}