301 lines
7.2 KiB
Lua
301 lines
7.2 KiB
Lua
----------------------------------- LITERATE ----------------------------------
|
|
|
|
-- Variable for all literate stuff
|
|
local lit = {}
|
|
|
|
-- Status indicator
|
|
lit.status = true
|
|
|
|
-- Valid metadata structure
|
|
lit.metastruct = {
|
|
["mandatory"] = {
|
|
-- Value as table == whole patterns to match
|
|
["id"] = {"%a[_%w]*"},
|
|
},
|
|
["optional"] = {
|
|
["lang"] = {"lua", "fennel", "python", "js", "ruby", "lisp", "graphviz"},
|
|
["cmd"] = {".+"},
|
|
-- Value as string == type to match
|
|
["args"] = "table",
|
|
["shift"] = "boolean",
|
|
["wipe"] = "boolean",
|
|
["typed"] = "boolean",
|
|
["link"] = "path",
|
|
["img"] = "path",
|
|
["alt"] = "string",
|
|
["dump"] = "path",
|
|
["quote"] = "boolean",
|
|
},
|
|
}
|
|
|
|
-- TODO
|
|
function lit.stringify(content)
|
|
if pandoc.utils.type(content) == "Inlines" then
|
|
return pandoc.utils.stringify(content:walk {
|
|
Quoted = function(quoted)
|
|
local quote = (quoted.quotetype == SingleQuoted and '"' or "'")
|
|
quoted = pandoc.utils.stringify(quoted.content)
|
|
return pandoc.Str(quote .. quoted .. quote)
|
|
end,
|
|
Inline = function(inline)
|
|
return pandoc.utils.stringify(inline)
|
|
end,
|
|
})
|
|
else
|
|
return pandoc.utils.stringify(content)
|
|
end
|
|
end
|
|
|
|
function lit.meta2table(meta)
|
|
for k, v in pairs(meta) do
|
|
if pandoc.utils.type(v) == "table" then
|
|
lit.meta2table(v)
|
|
else
|
|
v = lit.stringify(v)
|
|
-- print(k, v)
|
|
end
|
|
end
|
|
return meta
|
|
end
|
|
lit.test = lit.meta2table(pandoc.read(("src/locate.yaml"):read_text()).meta)
|
|
|
|
-- Messages for the user
|
|
lit.msg = {
|
|
["INFO"] = {
|
|
["parsing"] = {
|
|
["en"] = "Parsing:\n#1",
|
|
["es"] = "Realizando análisis sintáctico:\n#1",
|
|
},
|
|
},
|
|
["WARNING"] = {
|
|
|
|
},
|
|
["ERROR"] = {
|
|
["invalid_key"] = {
|
|
["en"] = "Invalid key '#1' with value '#2'",
|
|
["es"] = "Clave '#1' inválida con valor '#2'",
|
|
},
|
|
["invalid_path"] = {
|
|
["en"] = "Invalid path '#1' in key '#2'",
|
|
["es"] = "Ruta '#1' inválida en clave '#2'",
|
|
},
|
|
["invalid_type"] = {
|
|
["en"] = "Invalid type '#1' in key '#2'",
|
|
["es"] = "Tipo '#1' inválido en clave '#2'",
|
|
},
|
|
["invalid_value"] = {
|
|
["en"] = "Invalid value '#1' in key '#2'",
|
|
["es"] = "Valor '#1' inválido en clave '#2'",
|
|
},
|
|
["no_key"] = {
|
|
["en"] = "Key '#1' not found",
|
|
["es"] = "Clave '#1' no encontrada",
|
|
},
|
|
["aborted"] = {
|
|
["en"] = "Aborted due previous errors",
|
|
["es"] = "Abortado debido a previos errores",
|
|
},
|
|
["yaml_empty"] = {
|
|
["en"] = "Empty YAML",
|
|
["es"] = "YAML vacío",
|
|
},
|
|
["yaml_invalid"] = {
|
|
["en"] = "Invalid YAML",
|
|
["es"] = "YAML inválido",
|
|
},
|
|
},
|
|
}
|
|
|
|
function lit.debuglevel(str)
|
|
if str == "ERROR" then
|
|
lit.status = false
|
|
return 2
|
|
elseif str == "WARNING" then
|
|
return 1
|
|
else
|
|
return 0
|
|
end
|
|
end
|
|
|
|
function lit.setmsg(msg, ...)
|
|
local lang = os.lang()
|
|
msg = (msg[lang] ~= nil and msg[lang] or msg)
|
|
for i, str in ipairs({...}) do
|
|
msg = msg:gsub("#" .. i, str)
|
|
end
|
|
return msg
|
|
end
|
|
|
|
function lit.getmsg(key, ...)
|
|
local levelname = "INFO"
|
|
local level = 0
|
|
for mtype, msgs in pairs(lit.msg) do
|
|
if msgs[key] ~= nil then
|
|
key = lit.setmsg(msgs[key], ...)
|
|
levelname, level = mtype, lit.debuglevel(mtype)
|
|
break
|
|
end
|
|
end
|
|
return key, levelname, level
|
|
end
|
|
|
|
function lit.puts(key, ...)
|
|
local verbosity = lit.debuglevel(PANDOC_STATE.verbosity)
|
|
local msg, levelname, level = lit.getmsg(key, ...)
|
|
if level >= verbosity then
|
|
print("[" .. levelname .. "] [LIT] " .. msg)
|
|
end
|
|
end
|
|
|
|
function lit.getmetaval(meta, key)
|
|
local mtype = pandoc.utils.type(meta[key])
|
|
local mval = meta[key]
|
|
if mtype == "Inlines" then
|
|
mval = pandoc.utils.stringify(mval)
|
|
mtype = pandoc.utils.type(mval)
|
|
end
|
|
return mval, mtype
|
|
end
|
|
|
|
function lit.checkmetaextra(meta)
|
|
for key, val in pairs(meta) do
|
|
local missing1 = lit.metastruct["mandatory"][key] == nil
|
|
local missing2 = lit.metastruct["optional"][key] == nil
|
|
local mval = lit.getmetaval(meta, key)
|
|
if missing1 and missing2 then
|
|
lit.puts("invalid_key", key, mval)
|
|
end
|
|
end
|
|
end
|
|
|
|
function lit.checkmetatype(type, meta, key)
|
|
local mval, mtype = lit.getmetaval(meta, key)
|
|
if type ~= mtype then
|
|
if type == "path" then
|
|
if not(pandoc.path.directory(mval):isdir()) then
|
|
lit.puts("invalid_path", mval, key)
|
|
end
|
|
else
|
|
lit.puts("invalid_type", mtype, key)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- TODO: has bug
|
|
function lit.checkmetatable(table, meta, key)
|
|
local mval = lit.getmetaval(meta, key)
|
|
for _, pattern in pairs(table) do
|
|
if mval:match("^" .. pattern .. "$") == nil then
|
|
lit.puts("invalid_value", mval, key)
|
|
end
|
|
end
|
|
end
|
|
|
|
function lit.checkmeta(meta, kind)
|
|
for key, val in pairs(lit.metastruct[kind]) do
|
|
if meta[key] == nil then
|
|
if kind == "mandatory" then
|
|
lit.puts("no_key", key)
|
|
end
|
|
else
|
|
if type(val) == "table" then
|
|
lit.checkmetatable(val, meta, key)
|
|
else
|
|
lit.checkmetatype(val, meta, key)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function lit.setmeta(meta)
|
|
lit.checkmeta(meta, "mandatory")
|
|
lit.checkmeta(meta, "optional")
|
|
lit.checkmetaextra(meta)
|
|
-- TODO checks for 2) duplicates
|
|
-- Set defaults if lit.status = true
|
|
return meta
|
|
end
|
|
|
|
-- Grammars
|
|
lit.g = {}
|
|
|
|
-- Lexical elements
|
|
lit.newline = lpeg.P"\r"^-1 * lpeg.P"\n"
|
|
lit.space = lpeg.S" \t"
|
|
lit.anyspace = lpeg.S" \t\r\n"
|
|
lit.spot = (1 - lit.anyspace)
|
|
lit.any = (lit.spot + lit.space)
|
|
lit.yamlheader = lit.space^0 * lpeg.P"---" * lit.space^0 * lit.newline
|
|
lit.yamlfooter = lit.space^0 * lpeg.P"..." * lit.space^0 * lit.newline^-1
|
|
lit.yamlbody = -lit.yamlfooter * lit.any^0 * lit.newline
|
|
lit.id = lpeg.R("az", "AZ") * lpeg.R("az", "AZ", "09")^0
|
|
lit.ref = lpeg.P"#" * lit.id
|
|
|
|
-- Blocks grammar
|
|
lit.g.block = lpeg.P {
|
|
"Block";
|
|
Block = lpeg.Ct(lpeg.V"YAML" * lpeg.V"Code", "name");
|
|
YAML = lpeg.C(lit.yamlheader * lit.yamlbody^0 * lit.yamlfooter);
|
|
Code = lpeg.C((lit.any + lit.newline)^0);
|
|
}
|
|
|
|
-- Evals Lisp code
|
|
--[[
|
|
function lit.eval(code)
|
|
local is_passed, out = pcall (
|
|
function () return fennel.eval(code) end,
|
|
function (e) return e end
|
|
)
|
|
local lua = ""
|
|
local out = tostring(out)
|
|
local preview = out:gsub("\n.*", "")
|
|
if is_passed then
|
|
lua = fennel.compileString(code)
|
|
end
|
|
return {is_passed = is_passed, preview = preview, out = out, lua = lua}
|
|
end
|
|
]]--
|
|
|
|
-- TODO
|
|
function lit.assert(e, status)
|
|
if status == false then
|
|
lit.puts("aborted")
|
|
os.exit(1)
|
|
end
|
|
return e
|
|
end
|
|
|
|
function lit.parseyaml(rawyaml)
|
|
local yaml = io.popen("pandoc -t json <<<\"" .. rawyaml .. "\" 2>&1")
|
|
if yaml:read("*l"):sub(1, 1) == "{" then
|
|
yaml = pandoc.read(rawyaml).meta
|
|
if pandoc.utils.stringify(yaml):isempty() then
|
|
lit.puts("yaml_empty")
|
|
else
|
|
return lit.setmeta(yaml)
|
|
end
|
|
else
|
|
lit.puts("yaml_invalid")
|
|
return nil
|
|
end
|
|
end
|
|
|
|
function lit.parseblock(parsed)
|
|
lit.puts("parsing", table.concat(parsed, ""):indent())
|
|
local yaml = lit.parseyaml(parsed[1])
|
|
-- TODO: parsecode
|
|
return "TODO"
|
|
end
|
|
|
|
function lit.getblock(codeblock)
|
|
local parsed = lpeg.match(lit.g.block, codeblock.text)
|
|
parsed = (parsed ~= nil and lit.parseblock(parsed) or parsed)
|
|
return codeblock, lit.status
|
|
end
|
|
|
|
function lit.getinsert(code)
|
|
return code, lit.status
|
|
end
|
|
|
|
return lit
|