Automatically detect vimtex_compiler_method (for arara)

[mizhozan]

I would like to suggest a feature enhancement for the vimtex plugin. By default, I prefer using latexmk as the compiler method. However, for certain larger projects, I find it more suitable to use arara, as it is specified in top of the main .tex file.

Ideally, I would like the vimtex_compiler_method to remain as latexmk by default, but automatically switch to arara when the main .tex file indicates its use.

As an alternative solution, I believe it may be possible to achieve this behavior using a small Vim function or script that runs on .tex files and detects the presence of arara. However, the challenge lies in accurately detecting the main .tex file, a task which vimtex already handles effectively. If this doesn't worth a feature-request, I would appreciate guidance on utilizing Vimtex's built-in functions for a possible script.

Something like this:

function! SetCompilerMethod()
    let mainFile = vimtex#main#find()

    if mainFile !=# '' && filereadable(mainFile)
        let firstFiveLines = getline(1, 5)

        for line in firstFiveLines
            if line =~# '^%!\s*arara'
                let g:vimtex_compiler_method = 'arara'
                return
            endif
        endfor
    endif
endfunction

[lervag]

Ideally, I would like the vimtex_compiler_method to remain as latexmk by default, but automatically switch to arara when the main .tex file indicates its use.

This is an interesting idea. Currently, the vimtex_compiler_method option is only used in the private s:init_compiler function to specify the compiler method:

vimtex/autoload/vimtex/compiler.vim

Lines 314 to 336 in 02dcc7c

	function! s:init_compiler(options) abort " {{{1
	if index([
	\ 'arara',
	\ 'generic',
	\ 'latexmk',
	\ 'latexrun',
	\ 'tectonic',
	\], g:vimtex_compiler_method) < 0
	call vimtex#log#error(
	\ 'Error! Invalid g:vimtex_compiler_method: '
	\ . g:vimtex_compiler_method)
	let g:vimtex_compiler_method = 'latexmk'
	endif
	let l:options =
	\ get(g:, 'vimtex_compiler_' . g:vimtex_compiler_method, {})
	let l:options = extend(deepcopy(l:options), a:options)
	let l:compiler
	\ = vimtex#compiler#{g:vimtex_compiler_method}#init(l:options)
	return l:compiler
	endfunction
	" }}}1

So, what you want is something like this:

function! s:init_compiler(options) abort " {{{1
  let l:method = GET_METHOD(a:options.state)
  if empty(l:method)
    let l:method = g:vimtex_compiler_method
  endif

  if index([
        \ 'arara',
        \ 'generic',
        \ 'latexmk',
        \ 'latexrun',
        \ 'tectonic',
        \], l:method) < 0
    call vimtex#log#error(
          \ 'Error! Invalid compiler method: '
          \ . l:method)
    let l:method = 'latexmk'
  endif

  " …

where GET_METHOD will parse the current file preamble to detect the desired compiler method. If no method is found, we use g:vimtex_compiler_method as the fallback method.

I believe we have some choices here. First, GET_METHOD could simply be a user defined function. This means the user would need to implement the logic themselves. For power users, this would be very flexible. E.g. as in your suggestion, something like this would work:

function! GET_METHOD(state)
  if !filereadable(a:state.tex) | return '' | endif

  for line in readfile(a:state.tex, '', 5)
    if line =~# '^%!\s*arara'
      return 'arara'
    endif
  endfor

  return ''
endfunction

As an alternative solution, I believe it may be possible to achieve this behavior using a small Vim function or script that runs on .tex files and detects the presence of arara. However, the challenge lies in accurately detecting the main .tex file, a task which vimtex already handles effectively. If this doesn't worth a feature-request, I would appreciate guidance on utilizing Vimtex's built-in functions for a possible script.

An important challenge with this is that you need to run your script/function before VimTeX is initialized for the current project. But yes, if you did that, then you would be able to do what you are thinking. But I don't think it is immediately possible with VimTeX APIs now, because the state data such as file paths are created during initialization.

But I think we can build on my above mentioned idea.

