🚀 greyjoy.nvim

Greyjoy uses vim.ui.select and built-in terminal/buffers but integration with a few plugins are available but requires dependencies

Available when installed.

{
  ui = {
    buffer = { -- width and height for the buffer output
      width = math.ceil(math.min(vim.o.columns, math.max(80, vim.o.columns - 20))),
      height = math.ceil(math.min(vim.o.lines, math.max(20, vim.o.lines - 10))),
    },
    toggleterm = { -- by default no size is defined for the toggleterm by
      -- greyjoy.nvim it will be dependent on the user configured size for toggle
      -- term.
      size = nil,
    },
    term = {
      width_pct = 0.2, -- 20% of screen
    },
    telescope = {
        keys = {
            select = "<CR>", -- enter
            edit = "<C-e>", -- CTRL-e
        },
    }
  },
  toggleterm = {
      -- default_group_id can be a number or a function that takes a string as parameter.
      -- The string passed as parameter is the name of the plugin so its possible to do logic based
      -- on plugin name and function should always return a number like:
      -- default_group_id = function(plugin) return 1 end
      default_group_id = 1,
  },
  enable = true,
  border = "rounded", -- style for vim.ui.selector
  style = "minimal",
  show_command = false, -- show command to run in menu
  show_command_in_output = true, -- show command that was just executed in output
  patterns = {".git", ".svn"}, -- patterns to find the root of the project
  output_result = require("greyjoy.terminals").buffer,
  extensions = {}, -- extensions configurations
  run_groups = {}, -- See `Run groups`
  overrides = {}, -- Stores internal overrides of commands
}

Per default all plugins use the same terminal/buffer but this behaviour can be overridden if you are using toggleterm.

Toggleterm supports multiple terminals so you can group extensions into having different terminal.

Specify group_id or create a function to assign number based on plugin name.

So if you want all extensions to run under id 1 (default) but the docker_compose you would like to have another group you can configure it via

  extensions = {
    docker_compose = { group_id = 2 },
  },

Now all docker compose's exec is running in a secondary terminal (group_id 2) and all the others in group_id 1

🫂 Run groups

Some extension can be slow or not always required so its possible to group extensions into groups.

{
	...
     run_groups = { fast = { "generic", "makefile", "cargo", "docker_compose" } },
	...
}

Invoking :Greyjoy fast now only runs the defined extensions.

🪝 Hooks

Hooks can be invoked before and after a command and no default ones are defined.

An example of running a target via a makefile can put the errors in the quickfix list just like running it via the :make:

return {
    "desdic/greyjoy.nvim",
    keys = {
        { "<leader>gr", "<cmd>Greyjoy<CR>", desc = "[G]reyjoy [r]un" },
    },
    cmd = { "Greyjoy", "Greyedit", "GreyjoyRunLast" },
    config = function()
        local greyjoy = require("greyjoy")

        local tmpmakename = nil

        local pre_make = function(command)
            tmpmakename = os.tmpname()
            table.insert(command.command, "2>&1")
            table.insert(command.command, "|")
            table.insert(command.command, "tee")
            table.insert(command.command, tmpmakename)
        end

        -- A bit hacky solution to checking when tee has flushed its file
        local post_make = function()
            vim.cmd(":cexpr []")
            local cmd = { "inotifywait", "-e", "close_write", tmpmakename }

            local job_id = vim.fn.jobstart(cmd, {
                stdout_buffered = true,
                on_exit = function(_, _, _)
                    if tmpmakename ~= nil then
                        vim.cmd(":cgetfile " .. tmpmakename)
                        os.remove(tmpmakename)
                    end
                end,
            })

            if job_id <= 0 then
                vim.notify("Failed to start inotifywait!")
            end
        end

        greyjoy.setup({
            ui = {
                term = {
                    height = 10,
                },
            },
            output_results = require("greyjoy.terminals").term,
            extensions = {
                makefile = {
                    pre_hook = pre_make,
                    post_hook = post_make,
                },
            }
        })

        greyjoy.load_extension("makefile")
    end,
}

Generic extension

generic extension is a global module that does not take into account if we are in a project (found via the patterns). Commands to run can be matched using filetype, filename, filepath

Example:

generic = {
  commands = {
    ["run {filename}"] = {
      command = {"python3 {filename}"}, -- can be a single string or multiple but is still a single command
      filetype = "python", -- only runs if filetype is python and filename is test.py
      filename = "test.py"
    },
    ["run {filename}"] = {
      command = {"go", "run", "{filename}"},
      filetype = "go" -- run if filetype is go
    },
    ["cmake --build target"] = {
        command = { "cd", "{rootdir}", "&&", "cmake", "--build", "{rootdir}/target" },
        condition = function(n) -- custom conditions can be added
            return condition.file_exists("CMakeLists.txt", n)
                and condition.directory_exists("target", n)
        end,
    },
    ["cmake -S . -B target"] = {
        command = { "cd", "{rootdir}", "&&", "cmake", "-S", ".", "-B", "{rootdir}/target" },
        condition = function(n)
            return condition.file_exists("CMakeLists.txt", n)
                and not condition.directory_exists("target", n)
        end,
    },
    ...
  }
},

File extension

file extension is a global module that only reads greyjoy.json (can be changed) from within your project

Example configuration:

file = {
  filename = "myrunner.json"
},

The configuration file is a simple key value. Value can be a string or an array (same result).

{
  "build all": ["make", "build"],
  "do cleanup": "make clean"
}

Makefile extension

The makefile extension is file based and will only trigger if a Makefile is located in the project root. It finds all targets for a Makefile.

Vscode_tasks extension

The vscode_tasks extension is file based and will only trigger if .vscode/tasks.json exists in the project root

Kitchen extension

The kitchen extension is also file based and looks for .kitchen.yml (chefdk or cinc-workstation).

This extension can be configured to only include specific targets

extensions = {
    kitchen = {
        targets = { "converge", "verify", "destroy", "test", "login" },
        include_all = false,
    }
}

Cargo extension

The cargo extension is file based and looks for Cargo.toml and requires cargo

Docker_compose extension

The docker_compose extension is file based and looks for docker-compose.yml.

Condition functions can be applied to the generic extension in case the built-in isn't enough.

Displaying the output of a command is based on the function defined in output_result. Default it just outputs to a buffer but you can write a function for your custom need.