gitlab.nvim/doc/gitlab.nvim.txt

*gitlab.nvim.txt* Create, review, and manage Gitlab resources without leaving Neovim

==============================================================================
Table of Contents                              *gitlab.nvim.table-of-contents*

  - Requirements                                    |gitlab.nvim.requirements|
  - Quick Start                                      |gitlab.nvim.quick-start|
  - Installation                                    |gitlab.nvim.installation|
  - Connecting to Gitlab                    |gitlab.nvim.connecting-to-gitlab|
  - Configuring the Plugin                |gitlab.nvim.configuring-the-plugin|
  - Usage                                                  |gitlab.nvim.usage|
  - The Summary view                            |gitlab.nvim.the-summary-view|
  - Reviewing an MR                              |gitlab.nvim.reviewing-an-mr|
  - Temporary registers                           |gitlab.nvim.temp-registers|
  - Discussions and Notes                  |gitlab.nvim.discussions-and-notes|
  - Labels                                                |gitlab.nvim.labels|
  - Signs and diagnostics                  |gitlab.nvim.signs-and-diagnostics|
  - Emojis                                                |gitlab.nvim.emojis|
  - Uploading Files                              |gitlab.nvim.uploading-files|
  - MR Approvals                                    |gitlab.nvim.mr-approvals|
  - Merging an MR                                  |gitlab.nvim.merging-an-mr|
  - Creating an MR                                |gitlab.nvim.creating-an-mr|
  - Pipelines                                          |gitlab.nvim.pipelines|
  - Reviewers and Assignees              |gitlab.nvim.reviewers-and-assignees|
  - Restarting or Shutting Down      |gitlab.nvim.restarting-or-shutting-down|
  - Keybindings                                      |gitlab.nvim.keybindings|
  - Troubleshooting                              |gitlab.nvim.troubleshooting|
  - Api                                                      |gitlab.nvim.api|


OVERVIEW                                                *gitlab.nvim.overview*

This Neovim plugin is designed to make it easy to review Gitlab MRs from within
the editor. This means you can do things like:

- Create, approve, and merge MRs for the current branch
- Read and edit an MR description
- Add or remove reviewers and assignees
- Resolve, reply to, and unresolve discussion threads
- Create, edit, delete, and reply to comments
- View and manage pipeline Jobs
- Upload files, jump to the browser, and a lot more!


REQUIREMENTS                                        *gitlab.nvim.requirements*

- Go >= v1.19


QUICK START                                          *gitlab.nvim.quick-start*

1. Install Go
2. Add configuration (see Installation section)
5. Run `:lua require("gitlab").choose_merge_request()`

This will checkout the branch locally, and up the plugin's reviewer pane.

NOTE: At the moment, the plugin assumes that the remote where you want to
merge your feature branch is called "origin".


INSTALLATION                                        *gitlab.nvim.installation*

With Lazy:
>lua
    return {
      "harrisoncramer/gitlab.nvim",
      dependencies = {
        "MunifTanjim/nui.nvim",
        "nvim-lua/plenary.nvim",
        "sindrets/diffview.nvim",
        "stevearc/dressing.nvim", -- Recommended but not required. Better UI for pickers.
        "nvim-tree/nvim-web-devicons" -- Recommended but not required. Icons in discussion tree.
      },
      enabled = true,
      build = function () require("gitlab.server").build(true) end, -- Builds the Go binary
      config = function()
        require("gitlab").setup()
      end,
    }
<
And with Packer:
>lua
    use {
      "harrisoncramer/gitlab.nvim",
      requires = {
        "MunifTanjim/nui.nvim",
        "nvim-lua/plenary.nvim",
        "sindrets/diffview.nvim",
        "stevearc/dressing.nvim", -- Recommended but not required. Better UI for pickers.
        "nvim-tree/nvim-web-devicons", -- Recommended but not required. Icons in discussion tree.
      },
      build = function()
        require("gitlab.server").build()
      end,
      branch = "develop",
      config = function()
        require("diffview") -- We require some global state from diffview
        local gitlab = require("gitlab")
        gitlab.setup()
      end,
    }
<

CONNECTING TO GITLAB                        *gitlab.nvim.connecting-to-gitlab*

This plugin requires an auth token to connect to Gitlab. The token can be set
in the root directory of the project in a `.gitlab.nvim` environment file, or
can be set via a shell environment variable called `GITLAB_TOKEN` instead. If
both are present, the `.gitlab.nvim` file will take precedence.

