feat: implement rebasing

Author: jakubbortlik

cmd/app/rebase_mr.go

@@ -0,0 +1,57 @@
+package app
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	gitlab "gitlab.com/gitlab-org/api/client-go"
+)
+
+type RebaseMrRequest struct {
+	SkipCI bool `json:"skip_ci,omitempty"`
+}
+
+type MergeRequestRebaser interface {
+	RebaseMergeRequest(pid interface{}, mergeRequest int64, opt *gitlab.RebaseMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
+}
+
+type mergeRequestRebaserService struct {
+	data
+	client MergeRequestRebaser
+}
+
+/* Rebases a merge request on the server */
+func (a mergeRequestRebaserService) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+
+	payload := r.Context().Value(payload("payload")).(*RebaseMrRequest)
+
+	opts := gitlab.RebaseMergeRequestOptions{
+		SkipCI: &payload.SkipCI,
+	}
+
+	res, err := a.client.RebaseMergeRequest(a.projectInfo.ProjectId, a.projectInfo.MergeId, &opts)
+
+	if err != nil {
+		handleError(w, err, "Could not rebase MR", http.StatusInternalServerError)
+		return
+	}
+
+	if res.StatusCode >= 300 {
+		handleError(w, GenericError{r.URL.Path}, "Could not rebase MR", res.StatusCode)
+		return
+	}
+
+	skippingCI := ""
+	if payload.SkipCI {
+		skippingCI = " (skipping CI)"
+	}
+	response := SuccessResponse{Message: fmt.Sprintf("MR rebased successfully%s", skippingCI)}
+
+	w.WriteHeader(http.StatusOK)
+
+	err = json.NewEncoder(w).Encode(response)
+	if err != nil {
+		handleError(w, err, "Could not encode response", http.StatusInternalServerError)
+	}
+}

cmd/app/rebase_mr_test.go

@@ -0,0 +1,78 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	gitlab "gitlab.com/gitlab-org/api/client-go"
+)
+
+type fakeMergeRequestRebaser struct {
+	testBase
+}
+
+func (f fakeMergeRequestRebaser) RebaseMergeRequest(pid interface{}, mergeRequest int64, opt *gitlab.RebaseMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, err
+	}
+
+	return resp, err
+}
+
+func TestRebaseHandler(t *testing.T) {
+	var testRebaseMrPayload = RebaseMrRequest{SkipCI: false}
+	t.Run("Rebases merge request", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/rebase", testRebaseMrPayload)
+		svc := middleware(
+			mergeRequestRebaserService{testProjectData, fakeMergeRequestRebaser{}},
+			withMr(testProjectData, fakeMergeRequestLister{}),
+			withPayloadValidation(methodToPayload{
+				http.MethodPost: newPayload[RebaseMrRequest],
+			}),
+			withMethodCheck(http.MethodPost),
+		)
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "MR rebased successfully")
+	})
+	var testRebaseMrPayloadSkipCI = RebaseMrRequest{SkipCI: true}
+	t.Run("Rebases merge request and skips CI", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/rebase", testRebaseMrPayloadSkipCI)
+		svc := middleware(
+			mergeRequestRebaserService{testProjectData, fakeMergeRequestRebaser{}},
+			withMr(testProjectData, fakeMergeRequestLister{}),
+			withPayloadValidation(methodToPayload{
+				http.MethodPost: newPayload[RebaseMrRequest],
+			}),
+			withMethodCheck(http.MethodPost),
+		)
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "MR rebased successfully (skipping CI)")
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/rebase", testRebaseMrPayload)
+		svc := middleware(
+			mergeRequestRebaserService{testProjectData, fakeMergeRequestRebaser{testBase{errFromGitlab: true}}},
+			withMr(testProjectData, fakeMergeRequestLister{}),
+			withPayloadValidation(methodToPayload{
+				http.MethodPost: newPayload[RebaseMrRequest],
+			}),
+			withMethodCheck(http.MethodPost),
+		)
+		data, _ := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not rebase MR")
+	})
+	t.Run("Handles non-200s from Gitlab", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/rebase", testRebaseMrPayload)
+		svc := middleware(
+			mergeRequestRebaserService{testProjectData, fakeMergeRequestRebaser{testBase{status: http.StatusSeeOther}}},
+			withMr(testProjectData, fakeMergeRequestLister{}),
+			withPayloadValidation(methodToPayload{
+				http.MethodPost: newPayload[RebaseMrRequest],
+			}),
+			withMethodCheck(http.MethodPost),
+		)
+		data, _ := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not rebase MR", "/mr/rebase")
+	})
+}

