commit e1357392b20ae02ac1748508cae667c09bdf09ab · notnite.com/core

+31

knotserver/git/diff.go

···

       1
       1
        
       package git

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"bytes"

     

       4
       5
        
       	"fmt"

     

       5
       6
        
       	"log"

     

       7
       7
       +
       	"os"

     

       8
       8
       +
       	"os/exec"

     

       6
       9
        
       	"strings"

     

       7
       10
        
       

     

       8
       11
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

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

     

       10
       13
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       14
       14
       +
       	"tangled.sh/tangled.sh/core/patchutil"

     

       11
       15
        
       	"tangled.sh/tangled.sh/core/types"

     

       12
       16
        
       )

     

       13
       17
        
       

     
···

       118
       122
        
       		Patch: patch.String(),

     

       119
       123
        
       		Diff:  diffs,

     

       120
       124
        
       	}, nil

     

       125
       125
       +
       }

     

       126
       126
       +
       

     

       127
       127
       +
       // FormatPatch generates a git-format-patch output between two commits,

     

       128
       128
       +
       // and returns the raw format-patch series, a parsed FormatPatch and an error.

     

       129
       129
       +
       func (g *GitRepo) FormatPatch(base, commit2 *object.Commit) (string, []patchutil.FormatPatch, error) {

     

       130
       130
       +
       	var stdout bytes.Buffer

     

       131
       131
       +
       	cmd := exec.Command(

     

       132
       132
       +
       		"git",

     

       133
       133
       +
       		"-C",

     

       134
       134
       +
       		g.path,

     

       135
       135
       +
       		"format-patch",

     

       136
       136
       +
       		fmt.Sprintf("%s..%s", base.Hash.String(), commit2.Hash.String()),

     

       137
       137
       +
       		"--stdout",

     

       138
       138
       +
       	)

     

       139
       139
       +
       	cmd.Stdout = &stdout

     

       140
       140
       +
       	cmd.Stderr = os.Stderr

     

       141
       141
       +
       	err := cmd.Run()

     

       142
       142
       +
       	if err != nil {

     

       143
       143
       +
       		return "", nil, err

     

       144
       144
       +
       	}

     

       145
       145
       +
       

     

       146
       146
       +
       	formatPatch, err := patchutil.ExtractPatches(stdout.String())

     

       147
       147
       +
       	if err != nil {

     

       148
       148
       +
       		return "", nil, err

     

       149
       149
       +
       	}

     

       150
       150
       +
       

     

       151
       151
       +
       	return stdout.String(), formatPatch, nil

     

       121
       152
        
       }

     

       122
       153
        
       

     

       123
       154
        
       func (g *GitRepo) MergeBase(commit1, commit2 *object.Commit) (*object.Commit, error) {

+7 -2

knotserver/routes.go

···

       808
       808
        
       		return

     

       809
       809
        
       	}

     

       810
       810
        
       

     

       811
       811
       -
       	difftree, err := gr.DiffTree(mergeBase, commit2)

     

       811
       811
       +
       	rawPatch, formatPatch, err := gr.FormatPatch(mergeBase, commit2)

     

       812
       812
        
       	if err != nil {

     

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

     

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

     

       815
       815
        
       		return

     

       816
       816
        
       	}

     

       817
       817
        
       

     

       818
       818
       -
       	writeJSON(w, types.RepoDiffTreeResponse{difftree})

     

       818
       818
       +
       	writeJSON(w, types.RepoFormatPatchResponse{

     

       819
       819
       +
       		Rev1:        commit1.Hash.String(),

     

       820
       820
       +
       		Rev2:        commit2.Hash.String(),

     

       821
       821
       +
       		FormatPatch: formatPatch,

     

       822
       822
       +
       		Patch:       rawPatch,

     

       823
       823
       +
       	})

     

       819
       824
        
       	return

     

       820
       825
        
       }

     

       821
       826