local function resolve(base, relative)
if relative:sub(1, 1) == "/" then
return relative
end
local combined = base .. "/" .. relative
local segments = {}
for segment in combined:gmatch("[^/]+") do
if segment == ".." then
if #segments > 0 and segments[#segments] ~= ".." then
table.remove(segments)
else
table.insert(segments, "..")
end
elseif segment ~= "." and segment ~= "" then
table.insert(segments, segment)
end
end
local prefix = (base:sub(1, 1) == "/" or relative:sub(1, 1) == "/") and "/" or ""
return prefix .. table.concat(segments, "/")
end
-- The branch from the query string (?h=...), or nil. cgit doesn't pass it
-- to filters, but Lua filters run in cgit's process, which has the CGI
-- environment.
local function query_head()
local query = os.getenv("QUERY_STRING") or ""
for key, value in query:gmatch("([^&=]+)=([^&]*)") do
if key == "h" then
value = value:gsub("%+", " "):gsub("%%(%x%x)", function(hex)
return string.char(tonumber(hex, 16))
end)
if value ~= "" then
return value
end
end
end
return nil
end
local function url_escape(s)
return (s:gsub("[^%w._~/-]", function(c)
return string.format("%%%02X", c:byte())
end))
end
-- cgit provides html() to Lua filters. It writes in order with cgit's own
-- output, which io.write's buffered stdout doesn't. io.write is for running
-- the filter outside of cgit.
local emit = html or io.write
-- Run a shell command with input on stdin and return its output.
local function run(command, input)
local name = os.tmpname()
local file = assert(io.open(name, "w"))
file:write(input)
file:close()
local handle = io.popen(command .. " < " .. name, "r")
local output = handle and handle:read("*a")
if handle then
handle:close()
end
os.remove(name)
return output
end
local function md2html(markdown)
return run("@md2html@ --github", markdown)
end
local function shell_quote(s)
return "'" .. s:gsub("'", "'\\''") .. "'"
end
-- The files that exist in rev, as a set.
local function existing_files(rev, files)
local found = {}
if #files == 0 then
return found
end
local input = {}
for i, file in ipairs(files) do
input[i] = rev .. ":" .. file .. "\n"
end
local git_dir = shell_quote(os.getenv("CGIT_REPO_PATH") or ".")
local output = run("@git@ --git-dir=" .. git_dir .. " cat-file --batch-check", table.concat(input)) or ""
local i = 0
for line in output:gmatch("[^\n]*\n") do
i = i + 1
if line:match("^%x+ blob ") then
found[files[i]] = true
end
end
return found
end
-- The files the filter renders: README.md, and Markdown files in docs/.
local function renderable(file)
return file:sub(-3) == ".md"
end
local table_style = [[
]]
-- Column widths, shared by all tables with the same header. A column's
-- weight is the larger of its longest word and its average cell length, in
-- characters; code counts more, as monospace is wider. Narrow columns get a
-- fixed width, the others a share of what's left.
local code_weight = 1.25
local narrow = 12
local function length(s)
s = s:gsub("?%w+;", "x")
return select(2, s:gsub("[^\128-\191]", ""))
end
local function cell_weights(cell)
local longest, total = 0, 0
local function add(text, factor)
for word in text:gmatch("%S+") do
local n = length(word) * factor
longest = math.max(longest, n)
total = total + n + 1
end
end
for code in cell:gmatch("(.-)") do
add((code:gsub("<[^>]+>", "")), code_weight)
end
add((cell:gsub(".-", " "):gsub("<[^>]+>", " ")), 1)
return longest, math.max(total - 1, 0)
end
local function cells(row)
local result = {}
for cell in row:gmatch("]*>(.-)") do
table.insert(result, cell)
end
return result
end
local function header(tbl)
return table.concat(cells(tbl:match("
(.-)
") or ""), "\0")
end
local function column_widths(output)
local stats = {}
for tbl in output:gmatch("") do
local key = header(tbl)
stats[key] = stats[key] or { rows = 0, longest = {}, total = {} }
local s = stats[key]
for row in tbl:gmatch("(.-)
") do
s.rows = s.rows + 1
for i, cell in ipairs(cells(row)) do
local longest, total = cell_weights(cell)
s.longest[i] = math.max(s.longest[i] or 0, longest)
s.total[i] = (s.total[i] or 0) + total
end
end
end
local widths = {}
for key, s in pairs(stats) do
local weights, wide = {}, 0
for i = 1, #s.longest do
weights[i] = math.max(s.longest[i], s.total[i] / s.rows)
if weights[i] > narrow then
wide = wide + weights[i]
end
end
local cols = {}
for i, weight in ipairs(weights) do
if weight > narrow then
cols[i] = string.format('', 100 * weight / wide)
else
cols[i] = string.format('', math.ceil(weight) + 1)
end
end
widths[key] = "" .. table.concat(cols) .. ""
end
return widths
end
-- Add the column widths, and let code break after underscores.
local function layout_tables(output)
local widths = column_widths(output)
return (output:gsub("", function(tbl)
local key = header(tbl)
tbl = tbl:gsub("(.-)", function(code)
return "" .. code:gsub("_", "_") .. ""
end)
return "" .. widths[key] .. tbl:sub(#"" + 1)
end))
end
-- A heading's id, the way GitHub makes it: the text in lower case, without
-- punctuation, and with a hyphen for each space.
local function slug(content)
local text = content:gsub("<[^>]*>", ""):gsub("&[^;]*;", "")
return (text:lower():gsub("[^%w%s_%-\128-\255]", ""):gsub("%s", "-"))
end
-- Headings link to themselves, underlined on hover by cgit.css. Clicking
-- the heading that is the #fragment removes the fragment again. Setting
-- location.hash is what makes :target forget the heading;
-- history.replaceState alone doesn't.
local heading_links = [[
]]
-- Give headings ids, so links to #fragments work. A repeated id gets -1,
-- -2, etc., and so do ids cgit uses on the about page itself.
local function heading_ids(output)
local seen = { cgit = 0, header = 0, summary = 0 }
return (output:gsub("(.-)", function(level, content)
local id = slug(content)
if id == "" then
return nil
end
if seen[id] then
seen[id] = seen[id] + 1
id = id .. "-" .. seen[id]
else
seen[id] = 0
end
if not content:find("%s', id, content)
end
return string.format('%s', level, id, content, level)
end))
end
-- Highlight the heading a #fragment points to.
local target_style = [[
]]
-- Render ```mermaid code blocks in the browser.
local mermaid_script = [[
]]
local buffer = ""
local should_render = true
local current_dir = "" -- Stores the directory prefix of the file being processed
local current_file = ""
local function open(...)
local args = {...}
current_file = args[1] or ""
if current_file == "" then
current_file = "README.md"
end
if renderable(current_file) then
should_render = true
-- Extract directory context (e.g., "docs/ops.md" -> "docs/")
-- If it's the root README.md, current_dir stays an empty string ""
if current_file ~= "README.md" then
current_dir = current_file:match("(.*/)") or ""
else
current_dir = ""
end
else
should_render = false
end
buffer = ""
end
local function write(str)
if should_render then
buffer = buffer .. str
end
end
local function close()
if not should_render then
emit("Error: Access Denied. Only README.md and documentation markdown files are viewable here.
")
return
end
local repo = os.getenv("CGIT_REPO_URL") or ""
local head = query_head()
local query = ""
if head and head ~= os.getenv("CGIT_REPO_DEFBRANCH") then
query = "?h=" .. url_escape(head)
end
local link = "%[([^%]]+)%]%(([^:)]+)%)"
-- A link's path, resolved, and its fragment; nil for protocols (http,
-- https, etc.), absolute paths (/), and anchors (#).
local function target(path)
if path:sub(1, 1) == "/" or path:sub(1, 1) == "#" or path:match("^%w+:") then
return nil
end
local fragment
path, fragment = path:match("^([^#]*)(.*)$")
return resolve(current_dir, path), fragment
end
-- The README.md of a linked directory, if the filter renders it.
local function readme(path)
local file = (path == "" and "" or path .. "/") .. "README.md"
return renderable(file) and file or nil
end
local readmes = {}
for _, path in buffer:gmatch(link) do
path = target(path)
if path and readme(path) then
table.insert(readmes, readme(path))
end
end
local existing = existing_files(head or os.getenv("CGIT_REPO_DEFBRANCH") or "HEAD", readmes)
local processed = buffer:gsub(link, function(text, path)
local fragment
path, fragment = target(path)
if not path then
return nil
end
if existing[readme(path)] then
path = readme(path)
end
if path:sub(-3) == ".md" then
return string.format("[%s](/%s/about/%s%s%s)", text, repo, path, query, fragment)
else
return string.format("[%s](/%s/tree/%s%s%s)", text, repo, path, query, fragment)
end
end)
local output = md2html(processed)
if output then
output = heading_ids(output)
if output:find('", 1, true) then
emit(table_style)
output = layout_tables(output)
end
emit(output)
if output:find('', 1, true) then
emit(mermaid_script)
end
else
emit("Error: Could not execute md2html.
")
end
end
-- cgit hooks its output into the filter while the filter is open, so the
-- error page of a Lua error in here would end up in the buffer, and the
-- response would end without a word. Show the error instead.
local err
local function try(f, ...)
if not err then
local ok, e = xpcall(f, debug.traceback, ...)
if not ok then
err = e
end
end
end
function filter_open(...)
err = nil
try(open, ...)
end
function filter_write(str)
try(write, str)
end
function filter_close()
try(close)
if err then
emit("")
;(html_txt or io.write)(err)
emit("")
end
end