back round 0 view raw

knotserver: git: remove MergeBase calculation #231

merged

opened by

oppi.li 6 months ago targeting master from push-ovrqrxnpvroz

the rev-list approach to building format-patch internally performs merge-base calculations.

Signed-off-by: oppiliappan me@oppi.li

options

unified split

Changed files

+3 -34

knotserver

git

diff.go

routes.go

types

repo.go

+1 -24

knotserver/git/diff.go

···

       166
       166
        
       	return stdout.String(), &formatPatch[0], nil

     

       167
       167
        
       }

     

       168
       168
        
       

     

       169
       169
       -
       func (g *GitRepo) MergeBase(commit1, commit2 *object.Commit) (*object.Commit, error) {

     

       170
       170
       -
       	isAncestor, err := commit1.IsAncestor(commit2)

     

       171
       171
       -
       	if err != nil {

     

       172
       172
       -
       		return nil, err

     

       173
       173
       -
       	}

     

       174
       174
       -
       

     

       175
       175
       -
       	if isAncestor {

     

       176
       176
       -
       		return commit1, nil

     

       177
       177
       -
       	}

     

       178
       178
       -
       

     

       179
       179
       -
       	mergeBase, err := commit1.MergeBase(commit2)

     

       180
       180
       -
       	if err != nil {

     

       181
       181
       -
       		return nil, err

     

       182
       182
       -
       	}

     

       183
       183
       -
       

     

       184
       184
       -
       	if len(mergeBase) == 0 {

     

       185
       185
       -
       		return nil, fmt.Errorf("failed to find a merge-base")

     

       186
       186
       -
       	}

     

       187
       187
       -
       

     

       188
       188
       -
       	return mergeBase[0], nil

     

       189
       189
       -
       }

     

       190
       190
       -
       

     

       191
       169
        
       func (g *GitRepo) ResolveRevision(revStr string) (*object.Commit, error) {

     

       192
       170
        
       	rev, err := g.r.ResolveRevision(plumbing.Revision(revStr))

     

       193
       171
        
       	if err != nil {

     
···

       224
       202
        
       		if err != nil {

     

       225
       203
        
       			continue

     

       226
       204
        
       		}

     

       227
       227
       -
       

     

       228
       205
        
       		commits = append(commits, obj)

     

       229
       206
        
       	}

     

       230
       207
        
       

     
···

       232
       209
        
       }

     

       233
       210
        
       

     

       234
       211
        
       func (g *GitRepo) FormatPatch(base, commit2 *object.Commit) (string, []types.FormatPatch, error) {

     

       235
       235
       -
       	// get list of commits between commir2 and base

     

       212
       212
       +
       	// get list of commits between commit2 and base

     

       236
       213
        
       	commits, err := g.commitsBetween(commit2, base)

     

       237
       214
        
       	if err != nil {

     

       238
       215
        
       		return "", nil, fmt.Errorf("failed to get commits: %w", err)

+1 -9

knotserver/routes.go

···

       1096
       1096
        
       		return

     

       1097
       1097
        
       	}

     

       1098
       1098
        
       

     

       1099
       1099
       -
       	mergeBase, err := gr.MergeBase(commit1, commit2)

     

       1100
       1100
       -
       	if err != nil {

     

       1101
       1101
       -
       		l.Error("failed to find merge-base", "msg", err.Error())

     

       1102
       1102
       -
       		writeError(w, "failed to calculate diff", http.StatusBadRequest)

     

       1103
       1103
       -
       		return

     

       1104
       1104
       -
       	}

     

       1105
       1105
       -
       

     

       1106
       1106
       -
       	rawPatch, formatPatch, err := gr.FormatPatch(mergeBase, commit2)

     

       1099
       1099
       +
       	rawPatch, formatPatch, err := gr.FormatPatch(commit1, commit2)

     

       1107
       1100
        
       	if err != nil {

     

       1108
       1101
        
       		l.Error("error comparing revisions", "msg", err.Error())

     

       1109
       1102
        
       		writeError(w, "error comparing revisions", http.StatusBadRequest)

     
···

       1114
       1107
        
       		Rev1:        commit1.Hash.String(),

     

       1115
       1108
        
       		Rev2:        commit2.Hash.String(),

     

       1116
       1109
        
       		FormatPatch: formatPatch,

     

       1117
       1117
       -
       		MergeBase:   mergeBase.Hash.String(),

     

       1118
       1110
        
       		Patch:       rawPatch,

     

       1119
       1111
        
       	})

     

       1120
       1112
        
       	return

+1 -1

types/repo.go

···

       36
       36
        
       	Rev1        string        `json:"rev1,omitempty"`

     

       37
       37
        
       	Rev2        string        `json:"rev2,omitempty"`

     

       38
       38
        
       	FormatPatch []FormatPatch `json:"format_patch,omitempty"`

     

       39
       39
       -
       	MergeBase   string        `json:"merge_base,omitempty"`

     

       39
       39
       +
       	MergeBase   string        `json:"merge_base,omitempty"` // deprecated

     

       40
       40
        
       	Patch       string        `json:"patch,omitempty"`

     

       41
       41
        
       }

     

       42
       42