Optionally provide a GITLAB_URL environment variable (or gitlab_url value in
the `.gitlab.nvim` file) to connect to a self-hosted Gitlab instance. This is
optional, use ONLY for self-hosted instances. Here’s what they’d look like
as environment variables:
>bash
    export GITLAB_TOKEN="your_gitlab_token"
    export GITLAB_URL="https://my-personal-gitlab-instance.com/"
<
And as a `.gitlab.nvim` file:
>
    auth_token=your_gitlab_token
    gitlab_url=https://my-personal-gitlab-instance.com/
<
The plugin will look for the `.gitlab.nvim` file in the root of the current
project by default. However, you may provide a custom path to the configuration
file via the `config_path` option. This must be an absolute path to the
directory that holds your `.gitlab.nvim` file.

The `connection_settings` block in the `state.lua` file will be used to
configure your connection to Gitlab.

In case even more control over the auth config is needed, there is the
possibility to override the `auth_provider` settings field. It should be
a function that returns the `token` as well as the `gitlab_url` value and
a nilable error value.

If the `gitlab_url` is `nil`, `https://gitlab.com` is used as default.

Here an example how to use a custom `auth_provider`:
>lua
    require("gitlab").setup({
      auth_provider = function()
        return "my_token", "https://custom.gitlab.instance.url", nil
      end,
    }
<


CONFIGURING THE PLUGIN                    *gitlab.nvim.configuring-the-plugin*

Here is the default setup function. All of these values are optional, and if
you call this function with no values the defaults will be used:
>lua
    require("gitlab").setup({
      port = nil, -- The port of the Go server, which runs in the background, if omitted or `nil` the port will be chosen automatically
      log_path = vim.fn.stdpath("cache") .. "/gitlab.nvim.log", -- Log path for the Go server
      config_path = nil, -- Custom path for `.gitlab.nvim` file, please read the "Connecting to Gitlab" section
      debug = { go_request = false, go_response = false }, -- Which values to log
      attachment_dir = nil, -- The local directory for files (see the "summary" section)
      reviewer_settings = {
        diffview = {
          imply_local = false, -- If true, will attempt to use --imply_local option when calling |:DiffviewOpen|
        },
      },
      connection_settings = {
        insecure = false, -- Like curl's --insecure option, ignore bad x509 certificates on connection
      },
      help = "g?", -- Opens a help popup for local keymaps when a relevant view is focused (popup, discussion panel, etc)
      popup = { -- The popup for comment creation, editing, and replying
        keymaps = {
          next_field = "<Tab>", -- Cycle to the next field. Accepts |count|.
          prev_field = "<S-Tab>", -- Cycle to the previous field. Accepts |count|.
        },
        perform_action = "<leader>s", -- Once in normal mode, does action (like saving comment or editing description, etc)
        perform_linewise_action = "<leader>l", -- Once in normal mode, does the linewise action (see logs for this job, etc)
        width = "40%",
        height = "60%",
        border = "rounded", -- One of "rounded", "single", "double", "solid"
        opacity = 1.0, -- From 0.0 (fully transparent) to 1.0 (fully opaque)
        comment = nil, -- Individual popup overrides, e.g. { width = "60%", height = "80%", border = "single", opacity = 0.85 },
        edit = nil,
        note = nil,
        pipeline = nil,
        reply = nil,
        squash_message = nil,
        temp_registers = {}, -- List of registers for backing up popup content (see `:h gitlab.nvim.temp-registers`)
      },
      discussion_tree = { -- The discussion tree that holds all comments
        auto_open = true, -- Automatically open when the reviewer is opened
        switch_view = "S", -- Toggles between the notes and discussions views
        default_view = "discussions" -- Show "discussions" or "notes" by default
        blacklist = {}, -- List of usernames to remove from tree (bots, CI, etc)
        jump_to_file = "o", -- Jump to comment location in file
        jump_to_reviewer = "m", -- Jump to the location in the reviewer window
        edit_comment = "e", -- Edit comment
        delete_comment = "dd", -- Delete comment
        refresh_data = "a", -- Refreshes the data in the view by hitting Gitlab's APIs again
        reply = "r", -- Reply to comment
        toggle_node = "t", -- Opens or closes the discussion
        add_emoji = "Ea" -- Add an emoji to the note/comment
        add_emoji = "Ed" -- Remove an emoji from a note/comment
        toggle_all_discussions = "T", -- Open or close separately both resolved and unresolved discussions
        toggle_resolved_discussions = "R", -- Open or close all resolved discussions
        toggle_unresolved_discussions = "U", -- Open or close all unresolved discussions
        keep_current_open = false, -- If true, current discussion stays open even if it should otherwise be closed when toggling
        publish_draft = "P", -- Publishes the currently focused note/comment
        toggle_resolved = "p" -- Toggles the resolved status of the whole discussion
        position = "left", -- "top", "right", "bottom" or "left"
        open_in_browser = "b" -- Jump to the URL of the current note/discussion
        copy_node_url = "u", -- Copy the URL of the current node to clipboard
        size = "20%", -- Size of split
        relative = "editor", -- Position of tree split relative to "editor" or "window"
        resolved = '✓', -- Symbol to show next to resolved discussions
        unresolved = '-', -- Symbol to show next to unresolved discussions
        tree_type = "simple", -- Type of discussion tree - "simple" means just list of discussions, "by_file_name" means file tree with discussions under file
        toggle_tree_type = "i", -- Toggle type of discussion tree - "simple", or "by_file_name"
        draft_mode = false, -- Whether comments are posted as drafts as part of a review
        toggle_draft_mode = "D" -- Toggle between draft mode (comments posted as drafts) and live mode (comments are posted immediately)
        winbar = nil -- Custom function to return winbar title, should return a string. Provided with WinbarTable (defined in annotations.lua)
                     -- If using lualine, please add "gitlab" to disabled file types, otherwise you will not see the winbar.
      },
      choose_merge_request = {
        open_reviewer = true, -- Open the reviewer window automatically after switching merge requests
      },
      info = { -- Show additional fields in the summary view
        enabled = true,
        horizontal = false, -- Display metadata to the left of the summary rather than underneath
        fields = { -- The fields listed here will be displayed, in whatever order you choose
          "author",
          "created_at",
          "updated_at",
          "merge_status",
          "draft",
          "conflicts",
          "assignees",
          "reviewers",
          "pipeline",
          "branch",
          "target_branch",
          "delete_branch",
          "squash",
          "labels",
        },
      },
      discussion_signs = {
        enabled = true, -- Show diagnostics for gitlab comments in the reviewer
        skip_resolved_discussion = false, -- Show diagnostics for resolved discussions
        severity = vim.diagnostic.severity.INFO, -- ERROR, WARN, INFO, or HINT
        virtual_text = false, -- Whether to show the comment text inline as floating virtual text
        use_diagnostic_signs = true, -- Show diagnostic sign (depending on the `severity` setting, e.g., I for INFO) along with the comment icon
        priority = 100, -- Higher will override LSP warnings, etc
        icons = {
          comment = "→|",
          range = " |",
        },
      },
      pipeline = {
        created = "",
        pending = "",
        preparing = "",
        scheduled = "",
        running = "",
        canceled = "↪",
        skipped = "↪",
        success = "✓",
        failed = "",
      },
      create_mr = {
        target = nil, -- Default branch to target when creating an MR
        template_file = nil, -- Default MR template in .gitlab/merge_request_templates
        delete_branch = false, -- Whether the source branch will be marked for deletion
        squash = false, -- Whether the commits will be marked for squashing
        fork = {
          enabled = false, -- If making an MR from a fork
          forked_project_id = nil -- The ID of the project you are merging into. If nil, will be prompted.
        },
        title_input = { -- Default settings for MR title input window
          width = 40,
          border = "rounded",
        },
      },
      colors = {
        discussion_tree = {
          username = "Keyword",
          date = "Comment",
          chevron = "DiffviewNonText",
          directory = "Directory",
          directory_icon = "DiffviewFolderSign",
          file_name = "Normal",
        }
      }
    })
<

USAGE                                                      *gitlab.nvim.usage*

First, check out the branch that you want to review locally:
>
    git checkout feature-branch
<
Then open Neovim. To begin, try running the `summary` command or the `review`
command.


THE SUMMARY VIEW                                *gitlab.nvim.the-summary-view*

The `summary` action will open the MR title and description:
>lua
    require("gitlab").summary()
<
After editing the description or title, you may save your changes via the
`settings.popup.perform_action` keybinding.

By default this plugin will also show additional metadata about the MR in a
separate pane underneath the description. This can be disabled, and these
fields can be reordered or removed. Please see the `settings.info` section of
the configuration.


REVIEWING AN MR                                  *gitlab.nvim.reviewing-an-mr*

The `review` action will open a diff of the changes. You can leave comments
using the `create_comment` action. In visual mode, add multiline comments with
the `create_multiline_comment` command, and add suggested changes with the
`create_comment_suggestion` command:
>lua
    require("gitlab").review()
    require("gitlab").create_comment()
    require("gitlab").create_multiline_comment()
    require("gitlab").create_comment_suggestion()
<
For suggesting changes you can use `create_comment_suggestion` in visual mode
which works similar to `create_multiline_comment` but prefills the comment
window with Gitlab’s suggest changes
<https://docs.gitlab.com/ee/user/project/merge_requests/reviews/suggestions.html>
code block with prefilled code from the visual selection.
Just like the summary, all the different kinds of comments are saved via the
`settings.popup.perform_action` keybinding.

DRAFT NOTES                                       *gitlab.nvim.draft-comments*

When you publish a "draft" of any of the above resources, the comment will be
added to a review. You can configure the default commenting mode (draft vs
live) via the `state.settings.discussion_tree.draft_mode` setting, and you can
toggle the setting with the `state.settings.discussion_tree.toggle_draft_mode`
keybinding, or by calling the `gitlab.toggle_draft_mode()` function. You may
publish all draft comments via the `gitlab.publish_all_drafts()` function, and
you can publish an individual comment or note by pressing the
`state.settings.discussion_tree.publish_draft` keybinding.

Draft notes do not support replying or emojis.

TEMPORARY REGISTERS                               *gitlab.nvim.temp-registers*

While writing a note/comment/suggestion/reply, you may need to interrupt the
work, do something else (e.g., read something in another file, etc.), and then
get back to your work on the comment. For occasions like this, you can set
`settings.popup.temp_registers` to a list of writable registers (see |registers|)
to which the contents of the popup window will be saved just before quitting.

A possible setting is, e.g., `settings.popup.temp_registers = {'"', "+", "g"}`
which saves to the so called unnamed register (see |quotequote|), the system
clipboard register (see |quoteplus|), as well as to the "g" register. This lets
you easily paste the text back in with |p| or |P| (from the unnamed register),
or with `"gp` or `"gP` if the unnamed register gets overwritten with something
else. Using the clipboard register lets you easily use the text outside of
nvim.

NOTE: The `temp_registers` are also filled with the contents of the popup when
pressing the `settings.popup.perform_action` keybinding, even if the action
that was supposed to be performed fails.

DISCUSSIONS AND NOTES                      *gitlab.nvim.discussions-and-notes*

Gitlab groups threads of comments together into "discussions."

To display all discussions for the current MR, use the `toggle_discussions`
action, which will show the discussions in a split window:
>lua
    require("gitlab").toggle_discussions()
<

You can jump to the comment’s location in the reviewer window by using the
`state.settings.discussion_tree.jump_to_reviewer` key, or to the actual file
with the `state.settings.discussion_tree.jump_to_file` key.

Within the discussion tree, you can delete/edit/reply to comments with the
`state.settings.discussion_tree.SOME_ACTION` keybindings.

If you’d like to create a note in an MR (like a comment, but not linked to a
specific line) use the `create_note` action. The same keybindings for
delete/edit/reply are available on the note tree.
>lua
    require("gitlab").create_note()
<

When the 'wrap' option is on, line wrapping can make the discussion tree
harder to read. You can use the 'breakindent' option to visually indent tree
nodes at the same level. If you don't want to set 'breakindent' globally, you
can set this only for the `gitlab` file type (the file type of discussions and
notes). One way of doing this is by creating a file called
$XDG_CONFIG_HOME/nvim/after/ftplugin/gitlab.lua with the following contents:
>lua
    vim.o.breakindent = true
<

LABELS                                                    *gitlab.nvim.labels*

You can add or remove labels from the current MR.
>lua
    require("gitlab").add_label()
    require("gitlab").delete_label()

These labels will be visible in the summary panel, as long as you provide the
"fields" string in your setup function under the `setting.info.fields` block.


SIGNS AND DIAGNOSTICS                      *gitlab.nvim.signs-and-diagnostics*

By default when reviewing files, you will see diagnostics for comments that
have been added to a review. These are the default settings:
>lua
    discussion_signs = {
      enabled = true, -- Show diagnostics for gitlab comments in the reviewer
      skip_resolved_discussion = false, -- Show diagnostics for resolved discussions
      severity = vim.diagnostic.severity.INFO, -- ERROR, WARN, INFO, or HINT
      virtual_text = false, -- Whether to show the comment text inline as floating virtual text
      use_diagnostic_signs = true, -- Show diagnostic sign (depending on the `severity` setting, e.g., I for INFO) along with the comment icon
      priority = 100, -- Higher will override LSP warnings, etc
      icons = {
        comment = "→|",
        range = " |",
      },
    },

When the cursor is on a diagnostic line you can view the discussion thread by
using `vim.diagnostic.show()`.

You can also jump to the discussion tree for the given comment:
>lua
    require("gitlab").move_to_discussion_tree_from_diagnostic()

Since nvim 0.10 you can use these two function anywhere in the diagnostic
range. In previous versions, you have to move the cursor to the first line of
the diagnostic.

You may skip resolved discussions by toggling `discussion_signs.skip_resolved_discussion`
in your setup function to `true`. By default, discussions from this plugin
are shown at the INFO severity level (see :h vim.diagnostic.severity).


EMOJIS                                                    *gitlab.nvim.emojis*

You can add or remove emojis from a note or comment in the discussion tree.

To see who has reacted with an emoji, hover over the emoji. A popup will
appear with anyone who has responded with that emoji. You can only delete
emojis that you have responded with.


UPLOADING FILES                                  *gitlab.nvim.uploading-files*

To attach a file to an MR description, reply, comment, and so forth use the
`settings.popup.perform_linewise_action` keybinding when the popup is open.
This will open a picker that will look for files in the directory you specify
in the `settings.attachment_dir` folder (this must be an absolute path).

When you have picked the file, it will be added to the current buffer at the
current line.

Use the `settings.popup.perform_action` to send the changes to Gitlab.


MR APPROVALS                                        *gitlab.nvim.mr-approvals*

You can approve or revoke approval for an MR with the `approve` and `revoke`
actions respectively:
>lua
    require("gitlab").approve()
    require("gitlab").revoke()
<

MERGING AN MR                                      *gitlab.nvim.merging-an-mr*

The `merge` action will merge an MR. The MR must be in a "mergeable" state for
this command to work.
>lua
    require("gitlab").merge()
    require("gitlab").merge({ squash = false, delete_branch = false })
<
See |gitlab.nvim.merge| for more help on this function.


CREATING AN MR                                    *gitlab.nvim.creating-an-mr*

To create an MR for the current branch, make sure you have the branch checked
out. Then, use the `create_mr` action. See |gitlab.nvim.create_mr| for more
help on this function
>lua
    require("gitlab").create_mr()
    require("gitlab").create_mr({ target = "main" })
    require("gitlab").create_mr({ template_file = "my-template.md", title = "Fix bug XYZ" })
<

PIPELINES                                              *gitlab.nvim.pipelines*

You can view the status of the pipeline for the current MR with the `pipeline`
action.
>lua
    require("gitlab").pipeline()
<
To re-trigger failed jobs in the pipeline manually, use the
`settings.popup.perform_action` keybinding. To open the log trace of a job in a
new Neovim buffer, use your `settings.popup.perform_linewise_action`
keybinding.


REVIEWERS AND ASSIGNEES                  *gitlab.nvim.reviewers-and-assignees*

The `add_reviewer` and `delete_reviewer` actions, as well as the `add_assignee`
and `delete_assignee` functions, will let you choose from a list of users who
are available in the current project:
>lua
    require("gitlab").add_reviewer()
    require("gitlab").delete_reviewer()
    require("gitlab").add_assignee()
    require("gitlab").delete_assignee()
<
These actions use Neovim’s built in picker, which is much nicer if you
install `dressing.nvim`. If you use Dressing, please enable it:
>lua
    require("dressing").setup({
        input = {
            enabled = true
        }
    })
<

RESTARTING OR SHUTTING DOWN          *gitlab.nvim.restarting-or-shutting-down*

The `gitlab.nvim` server will shut down automatically when you exit Neovim.
However, if you would like to manage this yourself (for instance, restart the
server when you check out a new branch) you may do so via the `restart`
command, or `shutdown` commands, which both accept callbacks:
>lua
    require("gitlab.server").restart()
    require("gitlab.server").shutdown()
<
For instance you could set up the following keybinding to close and reopen the
reviewer when checking out a new branch:
>lua
    local gitlab = require("gitlab")
    vim.keymap.set("n", "glB", function ()
        require("gitlab.server").restart(function ()
            vim.cmd.tabclose()
            gitlab.review() -- Reopen the reviewer after the server restarts
        end)
    end)
<

KEYBINDINGS                                          *gitlab.nvim.keybindings*

The plugin does not set up any keybindings outside of the special buffers it
creates, you need to set them up yourself. Here’s what I’m using (note that
the `<leader>` prefix is not necessary, as `gl` does not have a special meaning
in normal mode):
>lua
    local gitlab = require("gitlab")
    local gitlab_server = require("gitlab.server")
    vim.keymap.set("n", "glr", gitlab.review)
    vim.keymap.set("n", "gls", gitlab.summary)
    vim.keymap.set("n", "glA", gitlab.approve)
    vim.keymap.set("n", "glR", gitlab.revoke)
    vim.keymap.set("n", "glc", gitlab.create_comment)
    vim.keymap.set("v", "glc", gitlab.create_multiline_comment)
    vim.keymap.set("v", "glC", gitlab.create_comment_suggestion)
    vim.keymap.set("n", "glO", gitlab.create_mr)
    vim.keymap.set("n", "glm", gitlab.move_to_discussion_tree_from_diagnostic)
    vim.keymap.set("n", "gln", gitlab.create_note)
    vim.keymap.set("n", "gld", gitlab.toggle_discussions)
    vim.keymap.set("n", "glaa", gitlab.add_assignee)
    vim.keymap.set("n", "glad", gitlab.delete_assignee)
    vim.keymap.set("n", "glra", gitlab.add_reviewer)
    vim.keymap.set("n", "glrd", gitlab.delete_reviewer)
    vim.keymap.set("n", "glp", gitlab.pipeline)
    vim.keymap.set("n", "glo", gitlab.open_in_browser)
    vim.keymap.set("n", "glM", gitlab.merge)
    vim.keymap.set("n", "glu", gitlab.copy_mr_url)
    vim.keymap.set("n", "glP", gitlab.publish_all_drafts)
    vim.keymap.set("n", "glD", gitlab.toggle_draft_mode)
<

TROUBLESHOOTING                                  *gitlab.nvim.troubleshooting*

To check that the current settings of the plugin are configured correctly,~
please run:~
>lua
    require("gitlab").print_settings()
<
This plugin uses a Go server to reach out to Gitlab. It’s possible that
something is going wrong when starting that server or connecting with Gitlab.
The Go server runs outside of Neovim, and can be interacted with directly in
order to troubleshoot. To start the server, check out your feature branch and
run these commands:
>lua
    require("gitlab.server").build(true)
    require("gitlab.server").start(function() print("Server started") end)
<

The easiest way to debug what’s going wrong is to turn on the `debug` options
in your setup function. This will allow you to see requests leaving the Go
server, and the responses coming back from Gitlab. Once the server is running,
you can also interact with the Go server like any other process:
>
    curl --header "PRIVATE-TOKEN: ${GITLAB_TOKEN}" localhost:21036/mr/info
<
==============================================================================
LUA API                                                         *gitlab.nvim.api*

                                                                *gitlab.nvim.setup*
gitlab.setup() ~

Call this first to initialize the plugin. With no arguments, it will use the
default arguments outlined under "Configuring the Plugin".
>lua
  require("gitlab").setup()

  require("gitlab").setup({ port = 8392 })

  require("gitlab").setup({ discussion_tree = { blacklist = { "some_bot"} } })
<
                                                                *gitlab.nvim.choose_merge_request*
gitlab.choose_merge_request({opts}) ~

Choose a merge request from a list of those open in your current project to
review. This command will automatically check out the feature branch locally,
and by default also open the reviewer pane (this can be overridden with the
`open_reviewer` parameter).
>lua
  require("gitlab").choose_merge_request()
  require("gitlab").choose_merge_request({ open_reviewer = false })
<
    Parameters: ~
        • {opts}: (table|nil) Keyword arguments to configure the checkout.
            • {open_reviewer}: (boolean) Whether to open the reviewer after
            switching branches. True by default.
<
                                                                *gitlab.nvim.review*
gitlab.review() ~

Opens the reviewer pane. Can be used from anywhere within Neovim after the
plugin is loaded. If run twice, will open a second reviewer pane.
>lua
  require("gitlab").review()
<
                                                                *gitlab.nvim.summary*
gitlab.summary() ~

Opens the summary window with information about the current MR, such as the
description, the author, and the title. Can be configured via the `info` field
in the setup call.
>lua
  require("gitlab").summary()

The summary can be edited. Once you have made changes, send them to Gitlab via
the `settings.popup.perform_action` keybinding.

                                                                *gitlab.nvim.approve*
gitlab.approve() ~

Approves the current MR. Will error if the current user does not have
permission.
>lua
  require("gitlab").approve()
<
                                                                *gitlab.nvim.revoke*
gitlab.revoke() ~

Revokes approval for the current MR. Will error if the current user does not
have permission or has not previously approved the MR.
>lua
  require("gitlab").approve()
<
                                                                *gitlab.nvim.create_comment*
gitlab.create_comment() ~

Opens a popup to create a comment on the current line. Must be called when focused on the
reviewer pane (see the gitlab.nvim.review command), otherwise it will error.
>lua
  require("gitlab").create_comment()

After the comment is typed, submit it to Gitlab via the `settings.popup.perform_action`
keybinding, by default `<leader>l`.

                                                                *gitlab.nvim.create_multiline_comment*
gitlab.create_multiline_comment() ~

Opens a popup to create a multi-line comment. May only be called in visual
mode, and will use the currently selected lines.
>lua
  require("gitlab").create_multiline_comment()

After the comment is typed, submit it to Gitlab via the |settings.popup.perform_linewise_action|
keybinding, by default `<leader>l`.

                                                                *gitlab.nvim.create_comment_suggestion*
gitlab.create_comment_suggestion() ~

Opens a popup to create a comment suggestion (aka a comment that makes a committable
change suggestion to the currently selected lines).
>lua
  require("gitlab").create_multiline_comment()

After the comment is typed, submit it to Gitlab via the |settings.popup.perform_linewise_action|
keybinding, by default |<leader>l|

                                                                *gitlab.nvim.create_mr*
gitlab.create_mr({opts}) ~

Starts the process of creating an MR for the currently checked out branch.
>lua
  require("gitlab").create_mr()
  require("gitlab").create_mr({ target = "main" })
  require("gitlab").create_mr({ target = "main", template_file = "my-template.md" })
  require("gitlab").create_mr({ title = "Fix bug XYZ", description = "Closes #123" })
<
    Parameters: ~
        • {opts}: (table|nil) Keyword arguments that can be used to skip
          certain steps in the MR creation process. `target` and
          `template_file` can also be configured via the `gitlab.setup()`
          function in the `settings.create_mr` field. If any field is missing,
          you will be prompted to select a value interactively:
            • {target}: (string) Name of the target branch.
            • {template_file}: (string) Name of file (relative to
              `.gitlab/merge_request_templates`) that will be used for the MR
              description. See also
              <https://docs.gitlab.com/ee/user/project/description_templates.html>.
            • {description}: (string) String used for the MR description.
              Takes precedence over the {template_file}, if both options are
              used.
            • {title}: (string) MR title.
            • {delete_branch}: (bool) If true, the source branch will be
              marked for deletion.
            • {squash}: (bool) If true, the commits will be marked for
              squashing.

After selecting all necessary details, you'll be presented with a confirmation
window. You can cycle through the individual fields with the keymaps defined
in `settings.popup.keymaps.next_field` and `settings.popup.keymaps.prev_field`.
Both keymaps accept a count, i.g., 2<Tab> goes to the 2nd next field.
In the "Delete source branch", "Squash commits", and "Target branch" fields,
you can use the `settings.popup.perform_linewise_action` keymap to either
toggle the Boolean value or to select a new target branch, respectively.
Use the `settings.popup.perform_action` keymap to POST the MR to Gitlab.

                                                                *gitlab.nvim.move_to_discussion_tree_from_diagnostic*
gitlab.move_to_discussion_tree_from_diagnostic() ~

When hovering over a diagnostic in the reviewer pane, jumps to the relevant
node in the discussion tree.
>lua
  require("gitlab").move_to_discussion_tree_from_diagnostic()

If there are no diagnostics for the current line, shows a warning message.

                                                                *gitlab.nvim.create_note*
gitlab.create_note() ~

Opens a popup to create a note. Notes are like comments except they are not
tied to specific changes in an MR.
>lua
  require("gitlab").create_note()

After the comment is typed, submit it to Gitlab via the `settings.popup.perform_action`
keybinding, by default |<leader>s|.

                                                                *gitlab.nvim.toggle_discussions*
gitlab.toggle_discussions() ~

Toggles visibility of the discussion tree.
>lua
  require("gitlab").toggle_discussions()

Once the discussion tree is open, a number of different keybindings are available
for interacting with different discussions. Please see the `settings.discussion_tree`
section of the setup call for more information about different keybindings.

                                                                *gitlab.nvim.publish_all_drafts*
gitlab.publish_all_drafts() ~

Publishes all unpublished draft notes. Used to finish a review and make all notes and 
comments visible.
>lua
  require("gitlab").publish_all_drafts()
<
                                                                *gitlab.nvim.toggle_draft_mode*
gitlab.toggle_draft_mode() ~

Toggles between draft mode, where comments and notes are added to a review as
drafts, and regular (or live) mode, where comments are posted immediately.

                                                                *gitlab.nvim.add_assignee*
gitlab.add_assignee() ~

Opens up a select menu for choosing an assignee for the current merge request.
>lua
  require("gitlab").add_assignee()
<
                                                                *gitlab.nvim.delete_assignee*
gitlab.delete_assignee() ~

Opens up a select menu for removing an existing assignee for the current merge request.
>lua
  require("gitlab").delete_assignee()
<
                                                                *gitlab.nvim.add_reviewer*
gitlab.add_reviewer() ~

Opens up a select menu for adding a reviewer for the current merge request.
>lua
  require("gitlab").add_reviewer()
<
                                                                *gitlab.nvim.add_label*
gitlab.add_label() ~

Opens up a select menu for adding a label to the current merge request.
>lua
  require("gitlab").add_label()
<
                                                                *gitlab.nvim.delete_label*
gitlab.delete_label() ~

Opens up a select menu for removing an existing label from the current merge request.
>lua
  require("gitlab").delete_label()
<
                                                                *gitlab.nvim.delete_reviewer*
gitlab.delete_reviewer() ~

Opens up a select menu for removing an existing reviewer for the current merge request.
>lua
  require("gitlab").delete_reviewer()
<
                                                                *gitlab.nvim.pipeline*
gitlab.pipeline() ~

Opens up a popup with information about the pipeline for the current merge request.
>lua
  require("gitlab").pipeline()
<
To re-trigger failed jobs in the pipeline manually, use the `settings.popup.perform_action` keybinding.
To open the log trace of a job in a new Neovim buffer, use your `settings.popup.perform_linewise_action`
keybinding.

                                                                *gitlab.nvim.open_in_browser*
gitlab.open_in_browser() ~

Opens the current MR in your default web browser.
>lua
  require("gitlab").open_in_browser()
<
                                                                *gitlab.nvim.copy_mr_url*
gitlab.copy_mr_url() ~

Copies the URL of the current MR to system clipboard.
>lua
  require("gitlab").copy_mr_url()
<
                                                                *gitlab.nvim.merge*
gitlab.merge({opts}) ~

Merges the merge request into the target branch. When run without any
arguments, the `merge` action will respect the "Squash commits" and "Delete
source branch" settings set by `require("gitlab").create_mr()` or set in
Gitlab online. You can see the current settings in the Summary view, see
|gitlab.nvim.the-summary-view|.
>lua
  require("gitlab").merge()
  require("gitlab").merge({ squash = false, delete_branch = true })
<
    Parameters: ~
        • {opts}: (table|nil) Keyword arguments that can be used to override
          default behavior.
            • {delete_branch}: (bool) If true, the source branch will be
              deleted.
            • {squash}: (bool) If true, the commits will be squashed. If
              you enable {squash} you will be prompted for a squash
              message. To use the default message, leave the popup empty.
              Use the `settings.popup.perform_action` to merge the MR with
              your message.

                                                                *gitlab.nvim.data*
gitlab.data({resources}, {cb}) ~

The data function can be used to integrate `gitlab.nvim` with other plugins
and tooling, by fetching raw data about the current MR, including the summary
information (title, description, etc); reviewers, assignees, pipeline status.
>lua
  require("gitlab").data({
    { type = "info", refresh = false },
    { type = "user", refresh = false } }, function (data)
      vim.print("The info data is: ", data.info)
      vim.print("The user data is: ", data.user)
  end)

If the resources have not yet been fetched from Gitlab, this function will
perform API calls for them. Once the data has been fetched, the callback will
execute and passed the data as an argument.

    Parameters: ~
        • {resources}: (table) A list of {resource} blocks to fetch.
            • {resource}: (table) A resource to fetch, such as job
              information, etc. The resource is defined by its {type}:
                • {type}: (string) The type of resource, either:
                    • "user": Information about the currently authenticated
                      user.
                    • "labels": The labels available in the current project.
                    • "project_members": The list of current project members.
                    • "revisions": Revision information about the MR.
                    • "pipeline": Information about the current branch's
                      pipeline. Returns and object with `latest_pipeline` and
                      `jobs` as fields.
                    • "draft_notes": The current user's unpublished notes
                • {refresh}: (bool) Whether to re-fetch the data from Gitlab
                  or use the cached data locally, if available.
        • {cb}: (function) The callback function that runs after all of the
          resources have been fetched. Will be passed a table with the data,
          with each resource as a key-value pair, with the key being it's
          type.

vim:tw=78:ts=4:sw=4:expandtab:ft=help:norl: