commit 15a4c2cb8c06cdf043d88803f2e23beb67f26b19 · veryroundbird.house/core

+8 -8

knotserver/git/merge.go

···

       12
       12
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       13
       13
        
       )

     

       14
       14
        
       

     

       15
       15
       -
       type MergeError struct {

     

       15
       15
       +
       type ErrMerge struct {

     

       16
       16
        
       	Message     string

     

       17
       17
        
       	Conflicts   []ConflictInfo

     

       18
       18
        
       	HasConflict bool

     
···

       24
       24
        
       	Reason   string

     

       25
       25
        
       }

     

       26
       26
        
       

     

       27
       27
       -
       func (e MergeError) Error() string {

     

       27
       27
       +
       func (e ErrMerge) Error() string {

     

       28
       28
        
       	if e.HasConflict {

     

       29
       29
        
       		return fmt.Sprintf("merge failed due to conflicts: %s (%d conflicts)", e.Message, len(e.Conflicts))

     

       30
       30
        
       	}

     
···

       90
       90
        
       	if err := cmd.Run(); err != nil {

     

       91
       91
        
       		if checkOnly {

     

       92
       92
        
       			conflicts := parseGitApplyErrors(stderr.String())

     

       93
       93
       -
       			return &MergeError{

     

       93
       93
       +
       			return &ErrMerge{

     

       94
       94
        
       				Message:     "patch cannot be applied cleanly",

     

       95
       95
        
       				Conflicts:   conflicts,

     

       96
       96
        
       				HasConflict: len(conflicts) > 0,

     
···

       106
       106
        
       func (g *GitRepo) MergeCheck(patchData []byte, targetBranch string) error {

     

       107
       107
        
       	patchFile, err := g.createTempFileWithPatch(patchData)

     

       108
       108
        
       	if err != nil {

     

       109
       109
       -
       		return &MergeError{

     

       109
       109
       +
       		return &ErrMerge{

     

       110
       110
        
       			Message:    err.Error(),

     

       111
       111
        
       			OtherError: err,

     

       112
       112
        
       		}

     
···

       115
       115
        
       

     

       116
       116
        
       	tmpDir, err := g.cloneRepository(targetBranch)

     

       117
       117
        
       	if err != nil {

     

       118
       118
       -
       		return &MergeError{

     

       118
       118
       +
       		return &ErrMerge{

     

       119
       119
        
       			Message:    err.Error(),

     

       120
       120
        
       			OtherError: err,

     

       121
       121
        
       		}

     
···

       128
       128
        
       func (g *GitRepo) Merge(patchData []byte, targetBranch string) error {

     

       129
       129
        
       	patchFile, err := g.createTempFileWithPatch(patchData)

     

       130
       130
        
       	if err != nil {

     

       131
       131
       -
       		return &MergeError{

     

       131
       131
       +
       		return &ErrMerge{

     

       132
       132
        
       			Message:    err.Error(),

     

       133
       133
        
       			OtherError: err,

     

       134
       134
        
       		}

     
···

       137
       137
        
       

     

       138
       138
        
       	tmpDir, err := g.cloneRepository(targetBranch)

     

       139
       139
        
       	if err != nil {

     

       140
       140
       -
       		return &MergeError{

     

       140
       140
       +
       		return &ErrMerge{

     

       141
       141
        
       			Message:    err.Error(),

     

       142
       142
        
       			OtherError: err,

     

       143
       143
        
       		}

     
···

       150
       150
        
       

     

       151
       151
        
       	pushCmd := exec.Command("git", "-C", tmpDir, "push")

     

       152
       152
        
       	if err := pushCmd.Run(); err != nil {

     

       153
       153
       -
       		return &MergeError{

     

       153
       153
       +
       		return &ErrMerge{

     

       154
       154
        
       			Message:    "failed to push changes to bare repository",

     

       155
       155
        
       			OtherError: err,

     

       156
       156
        
       		}

+18 -18

knotserver/routes.go

···

       577
       577
        
       		notFound(w)

     

       578
       578
        
       		return

     

       579
       579
        
       	}

     

       580
       580
       -
       

     

       581
       580
        
       	if err := gr.Merge([]byte(patch), branch); err != nil {

     

       582
       582
       -
       		var mergeErr *git.MergeError

     

       581
       581
       +
       		var mergeErr *git.ErrMerge

     

       583
       582
        
       		if errors.As(err, &mergeErr) {

     

       584
       584
       -
       			conflictDetails := make([]map[string]interface{}, len(mergeErr.Conflicts))

     

       583
       583
       +
       			conflicts := make([]types.ConflictInfo, len(mergeErr.Conflicts))

     

       585
       584
        
       			for i, conflict := range mergeErr.Conflicts {

     

       586
       586
       -
       				conflictDetails[i] = map[string]interface{}{

     

       587
       587
       -
       					"filename": conflict.Filename,

     

       588
       588
       -
       					"reason":   conflict.Reason,

     

       585
       585
       +
       				conflicts[i] = types.ConflictInfo{

     

       586
       586
       +
       					Filename: conflict.Filename,

     

       587
       587
       +
       					Reason:   conflict.Reason,

     

       589
       588
        
       				}

     

       590
       589
        
       			}

     

       591
       591
       -
       			response := map[string]interface{}{

     

       592
       592
       -
       				"message":   mergeErr.Message,

     

       593
       593
       -
       				"conflicts": conflictDetails,

     

       590
       590
       +
       			response := types.MergeCheckResponse{

     

       591
       591
       +
       				IsConflicted: true,

     

       592
       592
       +
       				Conflicts:    conflicts,

     

       593
       593
       +
       				Message:      mergeErr.Message,

     

       594
       594
        
       			}

     

       595
       595
        
       			writeConflict(w, response)

     

       596
       596
        
       			h.l.Error("git: merge conflict", "handler", "Merge", "error", mergeErr)

     
···

       632
       632
        
       		return

     

       633
       633
        
       	}

     

       634
       634
        
       

     

       635
       635
       -
       	var mergeErr *git.MergeError

     

       635
       635
       +
       	var mergeErr *git.ErrMerge

     

       636
       636
        
       	if errors.As(err, &mergeErr) {

     

       637
       637
       -
       		conflictDetails := make([]map[string]interface{}, len(mergeErr.Conflicts))

     

       637
       637
       +
       		conflicts := make([]types.ConflictInfo, len(mergeErr.Conflicts))

     

       638
       638
        
       		for i, conflict := range mergeErr.Conflicts {

     

       639
       639
       -
       			conflictDetails[i] = map[string]interface{}{

     

       640
       640
       -
       				"filename": conflict.Filename,

     

       641
       641
       -
       				"reason":   conflict.Reason,

     

       639
       639
       +
       			conflicts[i] = types.ConflictInfo{

     

       640
       640
       +
       				Filename: conflict.Filename,

     

       641
       641
       +
       				Reason:   conflict.Reason,

     

       642
       642
        
       			}

     

       643
       643
        
       		}

     

       644
       644
       -
       		response := map[string]interface{}{

     

       645
       645
       -
       			"message":   mergeErr.Message,

     

       646
       646
       -
       			"conflicts": conflictDetails,

     

       644
       644
       +
       		response := types.MergeCheckResponse{

     

       645
       645
       +
       			IsConflicted: true,

     

       646
       646
       +
       			Conflicts:    conflicts,

     

       647
       647
       +
       			Message:      mergeErr.Message,

     

       647
       648
        
       		}

     

       648
       649
        
       		writeConflict(w, response)

     

       649
       650
        
       		h.l.Error("git: merge conflict", "handler", "MergeCheck", "error", mergeErr.Error())

     

       650
       651
        
       		return

     

       651
       652
        
       	}

     

       652
       652
       -
       

     

       653
       653
        
       	writeError(w, err.Error(), http.StatusInternalServerError)

     

       654
       654
        
       	h.l.Error("git: failed to check merge", "handler", "MergeCheck", "error", err.Error())

     

       655
       655
        
       }

+12

types/merge.go

···

       1
       1
        
       package types

     

       2
       2
       +
       

     

       3
       3
       +
       type ConflictInfo struct {

     

       4
       4
       +
       	Filename string `json:"filename"`

     

       5
       5
       +
       	Reason   string `json:"reason"`

     

       6
       6
       +
       }

     

       7
       7
       +
       

     

       8
       8
       +
       type MergeCheckResponse struct {

     

       9
       9
       +
       	IsConflicted bool           `json:"is_conflicted"`

     

       10
       10
       +
       	Conflicts    []ConflictInfo `json:"conflicts"`

     

       11
       11
       +
       	Message      string         `json:"message"`

     

       12
       12
       +
       	Error        string         `json:"error"`

     

       13
       13
       +
       }