From 898681c2532beaac134259024aaa83b794af13e4 Mon Sep 17 00:00:00 2001
From: Aleteoryx <alyx@aleteoryx.me>
Date: Sat, 6 Sep 2025 22:32:24 -0400
Subject: [PATCH] build system

---
 README.md                | 32 +------------
 gloss/__init__.py        | 84 ++++++++++++++++++++++++++++++++++
 gloss/__main__.py        | 99 +++++++++++-----------------------------
 gloss/markup/__init__.py |  3 ++
 gloss/modes/glossary.py  | 24 ++++------
 gloss/util.py            | 10 ++++
 6 files changed, 132 insertions(+), 120 deletions(-)
 create mode 100755 gloss/__init__.py
 create mode 100644 gloss/util.py

diff --git a/README.md b/README.md
index 1caa45f7117a2b91715713a2e512bb8a6be65a09..0138cf8770096d438dc2c9c996433af8c8799f18 100644
--- a/README.md
+++ b/README.md
@@ -6,34 +6,4 @@ it is designed to maximize nonlinear browsing.
 
 ***
 
-the central gloss.py script translates each .gls file in its input directory to a .html in its output.
-to run it, you will need a python runtime and a C compiler. make sure to download the entire repo.
-
-.gls files are composed of a names section, a set of blocks, and an optional "see also" section.
-
-the names section consists of the first non-empty non-comment lines in a file.
-each line becomes a name for the file.
-a file's names are automatically turned into links,
-the first time it is referenced in another document.
-matching is performed at word boundaries: a file with name "foo" will not be linked from "foobar".
-the names section is terminated with a blank line.
-
-blocks can be either paragraph blocks or quote blocks, and they are terminated by blank lines.
-a block is a quote block if its first line begins with a '>'.
-to begin a paragraph block with '>', escape it with a backslash.
-
-if any line in a block begins with ~, it will become the block's metadata.
-only quotes have metadata, for authorship info.
-the format is thus: `<source> @@ <time> // <url>`.
-if `@@` is omitted, the signature will have no time associated.
-if `//` is omitted, the signature will have no URL associated.
-
-within a block, one can write a link of the form `<https://example.com>`, or `<https://example.com|example page>`.
-one can also escape `<` and `>` with backslashes. regions of text can be italicized by putting them `/in slashes/`.
-
-if a block begins with `***`, the "see also" section is entered.
-each subsequent non-empty line should be the slug (filename, minus .gls) of an article.
-it will be linked in a "see also" list at the bottom.
-
-if a template.html is present in the source directory, it will be the template for all rendered pages.
-run gloss.py with no arguments for more information.
+I'll document this another time. maybe. it's for personal use mostly
diff --git a/gloss/__init__.py b/gloss/__init__.py
new file mode 100755
index 0000000000000000000000000000000000000000..d4f42b041b943e3d77700e2b8325b655bc27c16e
--- /dev/null
+++ b/gloss/__init__.py
@@ -0,0 +1,84 @@
+#!/bin/env python3
+
+import yaml
+from pathlib import Path
+from typing import List, Tuple, Callable
+from dataclasses import dataclass
+
+from .modes import glossary
+from .util import die, copy
+
+### MODES ###
+
+def copymode(sfmt, srcdir, outdir):
+	i = 0
+	for srcfile in srcdir.iterdir():
+		if not srcfile.is_file() or srcfile.name == '.gloss':
+			continue
+		i += 1
+		outfile = Path(outdir, srcfile.name)
+		copy(srcfile, outfile)
+	print(sfmt.format('###', f'copied {i} files'))
+
+modes = {
+	'copy': copymode,
+	'gloss': glossary.gloss
+}
+
+
+### FS WALK ###
+
+@dataclass
+class Step:
+	srcdir: Path
+	outdir: Path
+	reldir: Path
+	process: Callable[[str, Path, Path], None]
+	
+	def test(self):
+		if not self.outdir.is_dir() and self.outdir.exists():
+			die(f'can\'t output "{self.outdir}": non-directory already exists', 3)
+
+
+	def exec(self, sfmt):
+		if not self.outdir.exists():
+			self.outdir.mkdir()
+		self.process(sfmt, self.srcdir, self.outdir)
+
+def get_steps(srcdir, outdir) -> List[Step]:
+	global modes
+
+	dirs = [srcdir]
+	ret = []
+	for adir in dirs:
+		reldir = adir.relative_to(srcdir)
+
+		glossfile = Path(adir, '.gloss')
+		out = mode = None
+		if glossfile.is_file():
+			parsed = yaml.safe_load(open(glossfile, 'rt'))
+			out = parsed.get('out', None)
+			mode = parsed.get('mode', None)
+		
+		if out is None:
+			out = reldir
+		if mode is None:
+			mode = 'copy'
+		
+		if mode == 'ignore':
+			continue
+		
+		if mode not in modes:
+			die(f'fatal: unknown mode in "{glossfile}": "{mode}"', 2)
+
+		empty = True
+		for what in adir.iterdir():
+			if what.is_dir():
+				dirs.append(what)
+			elif what.is_file():
+				empty = False
+		
+		if mode != 'copy' or not empty:
+			ret.append(Step(adir, Path(outdir, out), reldir, modes[mode]))
+	
+	return ret
diff --git a/gloss/__main__.py b/gloss/__main__.py
index 6f3c741e9c673348024f260660806a0f6ae7995b..bc76b333eaf1eec11754ec1f392f6ba502ea7881 100755
--- a/gloss/__main__.py
+++ b/gloss/__main__.py
@@ -1,14 +1,15 @@
 #!/bin/env python3
 