cmd/app/server.go

@@ -117,6 +117,12 @@ func CreateRouter(gitlabClient *Client, projectInfo *ProjectInfo, s *shutdownSer
 		withPayloadValidation(methodToPayload{http.MethodPost: newPayload[AcceptMergeRequestRequest]}),
 		withMethodCheck(http.MethodPost),
 	))
+	m.HandleFunc("/mr/rebase", middleware(
+		mergeRequestRebaserService{d, gitlabClient},
+		withMr(d, gitlabClient),
+		withPayloadValidation(methodToPayload{http.MethodPost: newPayload[RebaseMrRequest]}),
+		withMethodCheck(http.MethodPost),
+	))
 	m.HandleFunc("/mr/discussions/list", middleware(
 		discussionsListerService{d, gitlabClient},
 		withMr(d, gitlabClient),

doc/gitlab.nvim.txt

@@ -179,6 +179,8 @@ you call this function with no values the defaults will be used:
           approve = "glA", -- Approve MR
           revoke = "glR", -- Revoke MR approval
           merge = "glM", -- Merge the feature branch to the target branch and close MR
+          rebase = "glrr", -- Rebase the feature branch of the MR on the server and pull the new state
+          rebase_skip_ci = "glrs", -- Same as `rebase`, but skip the CI pipeline
           create_mr = "glC", -- Create a new MR for currently checked-out feature branch
           choose_merge_request = "glc", -- Chose MR for review (if necessary check out the feature branch)
           start_review = "glS", -- Start review for the currently checked-out branch
@@ -1045,6 +1047,20 @@ Gitlab online. You can see the current settings in the Summary view, see
               Use the `keymaps.popup.perform_action` to merge the MR
               with your message.
 
+                                                                *gitlab.nvim.rebase*
+gitlab.rebase({opts}) ~
+
+Rebases the feature branch of the MR on the server and pulls the new state of
+the target branch.
+>lua
+  require("gitlab").rebase()
+  require("gitlab").rebase({ skip_ci = true })
+<
+    Parameters: ~
+        • {opts}: (table|nil) Keyword arguments that can be used to override
+          default behavior.
+            • {skip_ci}: (bool) If true, the CI pipeline will be skipped.
+
                                                                 *gitlab.nvim.data*
 gitlab.data({resources}, {cb}) ~
 

lua/gitlab/actions/rebase.lua

@@ -0,0 +1,49 @@
+local u = require("gitlab.utils")
+
+local M = {}
+
+---@class RebaseOpts
+---@field skip_ci boolean?
+
+local can_rebase = function()
+  local git = require("gitlab.git")
+  -- Check if there are local changes (couldn't run `git pull` after rebasing)
+  local has_clean_tree, err = git.has_clean_tree()
+  if not has_clean_tree then
+    u.notify("Cannot rebase when there are changed files", vim.log.levels.ERROR)
+    return false
+  elseif err ~= nil then
+    u.notify("Error while inspecting working tree", vim.log.levels.ERROR)
+    return false
+  end
+  return true
+end
+
+---@param opts RebaseOpts
+M.rebase = function(opts)
+  if not can_rebase() then
+    return
+  end
+
+  -- TODO: check that MR needs rebasing (requires https://github.com/harrisoncramer/gitlab.nvim/pull/532)
+
+  local state = require("gitlab.state")
+  local rebase_body = { skip_ci = state.settings.rebase_mr.skip_ci }
+  if opts and opts.skip_ci ~= nil then
+    rebase_body.skip_ci = opts.skip_ci
+  end
+
+  M.confirm_rebase(rebase_body)
+end
+
+---@param merge_body RebaseOpts
+M.confirm_rebase = function(merge_body)
+  local job = require("gitlab.job")
+  job.run_job("/mr/rebase", "POST", merge_body, function(data)
+    u.notify(data.message, vim.log.levels.INFO)
+    u.notify("Implement pulling", vim.log.levels.INFO)
+    u.notify("Implement updating the reviewer", vim.log.levels.INFO)
+  end)
+end
+
+return M

lua/gitlab/annotations.lua

@@ -162,6 +162,7 @@
 ---@field discussion_signs? DiscussionSigns -- The settings for discussion signs/diagnostics
 ---@field pipeline? PipelineSettings -- The settings for the pipeline popup
 ---@field create_mr? CreateMrSettings -- The settings when creating an MR
+---@field rebase_mr? RebaseMrSettings -- The settings when rebasing an MR
 ---@field colors? ColorSettings --- Colors settings for the plugin
 
 ---@class DiscussionSigns: table
@@ -196,6 +197,9 @@
 ---@field title_input? TitleInputSettings
 ---@field fork? ForkSettings
 
+---@class RebaseMrSettings: table
+---@field skip_ci? boolean -- Whether to skip CI after rabasing
+
 ---@class ForkSettings: table
 ---@field enabled? boolean -- If making an MR from a fork
 ---@field forked_project_id? number -- The Gitlab ID of the project you are merging into. If nil, will be prompted.

lua/gitlab/init.lua

@@ -8,6 +8,7 @@ local reviewer = require("gitlab.reviewer")
 local discussions = require("gitlab.actions.discussions")
 local merge_requests = require("gitlab.actions.merge_requests")
 local merge = require("gitlab.actions.merge")
+local rebase = require("gitlab.actions.rebase")
 local summary = require("gitlab.actions.summary")
 local data = require("gitlab.actions.data")
 local assignees_and_reviewers = require("gitlab.actions.assignees_and_reviewers")
@@ -86,6 +87,7 @@ return {
   end,
   pipeline = async.sequence({ latest_pipeline }, pipeline.open),
   merge = async.sequence({ u.merge(info, { refresh = true }) }, merge.merge),
+  rebase = async.sequence({ u.merge(info, { refresh = true }) }, rebase.rebase),
   -- Discussion Tree Actions 🌴
   toggle_discussions = function()
     if discussions.split_visible then

lua/gitlab/state.lua

@@ -81,6 +81,8 @@ M.settings = {
       approve = "glA",
       revoke = "glR",
       merge = "glM",
+      rebase = "glrr",
+      rebase_skip_ci = "glrs",
       create_mr = "glC",
       choose_merge_request = "glc",
       start_review = "glS",
@@ -196,6 +198,9 @@ M.settings = {
       border = "rounded",
     },
   },
+  rebase_mr = {
+    skip_ci = false,
+  },
   choose_merge_request = {
     open_reviewer = true,
   },
@@ -389,6 +394,18 @@ M.set_global_keymaps = function()
     end, { desc = "Merge MR", nowait = keymaps.global.merge_nowait })
   end
 
+  if keymaps.global.rebase then
+    vim.keymap.set("n", keymaps.global.rebase, function()
+      require("gitlab").rebase()
+    end, { desc = "Rebase MR", nowait = keymaps.global.rebase_nowait })
+  end
+
+  if keymaps.global.rebase_skip_ci then
+    vim.keymap.set("n", keymaps.global.rebase_skip_ci, function()
+      require("gitlab").rebase({ skip_ci = true })
+    end, { desc = "Rebase MR and skip CI", nowait = keymaps.global.rebase_skip_ci_nowait })
+  end
+
   if keymaps.global.copy_mr_url then
     vim.keymap.set("n", keymaps.global.copy_mr_url, function()
       require("gitlab").copy_mr_url()