Rmd files

[arnold-c]

Really enjoying learning Neovim, and this plugin has been a big help in trying to make the transition smooth. Unfortunately, though, I still need to use Rmd files on occasion, as there are some things that can't be done with Quarto just yet. I was therefore wondering if it is possible to activate the quarto-nvim/otter plugins when in an Rmd file?

One of the big benefits would also be the easy integration with vim-slime, as qmd files handle paragraphs nicely, which unfortunately isn't the case in Rmd files. I appreciate the Nvim-R plugin exists, but if I can avoid installing another plugin that seems cleaner due to less duplication of plugin functionality (though I also understand if that is the best way forward for the moment).

Thanks,
Callum

[jmbuhr]

Yes, that should be possible. Here are the things you'll want to look out for:

• set the delimiter for vim-slime in Rmd like in qmd (https://github.com/jmbuhr/quarto-nvim-kickstarter/blob/1f2a4416b663a91ca59540f3d7abc73e7b1caeb1/ftplugin/quarto.lua#L1)
• Likewise, add something like this to the rmd filetype file: https://github.com/quarto-dev/quarto-nvim/blob/main/ftplugin/quarto.lua
• make sure that any language servers that may attach to rmd files use a on_attach function that does not overwrite the keyboard shortcuts for otter.nvim functions that you set in the previous step.
  e.g. on_attach2 here:
  https://github.com/jmbuhr/quarto-nvim-kickstarter/blob/1f2a4416b663a91ca59540f3d7abc73e7b1caeb1/lua/plugins/quarto.lua#L191

[arnold-c]

Amazing! Thanks. That worked perfectly!

[arnold-c]

In case anyone gets stuck, here's what I have that is currently working with qmd, rmd, and julia scripts (though, as I say, I'm only a few days into Neovim and lua, so it's possible I've done something wrong regarding the ftplugins)

• Largely the suggested plugin layouts from the quarto nvim kickstarter, but everything in it's own file for easier management.

`ftplugin/rmd.lua`

vim.b.slime_cell_delimiter = "```"

-- wrap text, but by word not character
-- indent the wrappped line
vim.wo.wrap = true
vim.wo.linebreak = true
vim.wo.breakindent = true
vim.wo.showbreak = '|'

local q = require'quarto'
if q.config.lspFeatures.enabled and vim.bo.buftype ~= 'terminal' then
    local function buf_set_keymap(...)
        vim.api.nvim_buf_set_keymap(...)
    end
    local function buf_set_option(...)
        vim.api.nvim_buf_set_option(...)
    end
    local opts = { silent = true }

    q.activate()

    buf_set_keymap(0, 'n', q.config.keymap.definition, ":lua require'otter'.ask_definition()<cr>", opts)
    buf_set_keymap(0, 'n', q.config.keymap.type_definition, ":lua require'otter'.ask_type_definition()<cr>", opts)
    buf_set_keymap(0, 'n', q.config.keymap.hover, ":lua require'otter'.ask_hover()<cr>", opts)
    buf_set_keymap(0, 'n', q.config.keymap.rename, ":lua require'otter'.ask_rename()<cr>", opts)
    buf_set_keymap(0, 'n', q.config.keymap.references, ":lua require'otter'.ask_references()<cr>", opts)
    buf_set_keymap(0, 'n', q.config.keymap.document_symbols, ":lua require'otter'.ask_document_symbols()<cr>", opts)
end

`ftplugin/quarto.lua`

vim.b.slime_cell_delimiter = "```"

-- wrap text, but by word not character
-- indent the wrappped line
vim.wo.wrap = true
vim.wo.linebreak = true
vim.wo.breakindent = true
vim.wo.showbreak = '|'

`lua/plugins/vim-slime.lua`

