Python script, ASCII text executable
1
import re
2
import bs4 as beautifulsoup
3
import sys
4
def only_chars(string, chars):
7
chars = set(chars)
8
all_chars = set(string)
9
return all_chars.issubset(chars)
10
inlineRegex = r"""
13
(?P<em>[*_]{1,7}) (?P<textEm>(?:\\[*]|[^*])*) (?P=em) # emphasis
14
|
15
[`] (?P<textCode>(?:\\[`]|[^`])*) [`] # inline code
16
|
17
(?P<imageFlag>!?) \[ (?P<urlText>[^\[\]]*) \] \((?P<urlDestination>[^\(\)]*)\) # hyperlink or media
18
|
19
(?P<strike>~{2}) (?P<textStrike>(?:\\[~]|[^~])*) (~{2}) # strikethrough
20
|
21
(?P<diff>\-\-|\+\+) (?P<textDiff>(?:\\[-+]|[^-+])*) (?P=diff) # diffs
22
"""
23
def leading(string, character):
26
return len(string) - len(string.lstrip(character))
27
def trailing(string, character):
30
return len(string) - len(string.rstrip(character))
31
class Element:
34
def __init__(self):
35
self.classes = []
36
self.content = None
37
pass
38
def __repr__(self):
40
return "Void block"
41
@property
43
def tag_name(self):
44
return "m-void"
45
class Container(Element):
48
def __init__(self, content):
49
super().__init__()
50
self.content = parse_line(content)
51
def __repr__(self):
53
return "Generic container element: " + repr(self.content)
54
class Rule(Element):
57
def __init__(self):
58
super().__init__()
59
def __repr__(self):
61
return "Rule"
62
@property
64
def tag_name(self):
65
return "hr"
66
class HardBreak(Element):
69
def __init__(self):
70
super().__init__()
71
def __repr__(self):
73
return "Hard break"
74
@property
76
def tag_name(self):
77
return "br"
78
class Heading(Container):
81
def __init__(self, content, level):
82
super().__init__(content)
83
self.level = level
84
pass
85
def __repr__(self):
87
return f"Heading level {self.level}:\n\t" + repr(self.content)
88
@property
90
def tag_name(self):
91
return "h" + str(self.level)
92
class Paragraph(Container):
95
def __init__(self, content):
96
super().__init__("")
97
self.content = parse_line(content)
98
def __repr__(self):
100
return "Paragraph:\n\t" + repr(self.content)
101
@property
103
def tag_name(self):
104
return "p"
105
class CodeBlock(Element):
108
def __init__(self, content, language="text"):
109
super().__init__()
110
self.content = content
111
self.language = language
112
def __repr__(self):
114
return f"Code block ({self.language}):\n\t" + repr(self.content)
115
@property
117
def tag_name(self):
118
return "pre"
119
class UnorderedList(Element):
122
def __init__(self, content):
123
super().__init__()
124
self.content = content
125
def __repr__(self):
127
return "Unordered list:\n\t" + repr(self.content)
128
@property
130
def tag_name(self):
131
return "ul"
132
class OrderedList(Element):
135
def __init__(self, content):
136
super().__init__()
137
self.content = content
138
def __repr__(self):
140
return "Ordered list:\n\t" + repr(self.content)
141
@property
143
def tag_name(self):
144
return "ol"
145
class ListItem(Element):
148
def __init__(self, content):
149
super().__init__()
150
self.content = tokenise(content)
151
def __repr__(self):
153
return "List item:\n\t" + repr(self.content)
154
@property
156
def tag_name(self):
157
return "li"
158
class Blockquote(Paragraph):
161
def __init__(self, content):
162
super().__init__("")
163
self.content = tokenise(content)
164
def __repr__(self):
166
return "Blockquote:\n\t" + repr(self.content)
167
@property
169
def tag_name(self):
170
return "blockquote"
171
class Emphasis(Container):
174
def __init__(self, content, value):
175
super().__init__(content)
176
self.value = value
177
if value >= 4:
178
self.classes.append("emphasis-3")
179
if value % 4 >= 2:
180
self.classes.append("emphasis-2")
181
if value % 2:
182
self.classes.append("emphasis-1")
183
def __repr__(self):
185
return f"Emphasis ({self.value}): " + repr(self.content)
186
@property
188
def tag_name(self):
189
return "em" if self.value == 1 else "strong"
190
class Code(Element):
193
def __init__(self, content):
194
super().__init__()
195
self.content = [content]
196
def __repr__(self):
198
return f"Inline code: {self.content}"
199
@property
201
def tag_name(self):
202
return "code"
203
class Strikethrough(Container):
206
def __init__(self, content):
207
super().__init__(content)
208
def __repr__(self):
210
return f"Strikethrough: {repr(self.content)}"
211
@property
213
def tag_name(self):
214
return "s"
215
class Diff(Container):
218
def __init__(self, content, value):
219
super().__init__(content)
220
self.value = value
221
def __repr__(self):
223
return f"Diff ({self.value}): {self.content}"
224
@property
226
def tag_name(self):
227
return "ins" if self.value == "++" else "del"
228
class Link(Element):
231
def __init__(self, content, destination, image=False):
232
super().__init__()
233
self.content = content
234
self.destination = destination
235
self.image = image
236
def __repr__(self):
238
return f"{'Image' if self.image else 'Link'}: {self.content} -> {self.destination}"
239
@property
241
def tag_name(self):
242
return "a"
243
class Image(Link):
246
def __init__(self, text, destination):
247
super().__init__(text, destination, True)
248
@property
250
def tag_name(self):
251
return "img"
252
def parse_line(source):
255
if trailing(source, "\\") == 1:
256
source = source.rstrip("\\")
257
hard_break = True
258
else:
259
hard_break = False
260
tokens = []
262
pattern = re.compile(inlineRegex, re.MULTILINE | re.DOTALL | re.VERBOSE)
263
matches = pattern.finditer(source)
264
lookup = 0
266
for i in matches:
267
l = i.start()
268
r = i.end()
269
tokens.append(source[lookup:l])
270
lookup = r
272
if i.group("em"):
274
tokens.append(Emphasis(i.group("textEm"), len(i.group("em"))))
275
if i.group("textCode"):
276
tokens.append(Code(i.group("textCode")))
277
if i.group("strike"):
278
tokens.append(Strikethrough(i.group("textStrike")))
279
if i.group("diff"):
280
tokens.append(Diff(i.group("textDiff"), i.group("diff")))
281
if i.group("urlText"):
282
if i.group("imageFlag"):
283
tokens.append(Image(i.group("urlText"), i.group("urlDestination")))
284
else:
285
tokens.append(Link(i.group("urlText"), i.group("urlDestination")))
286
tokens.append(source[lookup:])
288
if hard_break:
290
tokens.append(HardBreak())
291
return tokens
293
def tokenise(source):
296
tokens = []
297
current_block = Element()
299
lines = [line[1:] if line.startswith(" ") else line for line in source.split("\n")] # remove leading spaces
301
i = 0
303
while i < len(lines):
304
line = lines[i]
305
if not line.strip():
306
# Void block
307
tokens.append(current_block)
309
current_block = Element()
310
i += 1
312
elif only_chars(line.strip(), "-_* ") and len(line.strip()) >= 3:
313
# Horizontal rule
314
tokens.append(current_block)
316
current_block = Rule()
317
i += 1
319
elif (lines[i].startswith("*") or lines[i].startswith("+") or lines[i].startswith("-")) and lines[i][1:].startswith(" "):
320
if not isinstance(current_block, UnorderedList):
321
tokens.append(current_block)
322
content = []
324
while i < len(lines) and ((lines[i].startswith("*") or lines[i].startswith("+") or lines[i].startswith("-")) and lines[i][1:].startswith(" ")):
326
inner_content = lines[i][2:].strip() + "\n" # discard marker and space
327
i += 1
328
while i < len(lines) and lines[i].strip() and not ((lines[i].startswith("*") or lines[i].startswith("+") or lines[i].startswith("-")) and lines[i][1:].startswith(" ")):
329
inner_content += lines[i] + "\n"
330
i += 1
331
content.append(ListItem(inner_content))
333
current_block = UnorderedList(content)
335
elif re.match(r"^\d+\.", line):
336
if not isinstance(current_block, UnorderedList):
337
tokens.append(current_block)
338
content = []
340
while i < len(lines) and re.match(r"^\d+\.", line) and len(lines[i].split(".", 1)) > 1:
342
inner_content = lines[i].split(".", 1)[1] + "\n" # discard number and period
343
i += 1
344
while i < len(lines) and lines[i].strip() and not re.match(r"^\d+\.", line):
345
inner_content += lines[i] + "\n"
346
i += 1
347
content.append(ListItem(inner_content))
349
current_block = OrderedList(content)
351
elif line.startswith("#") and leading(line.lstrip("#"), " "):
352
tokens.append(current_block)
353
content = line.lstrip("#").strip()
355
current_block = Heading(content, leading(line, "#"))
356
i += 1
358
elif line.startswith(">"):
359
if not isinstance(current_block, Blockquote):
360
tokens.append(current_block)
361
content = ""
363
while i < len(lines) and (lines[i].startswith(">") or (not lines[i].startswith("#") and not lines[i].startswith(">") and lines[i].strip()) and not only_chars(line.strip(), "-_* ") and len(line.strip()) >= 3):
365
content += lines[i].lstrip(">") + "\n"
366
i += 1
367
current_block = Blockquote(content)
369
elif leading(line, "~") == 3 or leading(line, "`") == 3:
370
if not isinstance(current_block, CodeBlock):
371
tokens.append(current_block)
372
language = line.lstrip("`~").strip()
374
content = ""
376
i += 1 # skip the opening fence
377
while i < len(lines) and not lines[i].strip() in ("```", "~~~"):
378
content += lines[i] + "\n"
379
i += 1
380
if i < len(lines):
382
i += 1 # prevent a new block from beginning with the closing fence
383
current_block = CodeBlock(content, language=language)
385
elif i < len(lines) - 1 and (only_chars(lines[i+1].strip(), "=") or only_chars(lines[i+1].strip(), "-")) and lines[i+1].strip():
386
tokens.append(current_block)
387
content = line.strip()
389
current_block = Heading(content, 1 if lines[i+1].startswith("=") else 2)
390
i += 2
392
else:
393
if not isinstance(current_block, Paragraph):
394
# Create a paragraph, if there is no other specifier
395
tokens.append(current_block)
396
content = ""
398
while (i < len(lines)
400
and not lines[i].startswith("#")
401
and not lines[i].startswith(">")
402
and not lines[i].startswith("* ")
403
and not lines[i].startswith("+ ")
404
and not lines[i].startswith("- ")
405
and not lines[i].startswith("~~~")
406
and not lines[i].startswith("```")
407
and lines[i].strip()):
408
content += lines[i].strip() + "\n"
409
i += 1
410
current_block = Paragraph(content)
412
tokens.append(current_block)
414
return tokens
416
def make_html(ast):
419
soup = beautifulsoup.BeautifulSoup()
420
for i in ast:
421
# Use bs4 to generate HTML
422
if isinstance(i, str):
423
soup.append(i)
424
elif hasattr(i, "content") and i.tag_name != "m-void":
425
tag = soup.new_tag(str(i.tag_name))
426
if i.tag_name == "a":
427
tag["href"] = i.destination
428
if i.tag_name == "img":
429
tag["src"] = i.destination
430
if i.tag_name == "pre":
431
tag["data-language"] = i.language
432
if i.classes:
433
tag["class"] = " ".join(i.classes)
434
try:
435
if isinstance(i.content, list):
436
tag.append(make_html(i.content))
437
elif i.content:
438
tag.string = i.content
439
except AttributeError as exc:
440
# print(i)
441
print(exc, file=sys.stderr)
442
...
443
soup.append(tag)
444
return soup
445
if __name__ == '__main__':
448
# Generate an AST from a markdown file
449
ast = tokenise(
450
r"""
451
Hello World
452
===========
453
Lorem
455
ipsum
456
dolor
457
sit
458
amet.
459
1. Test
461
2. Test
462
3. Test
463
* Test
465
* Test
466
* Lorem
468
ipsum
469
* Test
470
* Test
471
472
> Hello
473
> World
474
> * Test
475
> * Test
476
> * Test
477
"""
478
)
479
# for i in ast:
480
# print(repr(i))
481
# Now convert the AST to HTML
483
print(make_html(ast).prettify(formatter=beautifulsoup.formatter.HTMLFormatter(indent=4)))
484