vim-polyglot/autoload/vimtex/compiler/latexmk.vim

if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1

" vimtex - LaTeX plugin for Vim
"
" Maintainer: Karl Yngve Lervåg
" Email:      karl.yngve@gmail.com
"

function! vimtex#compiler#latexmk#init(options) abort " {{{1
  let l:compiler = deepcopy(s:compiler)

  call l:compiler.init(extend(a:options,
        \ get(g:, 'vimtex_compiler_latexmk', {}), 'keep'))

  return l:compiler
endfunction

" }}}1
function! vimtex#compiler#latexmk#wrap_option(name, value) abort " {{{1
  return has('win32')
        \ ? ' -e "$' . a:name . ' = ''' . a:value . '''"'
        \ : ' -e ''$' . a:name . ' = "' . a:value . '"'''
endfunction

"}}}1

function! vimtex#compiler#latexmk#get_rc_opt(root, opt, type, default) abort " {{{1
  "
  " Parse option from .latexmkrc.
  "
  " Arguments:
  "   root         Root of LaTeX project
  "   opt          Name of options
  "   type         0 if string, 1 if integer, 2 if list
  "   default      Value to return if option not found in latexmkrc file
  "
  " Output:
  "   [value, location]
  "
  "   value        Option value (integer or string)
  "   location     An integer that indicates where option was found
  "                 -1: not found (default value returned)
  "                  0: global latexmkrc file
  "                  1: local latexmkrc file
  "

  if a:type == 0
    let l:pattern = '^\s*\$' . a:opt . '\s*=\s*[''"]\(.\+\)[''"]'
  elseif a:type == 1
    let l:pattern = '^\s*\$' . a:opt . '\s*=\s*\(\d\+\)'
  elseif a:type == 2
    let l:pattern = '^\s*@' . a:opt . '\s*=\s*(\(.*\))'
  else
    throw 'vimtex: argument error'
  endif

  " Candidate files
  " - each element is a pair [path_to_file, is_local_rc_file].
  let l:files = [
        \ [a:root . '/latexmkrc', 1],
        \ [a:root . '/.latexmkrc', 1],
        \ [fnamemodify('~/.latexmkrc', ':p'), 0],
        \]
  if !empty($XDG_CONFIG_HOME)
    call add(l:files, [$XDG_CONFIG_HOME . '/latexmk/latexmkrc', 0])
  endif

  let l:result = [a:default, -1]

  for [l:file, l:is_local] in l:files
    if filereadable(l:file)
      let l:match = matchlist(readfile(l:file), l:pattern)
      if len(l:match) > 1
        let l:result = [l:match[1], l:is_local]
        break
      end
    endif
  endfor

  " Parse the list
  if a:type == 2 && l:result[1] > -1
    let l:array = split(l:result[0], ',')
    let l:result[0] = []
    for l:x in l:array
      let l:x = substitute(l:x, "^'", '', '')
      let l:x = substitute(l:x, "'$", '', '')
      let l:result[0] += [l:x]
    endfor
  endif

  return l:result
endfunction

" }}}1

let s:compiler = {
      \ 'name' : 'latexmk',
      \ 'executable' : 'latexmk',
      \ 'backend' : has('nvim') ? 'nvim'
      \                         : v:version >= 800 ? 'jobs' : 'process',
      \ 'root' : '',
      \ 'target' : '',
      \ 'target_path' : '',
      \ 'background' : 1,
      \ 'build_dir' : '',
      \ 'callback' : 1,
      \ 'continuous' : 1,
      \ 'output' : tempname(),
      \ 'options' : [
      \   '-verbose',
      \   '-file-line-error',
      \   '-synctex=1',
      \   '-interaction=nonstopmode',
      \ ],
      \ 'hooks' : [],
      \ 'shell' : fnamemodify(&shell, ':t'),
      \}

function! s:compiler.init(options) abort dict " {{{1
  call extend(self, a:options)

  call self.init_check_requirements()
  call self.init_build_dir_option()
  call self.init_pdf_mode_option()

  call extend(self, deepcopy(s:compiler_{self.backend}))

  " Continuous processes can't run in foreground, neither can processes run
  " with the new jobs api
  if self.continuous || self.backend !=# 'process'
    let self.background = 1
  endif

  if self.backend !=# 'process'
    let self.shell = 'sh'
  endif
endfunction

