---library for `texdef` and `latexdef`
---@module texdef
---@copyright 2025
local lfs = require 'lfs'
local tex = require 'tex'
local kpse = require 'kpse'
local texrocks = require 'texrocks'
local argparse = require 'argparse'
local template = require 'template'
local M = {}

---get parser
---@param name string program name
---@param fmt string TeX format name
---@return table parser
function M.get_parser(name, fmt)
   local parser = argparse(name):add_complete()
   parser:argument('macro', 'macro name without \\'):args('*')
   parser:option('--value -v', [[Show value of \the\macro instead]]):args(0)
   if fmt:match 'latex' then
       parser:option('--list -l', 'List all command sequences of the given packages by -l, -ll'):args(0):count("*")
       parser:option('--find -f', 'Show full filepath of the file where the command sequence was defined by -f, -ff')
           :args(0):count("*")
       parser:option('--ignore-regex -I', 'Ignore all command sequences in the above lists which match lua match()',
           '[@_]')
       parser:option('--Environment -E', 'Every command name is taken as an environment name'):args(0)
       parser:option('--class -c', 'class name', 'article')
       parser:option('--package -p', 'package name'):count("*")
       parser:option('--environment -e', 'environment name'):count("*")
       parser:option('--othercode -o', 'Add other code into the preamble before the definition is shown'):count("*")
       parser:option('--preamble -P', 'Show definition of the command inside the preamble'):args(0)
       parser:option('--beforeclass -B', [[Show definition of the command before \documentclass]]):args(0)
   end
   parser:option('--before -b', 'Place code before definition is shown'):count("*")
   parser:option('--after -a', 'Place code after definition is shown'):count("*")

   parser:option('--dry-run -n', 'Do not run'):args(0)
   parser:option('--output', 'output file name', tex.jobname .. '.tex')
   parser:option('--entering', 'entering file prompt', '>> entering file ')
   parser:option('--leaving', 'leaving file prompt', '<< leaving file ')
   parser:option('--defined', 'defined prompt', ': defined by ')
   return parser
end

---parse command line arguments
---@param args string[] command line arguments
---@return table cmd_args parsed result
function M.parse(args)
   local cmd_args = texrocks.preparse(args)
   local parser = M.get_parser(cmd_args[0], tex.formatname)
   cmd_args = parser:parse(cmd_args)
   return M.postparse(cmd_args)
end

