#!/bin/env python3
import html
import re
from datetime import datetime
from os import stat, system
from glob import glob
from typing import List, Optional, Union, Dict, Set, Tuple
from dataclasses import dataclass
from sys import argv, stderr, exit
from pathlib import Path
from subprocess import Popen, PIPE, run as runcmd
usage = f'''
usage: {argv[0]} <SRCDIR> <OUTDIR>
For each .gls file in SRCDIR, creates a matching .html file in OUTDIR.
If SRCDIR/template.html exists, it will be used. Templates are
interpolated as in str.format, and the following keys are provided:
{{title}} - The first name for an article.
{{slug}} - The name of the output file, minus '.html'.
{{body}} - The HTML content of an article.
{{modtime}} - The datetime of the article's last edit.
'''[1:]
def die(why, code=1):
print(why, file=stderr)
exit(code)
### TYPES ###
@dataclass
class Block:
ty: str
text: str
meta: str
@dataclass
class GlsFile:
slug: str
title: str
names: Set[str]
blocks: List[Block]
see_also: Optional[List[str]]
### PARSING ###
def readlines(fp):
return filter(
lambda x: not x.startswith(';'),
map(
lambda x: x.strip(),
fp.readlines() ) )
def first_pass(slug, fp):
lines = readlines(fp)
names = set()
title = None
for name in lines:
if len(name) == 0 and len(names) != 0: # section end
break
if title is None:
title = name.strip();
names.add(name.strip())
if len(names) == 0:
print(f'Empty file: {slug}.gls', file=stderr)
return None
do_see_also = False
block_type = None
block_text = None
block_meta = ''
blocks = []
for line in lines:
if len(line) == 0 and block_type is not None: # block end
blocks.append(Block(block_type, block_text, block_meta))
block_type = None
block_text = None
block_meta = ''
continue
if line.startswith('***') and block_type is None: # see also section
do_see_also = True
break
if line.startswith('~'):
block_meta = line[1:].strip()
elif block_type is None:
if len(line) == 0:
continue
if line.startswith('>'):
block_type = 'quote'
block_text = line[1:].strip()
continue
if line.startswith("\\>") or line.startswith("\\~") or line.startswith("\\***") or line == "\\":
line = line[1:]
block_type = 'para'
block_text = line
elif block_type == 'quote':
if line.startswith('>'):
line = line[1:].strip()
block_text += ' ' + line
elif block_type == 'para':
block_text += ' ' + line
see_also = None
if do_see_also:
see_also = [*filter(len, lines)]
elif block_type is not None:
blocks.append(Block(block_type, block_text, block_meta))
return GlsFile(slug, title, [*names], blocks, see_also)
class Markup:
def __init__(self, where, *, cfile='markup.c', bfile='markup'):
self.cfile = Path(where, cfile)
self.bfile = Path(where, bfile)
if not self.bfile.exists() or self.cfile.stat().st_mtime > self.bfile.stat().st_mtime:
print("recompiling markup subsystem...")
runcmd(['cc', str(self.cfile), '-o', str(self.bfile), '-Wall'], check=True)
print("recompiled!")
self.proc = Popen([str(self.bfile), 'convert'], stdin=PIPE, stdout=PIPE, text=True)
def process(self, text):
self.proc.stdin.write(text+"\n")
self.proc.stdin.flush()
segments = []
while (line := self.proc.stdout.readline()) not in ('NEXT\n', ''):
ty = line[0:4]
length = int(line[5:9])
ltext = line[12:12+length]
if ty == 'HTML':
segments.append((ltext,))
elif ty == 'IESC':
segments.append((html.escape(ltext),))
elif ty == 'TEXT':
segments.append(ltext)
else:
print(f'read in unknown type "{ty}" from markup subprocess', file=stderr)
return segments
quote_pat = re.compile("((?:(?!@@)(?!//).)*)(?:@@((?:(?!//).)+))?(?://(.+))?")
### GENERATION ###
def link_repl(mat):
url, name = map(lambda x: x if x is None else html.escape(x.strip()), mat.groups())
if name is not None and len(name) != 0:
return f'<a href="{url}">{name}</a>'
else:
return f'<a href="{url}"><{url}></a>'
@dataclass(init=False)
class Indexes:
by_slug: Dict[str, GlsFile]
by_name: Dict[str, GlsFile]
names_sorted: List[Tuple[str, re.Pattern]]
def __init__(self, files):
self.by_slug = {}
self.by_name = {}
self.names_sorted = []
for file in files:
self.by_slug[file.slug] = file
for name in file.names:
if name in self.by_name:
die(f'Redefinition of "{name}": occurs in {self.by_name[name].slug}.gls and {file.slug}.gls')
self.by_name[name] = file
pattern = re.compile(f"((?<=\\W)|^){re.escape(name)}((?=\\W)|$)", re.IGNORECASE)
self.names_sorted.append((name, pattern))
sorted(self.names_sorted, key=lambda x: len(x[0]))
def gen_inner_html(fmt, file, idx):
for block in file.blocks: # format text, listify it
block.text = fmt.process(block.text)
blacklist = set()
for name, pat in idx.names_sorted: # populate local links
if name in file.names: # ...but not to the same file
continue
if name in blacklist: # ...and don't repeat!
continue
for block in file.blocks:
for i in range(len(block.text)):
seg = block.text[i]
if type(seg) != str:
continue
m = pat.search(seg)
if m is None:
continue
s, e = m.span()
block.text.pop(i)
block.text.insert(i, seg[e:])
block.text.insert(i, (f'<a href="{html.escape(idx.by_name[name].slug)}.html">{seg[s:e]}</a>',))
block.text.insert(i, seg[:s])
break
content = f"<h1>{html.escape(file.title)}</h1>"
for block in file.blocks: # ok generate the html
text = ''.join(map(lambda x: html.escape(x) if type(x) == str else x[0], block.text))
if block.ty == 'para':
content += f"\n<p>{text}</p>"
elif block.ty == 'quote':
if block.meta is not None and len(block.meta):
sauce, date, url = map(
lambda x: x if x is None else html.escape(x.strip()),
quote_pat.match(block.meta).groups() )
else:
sauce = date = url = None
content += "\n<div>\n\t<blockquote" + ('' if url is None else f' cite="{url}"') + '>'
content += text
content += '</blockquote>'
if sauce is not None:
content += "\n\t<p>— <cite>" + (sauce if url is None else f'<a href="{url}">{sauce}</a>') + "</cite>"
if date is not None:
content += f', {date}'
content += '</p>'
content +='\n</div>'
if file.see_also is not None and len(file.see_also) != 0:
content += "\n<hr>\n<h3>See Also:</h3>\n<ul>"
for what in file.see_also:
if what in idx.by_slug:
page = idx.by_slug[what]
href = page.slug
name = page.title
elif what in idx.by_name:
page = idx.by_name[what]
href = page.slug
name = page.title
else:
if '|' in what:
href, name = what.split('|', 1)
else:
href = name = what
content += f"\n\t<li><a href=\"{html.escape(href)}.html\">{html.escape(name)}</a></li>"
content += "\n</ul>"
return content
### ENTRYPOINT ###
if __name__ == '__main__':
argv = argv[1:]
if len(argv) != 2 or argv[0][0] == '-' or argv[1][0] == '-':
die(usage)
srcdir = argv[0]
outdir = argv[1]
try:
with open('{srcdir}/template.html', 'rt') as fp:
template = fp.read()
except Exception:
template = \
'''<!doctype html>
<html>
<head>
<meta encoding='utf-8'>
<title>{title}</title>
</head>
<body>
<main>
{body}
</main>
<footer>File last modified {modtime:%a, %Y-%d-%M %H:%M:%S %Z}</footer>
</body>
</html>
'''
fmt = Markup(Path(__file__).parent)
files = []
for fn in glob('*.gls', root_dir=srcdir):
with open(f'{srcdir}/{fn}', 'rt') as fp:
data = first_pass(fn[:-4], fp)
if data is not None:
files.append(data)
indexes = Indexes(files)
for file in files:
with open(f'{outdir}/{file.slug}.html', 'wt') as fp:
ctx = {
'title': html.escape(file.title),
'slug': html.escape(file.slug),
'body': gen_inner_html(fmt, file, indexes),
'modtime': datetime.fromtimestamp(stat(f'{srcdir}/{file.slug}.gls').st_mtime)
}
fp.write(template.format(**ctx))