" }}}1
function! s:compiler.init_build_dir_option() abort dict " {{{1
  "
  " Check if .latexmkrc sets the build_dir - if so this should be respected
  "
  let l:out_dir =
        \ vimtex#compiler#latexmk#get_rc_opt(self.root, 'out_dir', 0, '')[0]

  if !empty(l:out_dir)
    if !empty(self.build_dir) && (self.build_dir !=# l:out_dir)
      call vimtex#log#warning(
            \ 'Setting out_dir from latexmkrc overrides build_dir!',
            \ 'Changed build_dir from: ' . self.build_dir,
            \ 'Changed build_dir to: ' . l:out_dir)
    endif
    let self.build_dir = l:out_dir
  endif
endfunction

" }}}1
function! s:compiler.init_pdf_mode_option() abort dict " {{{1
  " If the TeX program directive was not set, and if the pdf_mode is set in
  " a .latexmkrc file, then deduce the compiler engine from the value of
  " pdf_mode.

  " Parse the pdf_mode option. If not found, it is set to -1.
  let [l:pdf_mode, l:is_local] =
        \ vimtex#compiler#latexmk#get_rc_opt(self.root, 'pdf_mode', 1, -1)

  " If pdf_mode has a supported value (1: pdflatex, 4: lualatex, 5: xelatex),
  " override the value of self.tex_program.
  if l:pdf_mode == 1
    let l:tex_program = 'pdflatex'
  elseif l:pdf_mode == 3
    let l:tex_program = 'pdfdvi'
  elseif l:pdf_mode == 4
    let l:tex_program = 'lualatex'
  elseif l:pdf_mode == 5
    let l:tex_program = 'xelatex'
  else
    return
  endif

  if self.tex_program ==# '_'
    " The TeX program directive was not specified
    let self.tex_program = l:tex_program
  elseif l:is_local && self.tex_program !=# l:tex_program
    call vimtex#log#warning(
          \ 'Value of pdf_mode from latexmkrc is inconsistent with ' .
          \ 'TeX program directive!',
          \ 'TeX program: ' . self.tex_program,
          \ 'pdf_mode:    ' . l:tex_program,
          \ 'The value of pdf_mode will be ignored.')
  endif
endfunction

" }}}1
function! s:compiler.init_check_requirements() abort dict " {{{1
  " Check option validity
  if self.callback
    if !(has('clientserver') || has('nvim') || has('job'))
      let self.callback = 0
      call vimtex#log#warning(
            \ 'Can''t use callbacks without +job, +nvim, or +clientserver',
            \ 'Callback option has been disabled.')
    endif
  endif

  " Check for required executables
  let l:required = [self.executable]
  if self.continuous && !(has('win32') || has('win32unix'))
    let l:required += ['pgrep']
  endif
  let l:missing = filter(l:required, '!executable(v:val)')

  " Disable latexmk if required programs are missing
  if len(l:missing) > 0
    for l:cmd in l:missing
      call vimtex#log#warning(l:cmd . ' is not executable')
    endfor
    throw 'vimtex: Requirements not met'
  endif
endfunction

" }}}1

function! s:compiler.build_cmd() abort dict " {{{1
  if has('win32')
    let l:cmd = 'set max_print_line=2000 & ' . self.executable
  else
    if self.shell ==# 'fish'
      let l:cmd = 'set max_print_line 2000; and ' . self.executable
    else
      let l:cmd = 'max_print_line=2000 ' . self.executable
    endif
  endif

  for l:opt in self.options
    let l:cmd .= ' ' . l:opt
  endfor

  let l:cmd .= ' ' . self.get_engine()

  if !empty(self.build_dir)
    let l:cmd .= ' -outdir=' . fnameescape(self.build_dir)
  endif

  if self.continuous
    let l:cmd .= ' -pvc'

    " Set viewer options
    if !get(g:, 'vimtex_view_automatic', 1)
          \ || get(get(b:vimtex, 'viewer', {}), 'xwin_id') > 0
          \ || get(s:, 'silence_next_callback', 0)
      let l:cmd .= ' -view=none'
    elseif g:vimtex_view_enabled
          \ && has_key(b:vimtex.viewer, 'latexmk_append_argument')
      let l:cmd .= b:vimtex.viewer.latexmk_append_argument()
    endif

    if self.callback
      if has('job') || has('nvim')
        for [l:opt, l:val] in items({
              \ 'success_cmd' : 'vimtex_compiler_callback_success',
              \ 'failure_cmd' : 'vimtex_compiler_callback_failure',
              \})
          let l:func = 'echo ' . l:val
          let l:cmd .= vimtex#compiler#latexmk#wrap_option(l:opt, l:func)
        endfor
      elseif empty(v:servername)
        call vimtex#log#warning('Can''t use callbacks with empty v:servername')
      else
        " Some notes:
        " - We excape the v:servername because this seems necessary on Windows
        "   for neovim, see e.g. Github Issue #877
        for [l:opt, l:val] in items({'success_cmd' : 1, 'failure_cmd' : 0})
          let l:callback = has('win32')
                \   ? '"vimtex#compiler#callback(' . l:val . ')"'
                \   : '\"vimtex\#compiler\#callback(' . l:val . ')\"'
          let l:func = vimtex#util#shellescape('""')
                \ . g:vimtex_compiler_progname
                \ . vimtex#util#shellescape('""')
                \ . ' --servername ' . vimtex#util#shellescape(v:servername)
                \ . ' --remote-expr ' . l:callback
          let l:cmd .= vimtex#compiler#latexmk#wrap_option(l:opt, l:func)
        endfor
      endif
    endif
  endif

  return l:cmd . ' ' . vimtex#util#shellescape(self.target)
