aboutsummaryrefslogtreecommitdiff
path: root/_ext/gemtext_builder.py
blob: 9c317883f0d2d0adb875856bd3a87ec038edac7c (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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
from pathlib import Path
from typing import Set

from docutils import nodes, writers
from docutils.io import StringOutput
from sphinx.builders import Builder
from sphinx.util import logging
from sphinx.util.docutils import SphinxTranslator
from sphinx.util.osutil import ensuredir, os_path

logger = logging.getLogger(__name__)

class GemtextWriter(writers.Writer):
    def __init__(self, builder):
        super().__init__()
        self.builder = builder
    
    def translate(self):
        visitor = self.builder.create_translator(self.document, self.builder)
        self.document.walkabout(visitor)
        self.output = '\n'.join(visitor.body) + '\n'

class GemtextTranslator(SphinxTranslator):
    def __init__(self, document: nodes.document, builder):
        super().__init__(document, builder)
        self.heading_level = 0
        self.current_line = ''
        self.body = []
        self.literal = False
    
    def _finish_line(self):
        if self.current_line != '':
            self.body.append(self.current_line)
            self.current_line = ''
    
    def visit_document(self, node: nodes.document):
        self.heading_level = 1
        self.current_line = ''
        self.body = []
        self.literal = False
    
    def depart_document(self, node: nodes.document):
        self._finish_line()
    
    def visit_section(self, node: nodes.section):
        self.heading_level += 1
        if len(self.body) > 0 and self.body[-1] != '':
            self.body.append('')
    
    def depart_section(self, node: nodes.section):
        self.heading_level -= 1
    
    def visit_title(self, node: nodes.title):
        pass

    def depart_title(self, node: nodes.title):
        self.current_line = '#' * (self.heading_level - 1) + ' ' + self.current_line
        self._finish_line()
        self.body.append('')

    def visit_Text(self, node: nodes.Text):
        text = node.astext()
        if not self.literal:
            text = text.replace('\n', ' ')
        self.current_line += text
    
    def depart_Text(self, node: nodes.Text):
        pass

    def visit_paragraph(self, node: nodes.paragraph):
        pass

    def depart_paragraph(self, node: nodes.paragraph):
        self._finish_line()

    def visit_reference(self, node: nodes.reference):
        pass

    def depart_reference(self, node: nodes.reference):
        if self.current_line.startswith('=>'):
            self._finish_line()
            self.body.append('=> {} {}'.format(node.attributes['refuri'], node.astext()))
        else:
            self.current_line = '=> {} {}'.format(node.attributes['refuri'], self.current_line)

    def visit_image(self, node: nodes.image):
        if self.current_line == '':
            self.body.append('=> {} {}'.format(node.attributes['uri'], node.attributes['alt']))
        else:
            raise NotImplementedError('inline images')
    
    def depart_image(self, node: nodes.image):
        pass

    def visit_comment(self, node: nodes.comment):
        raise nodes.SkipNode

    def visit_strong(self, node: nodes.strong):
        self.current_line += '**'
    
    depart_strong = visit_strong

    def visit_emphasis(self, node: nodes.emphasis):
        self.current_line += '_'
    
    depart_emphasis = visit_emphasis

    def visit_target(self, node: nodes.target):
        raise nodes.SkipNode

    def visit_bullet_list(self, node: nodes.bullet_list):
        pass

    def depart_bullet_list(self, node: nodes.bullet_list):
        pass

    def visit_list_item(self, node: nodes.list_item):
        self.current_line += '* '

    def depart_list_item(self, node: nodes.list_item):
        pass

    def visit_compound(self, node: nodes.compound):
        pass

    def depart_compound(self, node: nodes.compound):
        pass

    def visit_inline(self, node: nodes.inline):
        pass

    def depart_inline(self, node: nodes.inline):
        pass

    def visit_title_reference(self, nodes: nodes.title_reference):
        pass

    def depart_title_reference(self, nodes: nodes.title_reference):
        pass

    def visit_literal(self, nodes: nodes.literal):
        self.current_line += '`'

    depart_literal = visit_literal

    def visit_literal_block(self, nodes: nodes.literal_block):
        self.body.append('')
        self.body.append('```')
        self.literal = True

    def depart_literal_block(self, nodes: nodes.literal_block):
        self._finish_line()
        self.body.append('```')
        self.body.append('')
        self.literal = False

class GemtextBuilder(Builder):
    name = 'gmi'
    format = 'gmi'

    out_suffix = '.gmi'
    default_translator_class = GemtextTranslator

    def get_outdated_docs(self):
        return self.env.found_docs # can't be fucked to implement this right
    
    def get_target_uri(self, docname: str, typ: str = None):
        return docname
    
    def prepare_writing(self, docnames: Set[str]):
        self.writer = GemtextWriter(self)

    def write_doc(self, docname: str, doctree: nodes.document):
        destination = StringOutput(encoding='utf-8')
        self.writer.write(doctree, destination)
        out_name = Path(self.outdir, os_path(docname) + '.gmi')
        out_name.parent.mkdir(parents=True, exist_ok=True)
        with open(out_name, 'w', encoding='utf-8') as out_file:
            out_file.write(self.writer.output)

def setup(app):
    app.add_builder(GemtextBuilder)

    return {
        'version': '0.1',
        'parallel_read_safe': True,
        'parallel_write_safe': True,
    }