[lervag]

So, the main question is how to add the user facing interface here. I don't like new options. Perhaps another option is to allow g:vimtex_compiler_method to be either 1) a string (same behaviour as today) or 2) a function that should resolve to a string (the desired method). E.g., a very quick doc draft:

*g:vimtex_compiler_method*
  Set the compiler method either explicity as a |String| or dynamically as
  a |Funcref|. The latter needs to be a function that takes a single string
  argument (the path to the main TeX file) and returns the desired method as
  a |String|.

  Using a |Funcref| allows  a lot of flexibility in the choice of compiler
  method. E.g., one could use `arara` for files that have `arara`
  specifications at the top and fall back to `latexmk` for all other files: >vim

    function! SetCompilerMethod(mainfile)
      if filereadable(a:mainfile)
        for line in readfile(a:mainfile, '', 5)
          if line =~# '^%!\s*arara'
            return 'arara'
          endif
        endfor
      endif

      return 'latexmk'
    endfunction

< The available compiler method choices are:

    Value      Documentation              Configuration ~
    `latexmk`    |vimtex-compiler-latexmk|    |g:vimtex_compiler_latexmk|
    `latexrun`   |vimtex-compiler-latexrun|   |g:vimtex_compiler_latexrun|
    `tectonic`   |vimtex-compiler-tectonic|   |g:vimtex_compiler_tectonic|
    `arara`      |vimtex-compiler-arara|      |g:vimtex_compiler_arara|
    `generic`    |vimtex-compiler-generic|    |g:vimtex_compiler_generic|

  Default value: `'latexmk'`

[lervag]

I believe #2721 should work already., but it is still very much WIP. I'll continue later when I have the time.

[lervag]

Let me know if you find #2721 sufficient here. I believe it should allow what you want.

[mizhozan]

Wow, this #2722 is truly amazing and works flawlessly. I believe the exclamation mark (!) might be unnecessary in the matching pattern ('^%!\s*arara')—if I understand correctly. Regardless, I simply removed it, and the Vimtex for Vim worked as expected.

function! SetCompilerMethod(mainfile)
  if filereadable(a:mainfile)
    for line in readfile(a:mainfile, '', 5)
      if line =~# '^%\s*arara'
        return 'arara'
      endif
    endfor
  endif

  return 'latexmk'
endfunction
let g:vimtex_compiler_method = 'SetCompilerMethod'

I hope to see this in master branch soon, though!

---

Just for documentation purposes here, I couldn't get it to work in Neovim with an autogenerated lua equivalent, possibly due to my lack of knowledge in Lua (one problem was mainfile never set and it just skip the if clause to latexmk). However, since I primarily use Vim, it's not a problem for me personally.

function SetCompilerMethod(mainfile)
  if vim.fn.filereadable(mainfile) == 1 then
    local lines = vim.fn.readfile(mainfile, '', 5)
    for _, line in ipairs(lines) do
      if string.match(line, '^.*arara') then
        return 'arara'
      end
    end
  end

  return 'latexmk'
end


vim.g.vimtex_compiler_method = SetCompilerMethod()

[lervag]

Wow, this #2722 is truly amazing and works flawlessly.

Thanks! I'm glad you like it :)

I believe the exclamation mark (!) might be unnecessary in the matching pattern ('^%!\s*arara')—if I understand correctly.

Yes, you are right - I fixed the docs before merging.

I hope to see this in master branch soon, though!

Done!

Just for documentation purposes here, I couldn't get it to work in Neovim with an autogenerated lua equivalent, …

I think the error is that you want to set the option to the function, not to the result of running the function. Thus, you would want something like this:

vim.g.vimtex_compiler_method = function(mainfile)
  if vim.fn.filereadable(mainfile) == 1 then
    local lines = vim.fn.readfile(mainfile, '', 5)
    for _, line in ipairs(lines) do
      if string.match(line, '^.*arara') then
        return 'arara'
      end
    end
  end

  return 'latexmk'
end

[mizhozan]

Confirmed! It work smoothly in both vim/neovim on linux.