endfunction

" }}}1
function! s:compiler.get_engine() abort dict " {{{1
  return get(extend(g:vimtex_compiler_latexmk_engines,
        \ {
        \  'pdfdvi'           : '-pdfdvi',
        \  'pdflatex'         : '-pdf',
        \  'luatex'           : '-lualatex',
        \  'lualatex'         : '-lualatex',
        \  'xelatex'          : '-xelatex',
        \  'context (pdftex)' : '-pdf -pdflatex=texexec',
        \  'context (luatex)' : '-pdf -pdflatex=context',
        \  'context (xetex)'  : '-pdf -pdflatex=''texexec --xtx''',
        \ }, 'keep'), self.tex_program, '-pdf')
endfunction

" }}}1
function! s:compiler.cleanup() abort dict " {{{1
  if self.is_running()
    call self.kill()
  endif
endfunction

" }}}1
function! s:compiler.pprint_items() abort dict " {{{1
  let l:configuration = [
        \ ['continuous', self.continuous],
        \ ['callback', self.callback],
        \]

  if self.backend ==# 'process' && !self.continuous
    call add(l:configuration, ['background', self.background])
  endif

  if !empty(self.build_dir)
    call add(l:configuration, ['build_dir', self.build_dir])
  endif
  call add(l:configuration, ['latexmk options', self.options])
  call add(l:configuration, ['latexmk engine', self.get_engine()])

  let l:list = []
  call add(l:list, ['backend', self.backend])
  if self.executable !=# s:compiler.executable
    call add(l:list, ['latexmk executable', self.executable])
  endif
  if self.background
    call add(l:list, ['output', self.output])
  endif

  if self.target_path !=# b:vimtex.tex
    call add(l:list, ['root', self.root])
    call add(l:list, ['target', self.target_path])
  endif

  call add(l:list, ['configuration', l:configuration])

  if has_key(self, 'process')
    call add(l:list, ['process', self.process])
  endif

  if has_key(self, 'job')
    if self.continuous
      if self.backend ==# 'jobs'
        call add(l:list, ['job', self.job])
      else
        call add(l:list, ['pid', self.get_pid()])
      endif
    endif
    call add(l:list, ['cmd', self.cmd])
  endif

  return l:list
endfunction

" }}}1

function! s:compiler.clean(full) abort dict " {{{1
  let l:restart = self.is_running()
  if l:restart
    call self.stop()
  endif

  " Define and run the latexmk clean cmd
  let l:cmd = (has('win32')
        \   ? 'cd /D "' . self.root . '" & '
        \   : 'cd ' . vimtex#util#shellescape(self.root) . '; ')
        \ . self.executable . ' ' . (a:full ? '-C ' : '-c ')
  if !empty(self.build_dir)
    let l:cmd .= printf(' -outdir=%s ', fnameescape(self.build_dir))
  endif
  let l:cmd .= vimtex#util#shellescape(self.target)
  call vimtex#process#run(l:cmd)

  call vimtex#log#info('Compiler clean finished' . (a:full ? ' (full)' : ''))

  if l:restart
    let self.silent_next_callback = 1
    silent call self.start()
  endif
endfunction

" }}}1
function! s:compiler.start(...) abort dict " {{{1
  if self.is_running()
    call vimtex#log#warning(
          \ 'Compiler is already running for `' . self.target . "'")
    return
  endif

  "
  " Create build dir if it does not exist
  "
  if !empty(self.build_dir)
    let l:dirs = split(glob(self.root . '/**/*.tex'), '\n')
    call map(l:dirs, 'fnamemodify(v:val, '':h'')')
    call map(l:dirs, 'strpart(v:val, strlen(self.root) + 1)')
    call vimtex#util#uniq(sort(filter(l:dirs, "v:val !=# ''")))
    call map(l:dirs,
          \ (vimtex#paths#is_abs(self.build_dir) ? '' : "self.root . '/' . ")
          \ . "self.build_dir . '/' . v:val")
    call filter(l:dirs, '!isdirectory(v:val)')

    " Create the non-existing directories
    for l:dir in l:dirs
      call mkdir(l:dir, 'p')
    endfor
  endif

  call self.exec()

  if self.continuous
    call vimtex#log#info('Compiler started in continuous mode'
          \ . (a:0 > 0 ? ' (single shot)' : ''))
    if exists('#User#VimtexEventCompileStarted')
      doautocmd <nomodeline> User VimtexEventCompileStarted
    endif
  else
    if self.background
      call vimtex#log#info('Compiler started in background!')
    else
      call vimtex#compiler#callback(!vimtex#qf#inquire(self.target))
    endif
  endif
