#!/usr/bin/env python3 import markdown import sys import io import re from pygments.formatters import HtmlFormatter from markdown.extensions.toc import TocExtension from markdown.extensions import Extension from markdown.preprocessors import Preprocessor # Python-Markdown (unlike CommonMark/GitHub) refuses to let a list interrupt a # paragraph unless there's a blank line between them, so a very common README # shape renders as one run-on paragraph instead of a list: # # Passing: # - foo # - bar # # This preprocessor restores the GitHub behavior: when a bullet ( - * + ) or a # "1."/"1)" ordered-list marker immediately follows a paragraph line, insert a # blank line so the list starts. We deliberately only interrupt on "1" for # ordered lists (matching CommonMark) so prose like "... the year\n1985. was # ..." is not turned into a list. Fenced code, indented code, and lines that # already follow a list item are left untouched. _MD_FENCE = re.compile(r'^(\s{0,3})(`{3,}|~{3,})') _MD_BULLET = re.compile(r'^ {0,3}[-*+][ \t]+\S') _MD_ORDERED1 = re.compile(r'^ {0,3}1[.)][ \t]+\S') _MD_ANYITEM = re.compile(r'^ {0,3}(?:[-*+]|\d{1,9}[.)])[ \t]') class _ListInterruptPreprocessor(Preprocessor): def run(self, lines): out, in_fence, fence = [], False, None # Track whether we're already inside a list. A bullet that merely # continues an existing list must NOT get a blank line inserted before # it: that would turn a tight list into a loose one (every item wrapped # in

), which is exactly what happens when a preceding item wraps onto # an indented continuation line and we mistake the next bullet for a # paragraph->list transition. We only want to interrupt a real paragraph. in_list = False for line in lines: m = _MD_FENCE.match(line) if m: tok = m.group(2)[0] if not in_fence: in_fence, fence = True, tok elif fence == tok: in_fence, fence = False, None out.append(line) continue if in_fence: out.append(line) continue if not line.strip(): # a blank line doesn't end a list (loose lists / lazy # continuation), so leave in_list untouched out.append(line) continue is_item = bool(_MD_ANYITEM.match(line)) indented = line[:1] in (' ', '\t') # a non-indented, non-item line after a list closes that list if in_list and not is_item and not indented: in_list = False if out: prev = out[-1] if (prev.strip() and not in_list and not _MD_ANYITEM.match(prev) and not prev.startswith((' ', '\t')) and (_MD_BULLET.match(line) or _MD_ORDERED1.match(line))): out.append('') if is_item: in_list = True out.append(line) return out class ListInterruptExtension(Extension): def extendMarkdown(self, md): # priority 21: just above the built-in 'normalize_whitespace' (20) so we # operate on clean lines before block parsing. md.preprocessors.register( _ListInterruptPreprocessor(md), 'list_interrupt', 21) sys.stdin = io.TextIOWrapper(sys.stdin.buffer, encoding='utf-8') sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8') sys.stdout.write(''' ''') # Render to a string (not straight to stdout) so we can post-process it. # Note: you may want to run this through bleach for sanitization html = markdown.markdown( sys.stdin.read(), output_format="html5", extensions=[ "markdown.extensions.fenced_code", "markdown.extensions.codehilite", "markdown.extensions.tables", "markdown.extensions.sane_lists", ListInterruptExtension(), TocExtension(anchorlink=True)], extension_configs={ "markdown.extensions.codehilite":{"css_class":"highlight"}}) # A README's relative paths point at repo content, but a browser resolves them # against the page the readme is shown on (//about/... or the summary page # //), not against the file's own location — so they 404 or hit the wrong # file. cgit serves this content through three commands, so rewrite relative # references to absolute cgit URLs (absolute so they work on the about page and # the summary page alike): # -> //plain/?h= (raw bytes) # *.md -> //about/ (rendered markdown) # other/dir -> //tree/?h= (browsable blob view) # cgit hands the about-filter the path of the file being rendered as argv[1] # (README.md, or docs/foo.md for a rendered subpage), so relative links resolve # against *that* file's directory and links inside a rendered subpage work too. # A href that climbs out of the repo with ".." (e.g. ../sibling) is resolved # against the repo's URL location (-> /sibling). The about view renders against # the configured readme ref, so about/ links carry no ?h=. If the repo context # env vars are absent we leave the references untouched. import os, re from urllib.parse import urljoin repo = os.environ.get("CGIT_REPO_URL", "").strip("/") if repo: branch = os.environ.get("CGIT_REPO_DEFBRANCH", "").strip() repo_root = "/" + repo + "/" plain = repo_root + "plain/" query = ("?h=" + branch) if branch else "" # directory of the file being rendered; relative links resolve against it. # argv[1] is the repo-relative readme/subpage path cgit passes the filter. cur = sys.argv[1] if len(sys.argv) > 1 else "" base_dir = "" if cur.startswith("/") else os.path.dirname(cur) # markdown files are rendered via the about view; everything else is a blob md_ext = re.compile(r"\.(?:md|markdown|mdown|mkd)$", re.I) # leave absolute, protocol-relative, root-relative, anchor, query-only and # scheme (mailto:, http:, data:, ...) URLs alone skip = re.compile(r"^(?:[a-z][a-z0-9+.\-]*:|//|/|[#?])", re.I) def _split_frag(url): # split off a trailing #fragment (kept verbatim on the rewritten URL) if "#" in url: path, frag = url.split("#", 1) return path, "#" + frag return url, "" def _resolve(path): # resolve `path` (relative to base_dir) into a repo-root-relative path, # collapsing "." / ".."; returns (climbs, cleaned) where `climbs` counts # ".." segments that escaped above the repo root. combined = (base_dir + "/" + path) if base_dir else path out, climbs = [], 0 for seg in combined.split("/"): if seg in ("", "."): continue if seg == "..": if out: out.pop() else: climbs += 1 else: out.append(seg) return climbs, "/".join(out) def rewrite_img(m): url = m.group(2) if not url or skip.match(url): return m.group(0) path, frag = _split_frag(url) climbs, cleaned = _resolve(path) if climbs or not cleaned: return m.group(0) return m.group(1) + plain + cleaned + query + frag + m.group(3) def rewrite_href(m): url = m.group(2) if not url or skip.match(url): return m.group(0) path, frag = _split_frag(url) climbs, cleaned = _resolve(path) if climbs: # escapes the repo (sibling repo etc.): resolve against repo location dest = urljoin(repo_root, "../" * climbs + cleaned) elif not cleaned: dest = repo_root + (query or "") elif md_ext.search(cleaned): # rendered through the about-filter (renders against the readme ref) dest = repo_root + "about/" + cleaned else: dest = repo_root + "tree/" + cleaned + query return m.group(1) + dest + frag + m.group(3) html = re.sub(r'(]*?\bsrc=")([^"]*)(")', rewrite_img, html, flags=re.I) html = re.sub(r'(]*?\bhref=")([^"]*)(")', rewrite_href, html, flags=re.I) sys.stdout.write("

") sys.stdout.write(html) sys.stdout.write("