+from time import time
+start = time()
+
 from sys import argv
-import yaml
 from pathlib import Path
-from typing import List, Tuple, Callable
-from dataclasses import dataclass
+from math import log10
 
-from . import markup
+from . import get_steps
+from .util import die
 
-from .modes import glossary
 
 usage = f'''
 usage: {argv[0]} <SRCDIR> <OUTDIR>
@@ -26,78 +27,30 @@ said file's 'mode' key is missing, the mode defaults to 'copy'.
 		SRCDIR.
 '''[1:]
 
-def die(why, code=1):
-	print(why, file=stderr)
-	exit(code)
-
-
-### MODES ###
-
-def copymode(srcdir, outdir):
-	for srcfile in srcdir.iterdir():
-		if not srcfile.is_file() or srcfile.name == '.gloss':
-			continue
-		outfile = outdir + srcfile.name
-		outfile.write_bytes(srcfile.read_bytes())
-
-modes = {
-	'copy': copymode,
-	'gloss': glossary.gloss
-}
-
-
-### FS WALK ###
 
-@dataclass
-class SrcDir:
-	srcdir: Path
-	outdir: Path
-	process: Callable[[Path, Path], None]
+argv = argv[1:]
+if len(argv) != 2 or argv[0][0] == '-' or argv[1][0] == '-':
+	die(usage)
+srcdir = Path(argv[0]).absolute()
+outdir = Path(argv[1]).absolute()
 
-def get_dirs(srcdir, outdir) -> List[SrcDir]:
-	global modes
 
-	dirs = [srcdir]
-	ret = []
-	for adir in dirs:
-		if not adir.is_dir():
-			continue
+print('collecting steps...')
+steps = get_steps(srcdir, outdir)
 
-		glossfile = Path(adir, '.gloss')
-		out = mode = None
-		if glossfile.is_file():
-			parsed = yaml.safe_load(open(glossfile, 'rt'))
-			out = parsed.get('out', None)
-			mode = parsed.get('mode', None)
-		
-		if out is None:
-			out = adir.relative_to(srcdir)
-		if mode is None:
-			mode = 'copy'
-		
-		if mode == 'ignore':
-			continue
-		
-		if mode not in modes:
-			die(f'fatal: unknown mode in "{glossfile}": "{mode}"')
-		
-		ret.append(SrcDir(adir, Path(outdir, out), modes[mode]))
-		dirs.extend(adir.iterdir())
-	
-	return ret
+numlen = int(log10(len(steps))+1)
+nfmt = f'[{{0:{numlen}}}/{len(steps)}]' # calculates the correct width for e.g. [ 5/52]
+sfmt = f'<{{0:^{numlen*2+1}}}> {{1}}'   # and for the status, e.g.              < END >
 
+print(sfmt.format('...', 'testing!'))
+for n, step in enumerate(steps):
+	print(f'{nfmt} testing {{1}}'.format(n+1, Path('/', step.reldir)))
+	step.test()
 
