#!/usr/bin/env texlua -------------------------------------------------------------------------------- -- FILE: rst_helpers.lua -- USAGE: ./rst_helpers.lua -- DESCRIPTION: Complement to the reStructuredText parser -- AUTHOR: Philipp Gesang (Phg), -- VERSION: 1.0 -- CREATED: 07/09/10 01:03:08 CEST -------------------------------------------------------------------------------- -- local utf = unicode.utf8 local P, R, S, V, match = lpeg.P, lpeg.R, lpeg.S, lpeg.V, lpeg.match local C, Carg, Cb, Cc, Cg, Cmt, Cp, Cs, Ct = lpeg.C, lpeg.Carg, lpeg.Cb, lpeg.Cc, lpeg.Cg, lpeg.Cmt, lpeg.Cp, lpeg.Cs, lpeg.Ct local helpers = {} helpers.table = {} helpers.cell = {} function helpers.dbg_writef(...) if helpers_debug == true then io.write(string.format(...)) end end --helpers.dbg_write = dbg_write local dbg_write = helpers.dbg_writef helpers.patterns = {} do local p = helpers.patterns p.dash = P"-" p.equals = P"=" p.plus = P"+" p.bar = P"|" p.eol = P"\n" p.last = -P(1) p.space = P" " p.dash_or_equals = p.dash + p.equals p.celldelim = p.bar + p.plus p.cellcontent = (1 - p.celldelim) p.cell = p.celldelim * C((1 - p.celldelim)^1) * #p.celldelim p.cell_line = p.plus * p.dash^1 * #p.plus p.dashesonly = p.dash^1 * p.last p.spacesonly = p.space^1 * p.last p.col_start = Cp() * p.dash_or_equals^1 p.col_stop = p.dash_or_equals^1 * Cp() p.column_starts = p.col_start * ( p.space^1 * p.col_start)^1 p.column_stops = p.col_stop * ( p.space^1 * p.col_stop)^1 p.st_headsep = p.equals^1 * (p.space^1 * p.equals^1)^1 p.st_colspan = p.dash^1 * (p.space^1 * p.dash^1)^0 * p.space^0 * p.last p.st_span_starts = Ct(Cp() * p.dash^1 * (p.space^1 * Cp() * p.dash^1)^0) p.st_span_stops = Ct(p.dash^1 * Cp() * (p.space^1 * p.dash^1 * Cp())^0) p.cells = P{ [1] = "cells", cells = p.celldelim * (C(V"in_cell") * (V"matchwidth" * C(V"in_cell")) ^1), in_cell = p.cellcontent^1 + (p.dash - p.cellcontent)^1, matchwidth = Cmt(C(p.celldelim) * Carg(1), function(s,i,del, layout) local pos = 1 local lw = layout.widths for n=1, #lw do pos = pos + lw[n] + 1 if (i - 1) == pos then return true end end return false end), } p.sep_line = p.plus * (p.dash^1 * p.plus)^1 * p.last p.sep_head = p.plus * (p.equals^1 * p.plus)^1 * p.last p.sep_part = ((1 - p.cell_line)^0 * p.cell_line) - p.sep_line p.new_row = p.sep_line + p.sep_head + p.sep_part p.whitespace = S" \t\v\r\n"^1 p.strip = p.whitespace^0 * C((1 - (p.whitespace * p.last))^1) * p.whitespace^0 * p.last end function helpers.cell.create(raw, n_row, n_col, parent, variant) local p = helpers.patterns local cell = {} cell.stripped = raw and p.strip:match(raw) or "" cell.content = raw cell.width = raw and utf.len(raw) or 0 cell.bytes = raw and #raw or 0 cell.variant = "normal" -- [normal|separator|y_continue|x_continue] cell.pos = {} cell.pos.x = n_col cell.pos.y = n_row cell.span = {} cell.span.x = 1 cell.span.y = 1 cell.parent = parent return cell end function helpers.cell.get_x_span(content, layout, init) local acc = 0 local lw = layout.widths for n=init, #lw do acc = acc + lw[n] + 1 if utf.len(content) + 1 == acc then return n - init end end return false end -- Extending a cell by 1 cell horizontally. function helpers.cell.add_x (cell) cell.span.x = cell.span.x + 1 end local function set_layout (line) local p = helpers.patterns local layout = {} local slice = Ct((p.plus * C(p.dash^1) * #p.plus)^1) layout.widths = {} layout.slices = {} for n, elm in ipairs(slice:match(line)) do layout.widths[n] = #elm layout.slices[n] = elm end return layout end helpers_debug = true function helpers.table.create(raw) local newtab = {} newtab.rows = {} newtab.layout = set_layout(raw[1]) local p = helpers.patterns newtab.resolve_parent = function(row, col, array) local array = array or newtab.rows local cell = array[row][col] local par_row, par_col = row, col if cell.parent then par_row, par_col = newtab.resolve_parent(cell.parent.y, cell.parent.x) end return par_row, par_col end newtab.__init = function() local hc = helpers.cell local rowcount = 0 local newtablayout = newtab.layout for nr, row in ipairs(raw) do newtab.rows[nr] = {} local this_row = newtab.rows[nr] this_row.sepline = p.sep_line:match(row) this_row.sephead = p.sep_head:match(row) this_row.seppart = p.sep_part:match(row) if this_row.sephead then newtab.has_head = true newtab.head_end = nr end local splitted = { p.cells:match(row, 1, newtablayout) } local pos_layout, pos_row = 1, 1 local make_empty = {} make_empty.n, make_empty.parent = 0, nil while pos_layout <= #newtablayout.widths do local splitpos = splitted[pos_layout] local layoutwidth = newtablayout.widths[pos_layout] local span = 1 local this if make_empty.n > 0 then make_empty.n = make_empty.n - 1 this = hc.create("", nr, pos_layout, make_empty.parent) this.parent = make_empty.parent p_row, p_col = newtab.resolve_parent(this.parent.y, this.parent.x) local thisparent = newtab.rows[p_row][p_col] if this_row.sepline or this_row.sephead or newtab.rows[p_row][p_col].variant == "separator" then this.variant = "separator" else this.variant = "empty1" end else local cellwidth = utf.len(splitpos) if cellwidth > layoutwidth then span = span + hc.get_x_span(splitpos, newtablayout, pos_layout) end pos_row = pos_row + span this = hc.create(splitpos, nr, pos_layout, nil) if p.dashesonly:match(splitpos) or this_row.sepline or this_row.sephead then this.variant = "separator" end this.span.x = span make_empty.n = span - 1 make_empty.parent = span > 1 and { y = nr, x = pos_layout } or nil end this_row[pos_layout] = this pos_layout = pos_layout + 1 end -- while end -- for loop over rows local oldrows = newtab.rows local newrows = oldrows for nc, width in ipairs(newtablayout.widths) do -- this is gonna be extremely slow but at least it's readable local newrow local currentrow = 1 for nr, row in ipairs(newrows) do local cell = row[nc] dbg_write("nc: %s, nr:%2s | %9s | ", nc, nr,cell.variant) if row.sepline or row.sephead or p.dashesonly:match(cell.content) or cell.variant == "separator" then -- separator; skipping and beginning new row newrows[nr][nc] = cell currentrow = currentrow + 1 newrow = true dbg_write("new >%24s< ", cell.stripped) if cell.parent then dbg_write("parent |") else dbg_write("no par |") end else dbg_write("old >%24s< ", cell.stripped) if cell.parent then dbg_write("parent |") else dbg_write("no par |") end if newrow then newrows[nr][nc] = cell currentrow = currentrow + 1 else -- continuing parent local par_row, par_col local parent if cell.parent then par_row, par_col = newtab.resolve_parent(cell.parent.y, cell.parent.x, newrows) dbg_write(" use %s,%2s | ", par_col, par_row) else -- Using vertical predecessor. par_row, par_col = newtab.resolve_parent(nr-1,nc, newrows) dbg_write(" new %s,%2s | ", par_col, par_row) end parent = newrows[par_row][par_col] if newrows[nr].seppart then dbg_write("span++") parent.span.y = parent.span.y + 1 end parent.content = parent.content .. cell.content parent.stripped = parent.stripped .. " " .. cell.stripped cell.variant = "empty2" cell.parent = { x = par_col, y = par_row } end newrow = false end dbg_write("\n") newrows[nr][nc] = cell end -- for loop over rows end -- for loop over columns --newtab.rows = oldrows newtab.rows = newrows end newtab.__init() newtab.__draw_debug = function() for nr, row in ipairs(newtab.rows) do for nc, cell in ipairs(row) do local field = cell.variant:sub(1,7) if cell.parent then field = field .. string.format(" %s,%2s",cell.parent.x, cell.parent.y) end dbg_write("%12s | ", field) end dbg_write("\n") end end return newtab end function helpers.table.resolve_parent (row, col, array) local cell = array[row][col] local par_row, par_col = row, col if cell.parent then par_row, par_col = self.resolve_parent(cell.parent.y, cell.parent.x) end return par_row, par_col end -- Check the column boundaries of a simple table. function helpers.get_st_boundaries (str) local p = helpers.patterns local starts, stops, slices = {}, {}, {} for n, elm in ipairs({ p.column_starts:match(str) }) do slices[n] = { start = elm } starts[elm] = true end for n, elm in ipairs({ p.column_stops :match(str) }) do slices[n]["stop"] = elm stops[elm] = true end return { starts = starts, stops = stops, slices = slices } end function helpers.table.simple(raw) local rows = {} local multispans = {} local bounds = helpers.get_st_boundaries(raw[1]) local p = helpers.patterns for nr, row in ipairs(raw) do local newrow = {} local nc = 1 if not p.st_headsep:match(row) and not p.st_colspan:match(row) then local starts, stops = {}, {} local check_span = false if p.st_colspan:match(raw[nr+1]) then -- expect spans over several columns starts = p.st_span_starts:match(raw[nr+1]) stops = p.st_span_stops :match(raw[nr+1]) check_span = true else for colnr, slice in ipairs(bounds.slices) do starts[colnr] = slice.start stops [colnr] = slice.stop end end for nc, start in ipairs(starts) do -- last column can exceed layout width local stop = nc ~= #starts and stops[nc] or #row local cell = { content = "", span = { x = 1, y = 1 }, --ignore = false } cell.content = string.strip(row:sub(start, stop)) if check_span then local start_at, stop_at for colnr, slice in ipairs(bounds.slices) do if slice.start == start then start_at = colnr end if start_at and not (colnr == #bounds.slices) then if slice.stop == stop then stop_at = colnr break end else -- last column, width doesn't matter stop_at = colnr end end cell.span.x = 1 + stop_at - start_at end newrow[nc] = cell end elseif p.st_colspan:match(row) then newrow.ignore = true elseif not rows.head_end and nr > 1 and #raw > nr then -- ends the header rows.head_end = nr newrow.head_sep = true newrow.ignore = true else newrow.ignore = true end rows[nr] = newrow end for nr, row in ipairs(rows) do if not row.ignore and row[1].content == "" then row.ignore = true for nc, cell in ipairs(row) do local par_row, par_col = helpers.table.resolve_parent(nr - 1, nc, rows) parent = rows[par_row][par_col] parent.content = parent.content .. " " .. cell.content cell.content = "" end end end return rows end helpers.list = {} do local c = {} c.roman = S"ivxlcdm"^1 c.Roman = S"IVXLCDM"^1 c.alpha = R"az" - P"i" - P"v" - P"x" - P"l" c.Alpha = R"AZ" - P"I" - P"V" - P"X" - P"L" c.digit = R"09"^1 c.auto = P"#" local stripme = S" ()." local dontstrip = 1 - stripme local itemstripper = stripme^0 * C(dontstrip^1) * stripme^0 local con = function (str) str = itemstripper:match(str) for conv, pat in next, c do if pat:match(str) then return conv end end return false end helpers.list.conversion = con local rnums = { i = 1, v = 5, x = 10, l = 50, c = 100, d = 500, m = 1000, } local function roman_to_arab (str) local n = 1 local curr, succ local max_three = { } local value = 0 while n <= #str do if curr and curr == max_three[#max_three] then if #max_three >= 3 then return "Not a number" else max_three[#max_three+1] = curr end else max_three = { curr } end curr = rnums[str:sub(n,n)] n = n + 1 succ = str:sub(n,n) if succ and succ ~= "" then succ = rnums[succ] if curr < succ then --n = n + 1 --value = value + succ - curr value = value - curr else value = value + curr end else value = value + curr end end return value end helpers.list.roman_to_arab = roman_to_arab local suc = function (str, old) str, old = itemstripper:match(str), itemstripper:match(old) local n_str, n_old = tonumber(str), tonumber(old) if n_str and n_old then -- arabic numeral return n_str == n_old + 1 end local con_str, con_old = con(str), con(old) if con_str == "alpha" or con_str == "Alpha" then return str:byte() == old:byte() + 1 else -- “I'm a Roman!” - “A woman?” - “No, *Roman*! - Au!” - “So your father was a woman?” if not (str:lower() == str or str:upper() == str) then -- uneven cased --> fail return false end local trc = state.roman_cache n_str = trc[str] or nil n_old = trc[old] or nil if not n_str then n_str = roman_to_arab(str:lower()) trc[str] = n_str end if not n_old then n_old = roman_to_arab(old:lower()) trc[old] = n_old end return n_str == n_old + 1 end end helpers.list.successor = suc local greater = function (str, old) str, old = itemstripper:match(str), itemstripper:match(old) local n_str, n_old = tonumber(str), tonumber(old) if n_str and n_old then -- arabic numeral return n_str > n_old end local con_str, con_old = con(str), con(old) if con_str == "alpha" or con_str == "Alpha" then return str:byte() > old:byte() else if not (str:lower() == str or str:upper() == str) then -- uneven cased --> fail return false end local trc = state.roman_cache n_str = trc[str] or nil n_old = trc[old] or nil if not n_str then n_str = roman_to_arab(str:lower()) trc[str] = n_str end if not n_old then n_old = roman_to_arab(old:lower()) trc[old] = n_old end return n_str > n_old end end helpers.list.greater = greater local gd = function(str) str = itemstripper:match(str) local value local con_str = con(str) if con_str == "alpha" or con_str == "Alpha" then return str:byte() else if not (str:lower() == str or str:upper() == str) then return false end local trc = state.roman_cache n_str = trc[str] or nil if not n_str then n_str = roman_to_arab(str:lower()) trc[str] = n_str end return n_str end end helpers.list.get_decimal = gd end helpers.string = {} do -- This grammar inside the function is slightly faster than the same as an upvalue -- with the value of “width” repeatedly given via lpeg.Carg(). This holds -- for repeated calls as well. local ulen = utf.len function helpers.string.wrapat (str, width) local linelength = 0 local wrap = P{ [1] = "wrapper", wrapper = Cs(V"nowhitespace"^0 * (Cs(V"wrapme") + V"other")^1), whitespace = S" \t\v" + P"\n" / function() linelength = 0 end, nowhitespace = 1 - V"whitespace", ignore = P"\\type{" * (1 - P"}")^1 * P"}", other = Cmt(V"whitespace"^1 * (V"ignore" + (1 - V"whitespace")^1), function(s,i,w) linelength = linelength + ulen(w) return true end), wrapme = Cmt(V"whitespace"^1 * (1 - V"whitespace" - V"ignore")^1, function(s,i,w) local lw = ulen(w) if linelength + lw > width then linelength = lw return true end return false --end) / function (word) return "\n" .. match(V"whitespace"^1 * C((1 - V"whitespace")^1), word) end, end) / function (word) return "\n" .. word:match("[^%s]+") end, } local reflowed = wrap:match(str) return reflowed end end return helpers