return {
    {
        "jpalardy/vim-slime",
        init = function()
            vim.b["quarto_is_" .. "python" .. "_chunk"] = false
            Quarto_is_in_python_chunk = function()
                require("otter.tools.functions").is_otter_language_context("python")
            end
    
            vim.cmd([[
                let g:slime_dispatch_ipython_pause = 100
                function SlimeOverride_EscapeText_quarto(text)
                    call v:lua.Quarto_is_in_python_chunk()
                    if exists('g:slime_python_ipython') && len(split(a:text,"\n")) > 1 && b:quarto_is_python_chunk
                        return ["%cpaste -q\n", g:slime_dispatch_ipython_pause, a:text, "--", "\n"]
                    else
                        return a:text
                    end
                endfunction
            ]])
    
            local function mark_terminal()
                vim.g.slime_last_channel = vim.b.terminal_job_id
                vim.print(vim.g.slime_last_channel)
            end
    
            local function set_terminal()
                vim.b.slime_config = { jobid = vim.g.slime_last_channel }
            end
    
            vim.g.slime_cell_delimiter = "#%%"
    
            -- slime, neovvim terminal
            -- vim.g.slime_target = "neovim"
            -- vim.g.slime_python_ipython = 1
    
            -- -- slime, tmux
            local tmux_socket = "default"
            local tmux_pane = "Code:R"
            vim.g.slime_target = 'tmux'
            vim.g.slime_bracketed_paste = 1
            vim.g.slime_default_config = { socket_name = tmux_socket, target_pane = tmux_pane }
    
            local function toggle_slime_tmux_nvim()
                if vim.g.slime_target == "tmux" then
                    pcall(
                        function()
                            vim.b.slime_config = nil
                            vim.g.slime_default_config = nil
                        end
                    )
                    -- slime, neovvim terminal
                    vim.g.slime_target = "neovim"
                    vim.g.slime_bracketed_paste = 0
                    vim.g.slime_python_ipython = 1
    
                elseif vim.g.slime_target == "neovim" then
                    pcall(
                        function()
                            vim.b.slime_config = nil
                            vim.g.slime_default_config = nil
                        end
                    )
                    -- -- slime, tmux
                    vim.g.slime_target = "tmux"
                    vim.g.slime_bracketed_paste = 1
                    vim.g.slime_default_config = { socket_name = tmux_socket, target_pane = tmux_pane }
                end
            end
    
            require("which-key").register({
                ["<leader>cm"] = { mark_terminal, "mark terminal" },
                ["<leader>cs"] = { set_terminal, "set terminal" },
                ["<leader>ct"] = { toggle_slime_tmux_nvim, "toggle tmux/nvim terminal" },
            })
        end,
    }
}

`lua/plugins/vim-slime-cells.lua`

return {
    "Klafyvel/vim-slime-cells",
    dependencies = { "jpalardy/vim-slime" },
    -- see ftplugin/julia.lua for configuration of julia slime cells
    init = function()
        vim.g.slime_cells_no_highlight = 1
    end,
}

`ftplugins/julia.lua`

vim.b.slime_cell_delimiter = "#%%"
vim.b.slime_cells_no_highlight = 0

-- -- slime, tmux
local tmux_socket = "default"
local tmux_pane = "Code:Julia"
vim.g.slime_target = 'tmux'
vim.g.slime_bracketed_paste = 1
vim.g.slime_default_config = { socket_name = tmux_socket, target_pane = tmux_pane }

local nmap = function(key, effect)
    vim.keymap.set("n", key, effect, { silent = true, noremap = true })
end

local vmap = function(key, effect)
    vim.keymap.set("v", key, effect, { silent = true, noremap = true })
end

local imap = function(key, effect)
    vim.keymap.set("i", key, effect, { silent = true, noremap = true })
end

nmap("<c-cr>", "<Plug>SlimeParagraphSend")
nmap("<S-cr>", "<cmd>:SlimeSendCurrentLine<cr>")
imap("<c-cr>", "<esc><Plug>SlimeParagraphSend<cr>i")
imap("<S-cr>", "<esc><Plug>SlimeSendCurrentLine<cr>i")

-- send selected code with ctrl()+Enter (or shift+enter)
vmap("<c-cr>", "<Plug>SlimeRegionSend")
vmap("<S-cr>", "<Plug>SlimeRegionSend")

-- vim-slime-cells
nmap("<c-S-cr>", "<Plug>SlimeCellsSendAndGoToNext")
nmap("<c-c>j", "<Plug>SlimeCellsNext")
nmap("<c-c>k", "<Plug>SlimeCellsPrev")