search

CRAG666 / code_runner.nvim

Neovim plugin.The best code runner you could have, it is like the one in vscode but with super powers, it manages projects like in intellij but without being slow
MIT License
539 stars 38 forks source link
coderunner executable lua lua-script luajit neovim neovim-config neovim-configuration neovim-plugin nvim nvim-lua nvim-plugin run-command vim-configs vim-plugin

readme

Code_Runner

🔥 Code Runner for Neovim written in pure lua 🔥

Introduction

When I was still in college it was common to try multiple programming languages, at that time I used vscode that with a single plugin allowed me to run many programming languages, I left the ballast that are electron apps and switched to neovim, I searched the Internet and finally i found a lot of plugins, but none of them i liked (maybe i didn't search well), so i started adding autocmds like i don't have a tomorrow, this worked fine but this is lazy (maybe it will work for you, if you only programs in one or three languages maximum). So I decided to make this plugin and since the migration of my commands was very fast, it was just copy and paste and everything worked. Currently I don't test many languages anymore and work in the professional environment, but this plugin is still my swiss army knife.

Requirements

Install

require("lazy").setup({
  { "CRAG666/code_runner.nvim", config = true },
}
use 'CRAG666/code_runner.nvim'
require "paq"{ 'CRAG666/code_runner.nvim'; }

Please see my config code_runner.lua

Features

Note If you want implement a new feature open an issue to know if it is worth implementing it and if there are people interested.

Setup

This plugin can be configured either in lua, with the setup function, or with json files for interopability between this plugin and the original code runner vscode plugin.

Minimal example

Lua

require('code_runner').setup({
  filetype = {
    java = {
      "cd $dir &&",
      "javac $fileName &&",
      "java $fileNameWithoutExt"
    },
    python = "python3 -u",
    typescript = "deno run",
    rust = {
      "cd $dir &&",
      "rustc $fileName &&",
      "$dir/$fileNameWithoutExt"
    },
    c = function(...)
      c_base = {
        "cd $dir &&",
        "gcc $fileName -o",
        "/tmp/$fileNameWithoutExt",
      }
      local c_exec = {
        "&& /tmp/$fileNameWithoutExt &&",
        "rm /tmp/$fileNameWithoutExt",
      }
      vim.ui.input({ prompt = "Add more args:" }, function(input)
        c_base[4] = input
        vim.print(vim.tbl_extend("force", c_base, c_exec))
        require("code_runner.commands").run_from_fn(vim.list_extend(c_base, c_exec))
      end)
    end,
  },
})

Json

Warning A common mistake is using relative paths instead of absolute paths in . Use absolute paths in configurations or else the plugin won't work, in case you like to use short or relative paths you can use something like this vim.fn.expand('~/.config/nvim/project_manager.json')

Note If you want to change were the code is displayed you need to specify the [mode]() attribute in the setup function

-- this is a config example
require('code_runner').setup {
  filetype_path = vim.fn.expand('~/.config/nvim/code_runner.json'),
  project_path = vim.fn.expand('~/.config/nvim/project_manager.json')
}

Commands

Note To check what modes ore supported see mode parameter.

All run commands allow restart. So, for example, if you use a command that does not have hot reload, you can call a command again and it will close the previous one and start again.

Recommended mappings:

vim.keymap.set('n', '<leader>r', ':RunCode<CR>', { noremap = true, silent = false })
vim.keymap.set('n', '<leader>rf', ':RunFile<CR>', { noremap = true, silent = false })
vim.keymap.set('n', '<leader>rft', ':RunFile tab<CR>', { noremap = true, silent = false })
vim.keymap.set('n', '<leader>rp', ':RunProject<CR>', { noremap = true, silent = false })
vim.keymap.set('n', '<leader>rc', ':RunClose<CR>', { noremap = true, silent = false })
vim.keymap.set('n', '<leader>crf', ':CRFiletype<CR>', { noremap = true, silent = false })
vim.keymap.set('n', '<leader>crp', ':CRProjects<CR>', { noremap = true, silent = false })

Parameters

Setup Global

This are the the configuration option you can pass to the setup function. To see the default values see: code_runner.nvim/lua/code_runner/options.

Parameters:

Setup Filetypes

Note The commands are runned in a shell. This means that you can't run neovim commands with this.

Lua

The filetype table can take either a string, a table or a function.

-- in setup function
filetype = {
  java = { "cd $dir &&", "javac $fileName &&", "java $fileNameWithoutExt" },
  python = "python3 -u",
  typescript = "deno run",
  rust = { "cd $dir &&",
    "rustc $fileName &&",
    "$dir/$fileNameWithoutExt"
  },
  cs = function(...)
    local root_dir = require("lspconfig").util.root_pattern "*.csproj"(vim.loop.cwd())
    return "cd " .. root_dir .. " && dotnet run$end"
  end,
},

If you want to add some other language or some other command follow this structure key = commans.

Json

Note In Json you can only pass the commands as a string

The equivalent for your json filetype file is:

{
  "java": "cd $dir && javac $fileName && java $fileNameWithoutExt",
  "python": "python3 -u",
  "typescript": "deno run",
  "rust": "cd $dir && rustc $fileName && $dir/$fileNameWithoutExt"
}

Variables

Note If you don't want to use the plugin specific variables you can use vim filename-modifiers.

This uses some special keyword to that means different things. This is do mainly for be compatible with the original vscode plugin.

The available variables are the following:

If you want to add some other language or some other command follow this structure key: commans.

Setup Projects

There are 3 main ways to configure the execution of a project (found in the example.)

  1. Use the default command defined in the filetypes file (see :CRFiletypeor check your config). In order to do that it is necessary to define file_name.
  2. Use a different command than the one set in CRFiletype or your config. In this case, the file_name and command must be provided.
  3. Use a command to run the project. It is only necessary to define command (You do not need to write navigate to the root of the project, because automatically the plugin is located in the root of the project).

The key for each project is a pattern to match against the current filename of the buffer. The pattern is a lua patterns and needs to escape magic characters like -, ., (, etc. with a %. To match the entire path to a directory you cannot simply append /. This is due to vim.fs.normalize being used. Append /.- instead to prevent stripping of /.

Also see project parameters to set correctly your project commands.

Lua

project = {
  ["~/python/intel_2021_1"] = {
    name = "Intel Course 2021",
    description = "Simple python project",
    file_name = "POO/main.py"
  },
  ["~/deno/example"] = {
    name = "ExapleDeno",
    description = "Project with deno using other command",
    file_name = "http/main.ts",
    command = "deno run --allow-net"
  },
  ["~/cpp/example"] = {
    name = "ExapleCpp",
    description = "Project with make file",
    command = "make buid && cd buid/ && ./compiled_file"
  },
  ["~/private/.*terraform%-prod.-/.-"] = {
    name = "ExampleTerraform",
    description = "All Folders in ~/private containing \"terraform-prod\"",
    command = "terraform plan",
  },
},

Json

{
  "~/python/intel_2021_1": {
    "name": "Intel Course 2021",
    "description": "Simple python project",
    "file_name": "POO/main.py"
  },
  "~/deno/example": {
    "name": "ExapleDeno",
    "description": "Project with deno using other command",
    "file_name": "http/main.ts",
    "command": "deno run --allow-net"
  },
  "~/cpp/example": {
    "name": "ExapleCpp",
    "description": "Project with make file",
    "command": "make buid && cd buid/ && ./compiled_file"
  },
  "~/private/.*terrafrom%-prod.-/.-": {
    "name": "ExampleTerraform",
    "description": "All Folders in ~/private containing \"terraform-prod\"",
    "command": "terraform plan"
  }
}

Parameters

Warning Avoid using all the parameters at the same time. The correct way to use them is shown in the example and described above.

Note Don't forget to name your projects because if you don't do so code runner will fail as it uses the name for the buffer name

Hooks

These elements are intended to help with those commands that require more complexity. For example, implement hot reload on markup documents.

Preview PDF

This module allows us to send a command to compile to pdf as well as show the result every time we save the original document.

Usage example

{
...
    filetype = {
      -- Using pdflatex compiler
      -- tex = function(...)
      --   require("code_runner.hooks.preview_pdf").run {
      --     command = "pdflatex",
      --     args = { "-output-directory", "/tmp", "$fileName" },
      --     preview_cmd = "/bin/zathura --fork",
      --     overwrite_output = "/tmp",
      --   }
      -- end,
      -- Using tectonic compiler
      tex = function(...)
        require("code_runner.hooks.ui").select {
          Single = function()
            local preview = require "code_runner.hooks.preview_pdf"
            preview.run {
              command = "tectonic",
              args = { "$fileName", "--keep-logs", "-o", "/tmp" },
              preview_cmd = preview_cmd,
              overwrite_output = "/tmp",
            }
          end,
          Project = function()
            local cr_au = require "code_runner.hooks.autocmd"
            cr_au.stop_job()
            os.execute "tectonic -X build --keep-logs --open &> /dev/null &"
            local fn = function()
              os.execute "tectonic -X build --keep-logs &> /dev/null &"
            end
            cr_au.create_au_write(fn)
          end,
        }
      end,
      markdown = function(...)
        local hook = require "code_runner.hooks.preview_pdf"
        require("code_runner.hooks.ui").select {
          Normal = function()
            hook.run {
              command = "pandoc",
              args = { "$fileName", "-o", "$tmpFile", "-t pdf" },
              preview_cmd = preview_cmd,
            }
          end,
          Presentation = function()
            hook.run {
              command = "pandoc",
              args = { "$fileName", "-o", "$tmpFile", "-t beamer" },
              preview_cmd = preview_cmd,
            }
          end,
          Eisvogel = function()
            hook.run {
              command = "bash",
              args = { "./build.sh" },
              preview_cmd = preview_cmd,
              overwrite_output = ".",
            }
          end,
        }
      end,
  ...
}

preview

In the above example we use the hook to compile markdown and latex files to pdf. Not only that, but we also indicate in what order the resulting pdf file will be opened. In my case it is zathura but you can use a browser if it is more comfortable for you.

It is important that you take into account that each time you save the original file, the pdf file will be generated.

Parameters

Vars

These are variables used to be substituted for values according to each filename.

Typescript hooks

This example showcases how to write a hook to run ts file, print the result in a new vertical windows and reload on save. Read the comments for more info.

-- custom function to run ts file
-- and print result in a new vertical windows
local function runTsFile(fileName)
  -- Check if the current file is a TypeScript file
  if string.match(fileName, '%.ts$') then
    -- Save the current window id
    local current_win = vim.fn.win_getid()

    -- Close previous terminal windows
    vim.cmd 'silent! wincmd w | if &buftype ==# "terminal" | q | endif'

    -- Open a vertical terminal
    vim.cmd 'vsplit term://'

    -- Run the TypeScript file and print the result
    vim.fn.termopen('ts-node ' .. fileName)

    -- Restore the focus to the original window
    vim.fn.win_gotoid(current_win)
  else
    print 'Not a TypeScript file!'
  end
end

-- hooks config
{
  filetype = {
    typescript = function()
      local cr_au = require "code_runner.hooks.autocmd"
      -- stop previous job (if has any)
      cr_au.stop_job() -- CodeRunnerJobPosWrite

      local fileName = vim.fn.expand '%:p'
      local fn = function()
        runTsFile(fileName)
      end

      -- run the command the first time
      fn()

      -- listen to bufwrite event after the first run time
      cr_au.create_au_write(fn)
    end,
  },
}

Integration with other plugins

API

These functions could be useful if you intend to create plugins around code_runner, currently only the file type and current project commands can be accessed respectively

require("code_runner.commands").get_filetype_command() -- get the current command for this filetype
require("code_runner.commands").get_project_command() -- get the current command for this project

Harpoon

You can directly integrate this plugin with ThePrimeagen/harpoon the way to do it is through command queries, harpoon allows the command to be sent to a terminal, below it is shown how to use harpoon term together with code_runner.nvim:

require("harpoon.term").sendCommand(1, require("code_runner.commands").get_filetype_command() .. "\n")

Inspirations and thanks

Screenshots

Contributing

Note If you have any ideas to improve this project, do not hesitate to make a request, if problems arise, try to solve them and publish them. Don't be so picky I did this in one afternoon

Your help is needed to make this plugin the best of its kind, be free to contribute, criticize (don't be soft) or contribute ideas. All PRs are welcome.

LICENCE

MIT