endfunction

" }}}1
function! s:compiler.stop() abort dict " {{{1
  if self.is_running()
    call self.kill()
    call vimtex#log#info('Compiler stopped (' . self.target . ')')
    if exists('#User#VimtexEventCompileStopped')
      doautocmd <nomodeline> User VimtexEventCompileStopped
    endif
  else
    call vimtex#log#warning(
          \ 'There is no process to stop (' . self.target . ')')
  endif
endfunction

" }}}1

let s:compiler_process = {}
function! s:compiler_process.exec() abort dict " {{{1
  let l:process = vimtex#process#new()
  let l:process.name = 'latexmk'
  let l:process.continuous = self.continuous
  let l:process.background = self.background
  let l:process.workdir = self.root
  let l:process.output = self.output
  let l:process.cmd = self.build_cmd()

  if l:process.continuous
    if (has('win32') || has('win32unix'))
      " Not implemented
    else
      for l:pid in split(system(
            \ 'pgrep -f "^[^ ]*perl.*latexmk.*' . self.target . '"'), "\n")
        let l:path = resolve('/proc/' . l:pid . '/cwd') . '/' . self.target
        if l:path ==# self.target_path
          let l:process.pid = str2nr(l:pid)
          break
        endif
      endfor
    endif
  endif

  function! l:process.set_pid() abort dict " {{{2
    if (has('win32') || has('win32unix'))
      let pidcmd = 'tasklist /fi "imagename eq latexmk.exe"'
      let pidinfo = vimtex#process#capture(pidcmd)[-1]
      let self.pid = str2nr(split(pidinfo,'\s\+')[1])
    else
      let self.pid = str2nr(system('pgrep -nf "^[^ ]*perl.*latexmk"')[:-2])
    endif

    return self.pid
  endfunction

  " }}}2

  let self.process = l:process
  call self.process.run()
endfunction

" }}}1
function! s:compiler_process.start_single() abort dict " {{{1
  let l:continuous = self.continuous
  let self.continuous = self.background && self.callback && !empty(v:servername)

  if self.continuous
    let g:vimtex_compiler_callback_hooks += ['VimtexSSCallback']
    function! VimtexSSCallback(status) abort
      silent call vimtex#compiler#stop()
      call remove(g:vimtex_compiler_callback_hooks, 'VimtexSSCallback')
    endfunction
  endif

  call self.start(1)
  let self.continuous = l:continuous
endfunction

" }}}1
function! s:compiler_process.is_running() abort dict " {{{1
  return exists('self.process.pid') && self.process.pid > 0
endfunction

" }}}1
function! s:compiler_process.kill() abort dict " {{{1
  call self.process.stop()
endfunction

" }}}1
function! s:compiler_process.get_pid() abort dict " {{{1
  return has_key(self, 'process') ? self.process.pid : 0
endfunction

" }}}1

let s:compiler_jobs = {}
function! s:compiler_jobs.exec() abort dict " {{{1
  let self.cmd = self.build_cmd()
  let l:cmd = has('win32')
        \ ? 'cmd /s /c "' . self.cmd . '"'
        \ : ['sh', '-c', self.cmd]

  let l:options = {
        \ 'out_io' : 'file',
        \ 'err_io' : 'file',
        \ 'out_name' : self.output,
        \ 'err_name' : self.output,
        \}
  if self.continuous
    let l:options.out_io = 'pipe'
    let l:options.err_io = 'pipe'
    let l:options.out_cb = function('s:callback_continuous_output')
    let l:options.err_cb = function('s:callback_continuous_output')
    call writefile([], self.output, 'a')
  else
    let s:cb_target = self.target_path !=# b:vimtex.tex
          \ ? self.target_path : ''
    let l:options.exit_cb = function('s:callback')
  endif

  call vimtex#paths#pushd(self.root)
  let self.job = job_start(l:cmd, l:options)
  call vimtex#paths#popd()