---change some values by command line arguments
---@param args table parsed result
---@return table cmd_args processed result
function M.postparse(args)
   if args.ignore_regex == '' then
       args.ignore_regex = '$^'
   end
   if args.class and args.class:sub(#args.class, #args.class) ~= '}' then
       args.class = '{' .. args.class .. '}'
   end
   if args.package then
       for i, pkg in ipairs(args.package) do
           if pkg:sub(#pkg, #pkg) ~= '}' then
               args.package[i] = '{' .. args.package[i] .. '}'
           end
       end
   end
   if args.environment then
       for i, pkg in ipairs(args.environment) do
           if pkg:sub(#pkg, #pkg) ~= '}' then
               args.environment[i] = '{' .. args.environment[i] .. '}'
           end
       end
   end
   if args.Environment then
       for i = 1, #args.macro do
           table.insert(args.macro, 'end' .. args.macro[i])
       end
   end
   args.fmt = tex.formatname .. '.fmt'
   args.list = args.list or 0
   args.find = args.find or 0
   args.sub = M.get_path('texdef/sub.tex')
   args.ipairs = ipairs
   return args
end

---wrap `tex.print()`
---@param code string TeX code
function M.print(code)
   code = code:gsub('^%s+', ''):gsub("%.*\n", ""):gsub("\n", "")
   tex.print(code)
end

---get path of template
---https://github.com/nvim-neorocks/lux/issues/922
---@param filename string template name
---@return string file template path
function M.get_path(filename)
   local root = debug.getinfo(1).source:match("@?(.*)/")
   local file = root .. '/' .. filename
   if not lfs.isfile(file) then
       file = lfs.currentdir() .. '/lua/' .. filename
   end
   return file
end

---**first entry for texdef and latexdef**
---@param args string[] command line arguments
---@return table | nil cmd_args parsed command line arguments
function M.main(args)
   print()
   local cmd_args = M.parse(args)
   local code = template.render(M.get_path('texdef/main.tex'), cmd_args)
   if cmd_args.dry_run then
       print(code)
       return
   end
   local output = cmd_args.output
   if cmd_args.list > 0 then
       output = tex.jobname .. '.log'
   end
   cmd_args.f = io.open('.lux/' .. output, 'w+')
   if cmd_args.f then
       M.print(code)
   end
   return cmd_args
end

---replace package names with their full paths
---@param text string
---@param defined string
---@return string text
function M.replace(text, defined)
   local paths = {}
   for file in text:gmatch(defined .. '(%S+)') do
       paths[file] = kpse.lookup(file)
   end
   for file, path in pairs(paths) do
       text = text:gsub(defined .. file, defined .. path)
   end
   return text
end

---@alias cs {type: '=' | '->' | '-->', value: string}
---@alias pkg table<string, cs>
---@alias log table<string, pkg>
---extract packages' macros' information from log
---one log contains many packages, one package contains many control sequences
---control sequence can be `k = v`, `k -> v` (macro), `k --> v` (long macro)
---@param f table log file handler
---@param entering string entering prompt
---@param leaving string leaving prompt
---@return log log
function M.parse_log(f, entering, leaving)
   local log = {}
   local pkg_names = {}
   local pkg_name

   for line in f:lines() do
       if line:match(entering) then
           pkg_name = line:gsub(entering, '')
           table.insert(pkg_names, pkg_name)
           log[pkg_name] = {}
       elseif pkg_name and line:match(leaving .. pkg_name) then
           table.remove(pkg_names)
           pkg_name = table.remove(pkg_names)
           if pkg_name then
               table.insert(pkg_names, pkg_name)
           end
       elseif pkg_name and (line:sub(2):match('^into ') or line:sub(2):match('^reassigning ')) then
           line = line:sub(2, #line - 1):gsub("^%S+ ", ""):gsub("\\ETC%.", "..."):gsub(
               'used in a moving argument.', '(moving)')
           local cs_name = line:match("^[^=]+")
           local cs = {
               type = '=',
               value = line:gsub("[^=]+=", ""),
           }
           if cs.value:match("^\\long macro:") then
               cs.type = '-->'
               cs.value = cs.value:gsub("^\\long macro:", "")
           elseif cs.value:match("^macro:") then
               cs.type = '->'
               cs.value = cs.value:gsub("^macro:", "")
           end
           if cs.type ~= '=' then
               local name = cs.value:gsub("%s*->.*", "")
               cs_name = cs_name .. name
               cs.value = cs.value:gsub(name .. '%s*->', "")
           end
           log[pkg_name][cs_name] = cs
       end
   end
   return log
end

---filter log by regex
---@param log log
---@param regex string
---@return log log
function M.filter(log, regex)
   for pkg_name, pkg in pairs(log) do
       for cs_name, _ in pairs(pkg) do
           if cs_name:match(regex) then
               log[pkg_name][cs_name] = nil
           end
       end
   end
   return log
end

---sort dictionary's keys
---@param input table
---@return table names
function M.get_sorted_keys(input)
   local names = {}
   for name, _ in pairs(input) do
       table.insert(names, name)
   end
   table.sort(names)
   return names
end

---sort log and dump output
---@param log log
---@param is_detailed boolean if print control sequences' values
---@return string text
function M.dump(log, is_detailed)
   local pkg_names = M.get_sorted_keys(log)
   local lines = {}
   for _, pkg_name in ipairs(pkg_names) do
       local pkg = log[pkg_name]
       local cs_names = M.get_sorted_keys(pkg)
       local sublines = {}
       for _, cs_name in ipairs(cs_names) do
           local cs = pkg[cs_name]
           local line = cs_name
           if is_detailed then
               line = line .. ' ' .. cs.type .. ' ' .. cs.value
           end
           table.insert(sublines, line)
       end
       if #cs_names ~= 0 then
           table.insert(lines, pkg_name)
           table.insert(lines, table.concat(sublines, "\n"))
       end
   end
   return table.concat(lines, "\n\n")
end

---**final entry for texdef and latexdef**
---@param args table parsed command line arguments
function M.output(args)
   if args == nil or args.f == nil then
       return
   end
   local text
   if args.list ~= 0 then
       local log = M.parse_log(args.f, args.entering, args.leaving)
       log = M.filter(log, args.ignore_regex)
       text = M.dump(log, args.list > 1)
   else
       text = args.f:read("*a"):gsub('=\n', ' = '):gsub('= macro:%->', '-> ')
       if args.find > 1 then
           text = M.replace(text, args.defined)
       end
   end
   print(text)
   args.f:close()
end

return M

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.