-if __name__ == '__main__':
-	argv = argv[1:]
-	if len(argv) != 2 or argv[0][0] == '-' or argv[1][0] == '-':
-		die(usage)
+print(sfmt.format('...', 'building!'))
+for n, step in enumerate(steps):
+	print(f'{nfmt} building {{1}}'.format(n+1, Path('/', step.reldir)))
+	step.exec(sfmt)
 
-	srcdir = Path(argv[0]).absolute()
-	outdir = Path(argv[1]).absolute()
-	
-	steps = get_dirs(srcdir, outdir)
-	print(steps)
-	for step in steps:
-		if not step.outdir.exists():
-			step.outdir.mkdir()
-		step.process(step.srcdir, step.outdir)
+stop = time()
+print(sfmt.format('END', f'build complete in {stop-start:.2}s! :3'))
diff --git a/gloss/markup/__init__.py b/gloss/markup/__init__.py
index 6bfcfd7c9ae3d4dc6caaa3ef3baf4c0db227fc6b..25966d289a68959fcb5929a023d9b996d5d1da67 100644
--- a/gloss/markup/__init__.py
+++ b/gloss/markup/__init__.py
@@ -14,6 +14,9 @@ class Markup:
 		
 		self.proc = Popen([str(self.bfile), 'convert'], stdin=PIPE, stdout=PIPE, text=True)
 	
+	def __del__(self):
+		self.proc.kill()
+
 	def process(self, text):
 		self.proc.stdin.write(text+"\n")
 		self.proc.stdin.flush()
diff --git a/gloss/modes/glossary.py b/gloss/modes/glossary.py
index b8442478faf192daaaee87a40ad2e436b2d4235d..aa29f832e2945d3c154256946e01e278c5c8fee4 100755
--- a/gloss/modes/glossary.py
+++ b/gloss/modes/glossary.py
@@ -7,9 +7,10 @@ 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 sys import argv, stderr
 
-from .. import markup
+from gloss.markup import get as getfmt
+from gloss.util import die
 
 usage = f'''
 usage: {argv[0]} <SRCDIR> <OUTDIR>
@@ -26,10 +27,6 @@ interpolated as in str.format, and the following keys are provided:
 	{{modtime}} - The datetime of the article's last edit.
 '''[1:]
 
-def die(why, code=1):
-	print(why, file=stderr)
-	exit(code)
-
 
 ### TYPES ###
 
@@ -151,7 +148,7 @@ class Indexes:
 				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]))
+		self.names_sorted = sorted(self.names_sorted, key=lambda x: len(x[0]), reverse=True)
 			
 def gen_inner_html(fmt, file, idx):
 	for block in file.blocks:		# format text, listify it
@@ -229,7 +226,7 @@ def gen_inner_html(fmt, file, idx):
 
 ### ENTRYPOINT ###
 
-def gloss(srcdir, outdir):
+def gloss(sfmt, srcdir, outdir):
 	try:
 		with open('{srcdir}/template.html', 'rt') as fp:
 			template = fp.read()
@@ -252,7 +249,7 @@ def gloss(srcdir, outdir):
 </html>
 '''
 
-	fmt = markup.get()
+	fmt = getfmt()
 
 	files = []
 	for fn in glob('*.gls', root_dir=srcdir):
@@ -273,10 +270,5 @@ def gloss(srcdir, outdir):
 				'modtime': datetime.fromtimestamp(stat(f'{srcdir}/{file.slug}.gls').st_mtime)
 			}
 			fp.write(template.format(**ctx))
-
-if __name__ == '__main__':
-	argv = argv[1:]
-	if len(argv) != 2 or argv[0][0] == '-' or argv[1][0] == '-':
-		die(usage)
-
-	gloss(argv[0], argv[1])
+	
+	print(sfmt.format('###', f'generated {len(files)} entries'))
diff --git a/gloss/util.py b/gloss/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec0feaa1df991a74f6c2a5d397f84b4f3670d881
--- /dev/null
+++ b/gloss/util.py
@@ -0,0 +1,10 @@
+from sys import exit
+
+def die(why, code=1):
+	print(why, file=stderr)
+	exit(code)
+
+def copy(a, b):
+	with open(a, 'rb') as af, open(b, 'wb') as bf:
+		while buf := af.read(2**20):
+			bf.write(buf)