endfunction

" }}}1
function! s:compiler_jobs.start_single() abort dict " {{{1
  let l:continuous = self.continuous
  let self.continuous = 0
  call self.start()
  let self.continuous = l:continuous
endfunction

" }}}1
function! s:compiler_jobs.kill() abort dict " {{{1
  call job_stop(self.job)
endfunction

" }}}1
function! s:compiler_jobs.is_running() abort dict " {{{1
  return has_key(self, 'job') && job_status(self.job) ==# 'run'
endfunction

" }}}1
function! s:compiler_jobs.get_pid() abort dict " {{{1
  return has_key(self, 'job')
        \ ? get(job_info(self.job), 'process') : 0
endfunction

" }}}1
function! s:callback(ch, msg) abort " {{{1
  call vimtex#compiler#callback(!vimtex#qf#inquire(s:cb_target))
endfunction

" }}}1
function! s:callback_continuous_output(channel, msg) abort " {{{1
  if exists('b:vimtex') && filewritable(b:vimtex.compiler.output)
    call writefile([a:msg], b:vimtex.compiler.output, 'a')
  endif

  if a:msg ==# 'vimtex_compiler_callback_success'
    call vimtex#compiler#callback(1)
  elseif a:msg ==# 'vimtex_compiler_callback_failure'
    call vimtex#compiler#callback(0)
  endif

  try
    for l:Hook in get(get(get(b:, 'vimtex', {}), 'compiler', {}), 'hooks', [])
      call l:Hook(a:msg)
    endfor
  catch /E716/
  endtry
endfunction

" }}}1

let s:compiler_nvim = {}
function! s:compiler_nvim.exec() abort dict " {{{1
  let self.cmd = self.build_cmd()
  let l:cmd = has('win32')
        \ ? 'cmd /s /c "' . self.cmd . '"'
        \ : ['sh', '-c', self.cmd]

  let l:shell = {
        \ 'on_stdout' : function('s:callback_nvim_output'),
        \ 'on_stderr' : function('s:callback_nvim_output'),
        \ 'cwd' : self.root,
        \ 'target' : self.target_path,
        \ 'output' : self.output,
        \}

  if !self.continuous
    let l:shell.on_exit = function('s:callback_nvim_exit')
  endif

  " Initialize output file
  try
    call writefile([], self.output)
  endtry

  let self.job = jobstart(l:cmd, l:shell)
endfunction

" }}}1
function! s:compiler_nvim.start_single() abort dict " {{{1
  let l:continuous = self.continuous
  let self.continuous = 0
  call self.start()
  let self.continuous = l:continuous
endfunction

" }}}1
function! s:compiler_nvim.kill() abort dict " {{{1
  call jobstop(self.job)
endfunction

" }}}1
function! s:compiler_nvim.is_running() abort dict " {{{1
  try
    let pid = jobpid(self.job)
    return 1
  catch
    return 0
  endtry
endfunction

" }}}1
function! s:compiler_nvim.get_pid() abort dict " {{{1
  try
    return jobpid(self.job)
  catch
    return 0
  endtry
endfunction

" }}}1
function! s:callback_nvim_output(id, data, event) abort dict " {{{1
  " Filter out unwanted newlines
  let l:data = split(substitute(join(a:data, 'QQ'), '^QQ\|QQ$', '', ''), 'QQ')

  if !empty(l:data) && filewritable(self.output)
    call writefile(l:data, self.output, 'a')
  endif

  if match(a:data, 'vimtex_compiler_callback_success') != -1
    call vimtex#compiler#callback(!vimtex#qf#inquire(self.target))
  elseif match(a:data, 'vimtex_compiler_callback_failure') != -1
    call vimtex#compiler#callback(0)
  endif

  try
    for l:Hook in get(get(get(b:, 'vimtex', {}), 'compiler', {}), 'hooks', [])
      call l:Hook(join(a:data, "\n"))
    endfor
  catch /E716/
  endtry
endfunction

" }}}1
function! s:callback_nvim_exit(id, data, event) abort dict " {{{1
  let l:target = self.target !=# b:vimtex.tex ? self.target : ''
  call vimtex#compiler#callback(!vimtex#qf#inquire(l:target))
endfunction

" }}}1

endif