summaryrefslogtreecommitdiff
path: root/diff.go
diff options
context:
space:
mode:
Diffstat (limited to 'diff.go')
-rw-r--r--diff.go258
1 files changed, 163 insertions, 95 deletions
diff --git a/diff.go b/diff.go
index bf08c8b..31000bc 100644
--- a/diff.go
+++ b/diff.go
@@ -12,72 +12,75 @@ import (
)
type DiffFlag int
+
const (
- DiffFlagBinary = DiffFlag(C.GIT_DIFF_FLAG_BINARY)
- DiffFlagNotBinary = C.GIT_DIFF_FLAG_NOT_BINARY
- DiffFlagValidOid = C.GIT_DIFF_FLAG_VALID_OID
+ DiffFlagBinary DiffFlag = C.GIT_DIFF_FLAG_BINARY
+ DiffFlagNotBinary = C.GIT_DIFF_FLAG_NOT_BINARY
+ DiffFlagValidOid = C.GIT_DIFF_FLAG_VALID_OID
)
type Delta int
+
const (
- DeltaUnmodified = Delta(C.GIT_DELTA_UNMODIFIED)
- DeltaAdded = C.GIT_DELTA_ADDED
- DeltaDeleted = C.GIT_DELTA_DELETED
- DeltaModified = C.GIT_DELTA_MODIFIED
- DeltaRenamed = C.GIT_DELTA_RENAMED
- DeltaCopied = C.GIT_DELTA_COPIED
- DeltaIgnored = C.GIT_DELTA_IGNORED
- DeltaUntracked = C.GIT_DELTA_UNTRACKED
- DeltaTypeChange = C.GIT_DELTA_TYPECHANGE
+ DeltaUnmodified Delta = C.GIT_DELTA_UNMODIFIED
+ DeltaAdded = C.GIT_DELTA_ADDED
+ DeltaDeleted = C.GIT_DELTA_DELETED
+ DeltaModified = C.GIT_DELTA_MODIFIED
+ DeltaRenamed = C.GIT_DELTA_RENAMED
+ DeltaCopied = C.GIT_DELTA_COPIED
+ DeltaIgnored = C.GIT_DELTA_IGNORED
+ DeltaUntracked = C.GIT_DELTA_UNTRACKED
+ DeltaTypeChange = C.GIT_DELTA_TYPECHANGE
)
type DiffLineType int
+
const (
- DiffLineContext = DiffLineType(C.GIT_DIFF_LINE_CONTEXT)
- DiffLineAddition = C.GIT_DIFF_LINE_ADDITION
- DiffLineDeletion = C.GIT_DIFF_LINE_DELETION
- DiffLineContextEOFNL = C.GIT_DIFF_LINE_CONTEXT_EOFNL
- DiffLineAddEOFNL = C.GIT_DIFF_LINE_ADD_EOFNL
- DiffLineDelEOFNL = C.GIT_DIFF_LINE_DEL_EOFNL
+ DiffLineContext DiffLineType = C.GIT_DIFF_LINE_CONTEXT
+ DiffLineAddition = C.GIT_DIFF_LINE_ADDITION
+ DiffLineDeletion = C.GIT_DIFF_LINE_DELETION
+ DiffLineContextEOFNL = C.GIT_DIFF_LINE_CONTEXT_EOFNL
+ DiffLineAddEOFNL = C.GIT_DIFF_LINE_ADD_EOFNL
+ DiffLineDelEOFNL = C.GIT_DIFF_LINE_DEL_EOFNL
DiffLineFileHdr = C.GIT_DIFF_LINE_FILE_HDR
DiffLineHunkHdr = C.GIT_DIFF_LINE_HUNK_HDR
- DiffLineBinary = C.GIT_DIFF_LINE_BINARY
+ DiffLineBinary = C.GIT_DIFF_LINE_BINARY
)
type DiffFile struct {
- Path string
- Oid *Oid
- Size int
+ Path string
+ Oid *Oid
+ Size int
Flags DiffFlag
- Mode uint16
+ Mode uint16
}
-func newDiffFile(file *C.git_diff_file) *DiffFile {
+func newDiffFileFromC(file *C.git_diff_file) *DiffFile {
return &DiffFile{
- Path: C.GoString(file.path),
- Oid: newOidFromC(&file.oid),
- Size: int(file.size),
+ Path: C.GoString(file.path),
+ Oid: newOidFromC(&file.oid),
+ Size: int(file.size),
Flags: DiffFlag(file.flags),
- Mode: uint16(file.mode),
+ Mode: uint16(file.mode),
}
}
type DiffDelta struct {
- Status Delta
- Flags DiffFlag
+ Status Delta
+ Flags DiffFlag
Similarity uint16
- OldFile *DiffFile
- NewFile *DiffFile
+ OldFile *DiffFile
+ NewFile *DiffFile
}
-func newDiffDelta(delta *C.git_diff_delta) *DiffDelta {
+func newDiffDeltaFromC(delta *C.git_diff_delta) *DiffDelta {
return &DiffDelta{
- Status: Delta(delta.status),
- Flags: DiffFlag(delta.flags),
+ Status: Delta(delta.status),
+ Flags: DiffFlag(delta.flags),
Similarity: uint16(delta.similarity),
- OldFile: newDiffFile(&delta.old_file),
- NewFile: newDiffFile(&delta.new_file),
+ OldFile: newDiffFileFromC(&delta.old_file),
+ NewFile: newDiffFileFromC(&delta.new_file),
}
}
@@ -86,38 +89,38 @@ type DiffHunk struct {
OldLines int
NewStart int
NewLines int
- Header string
+ Header string
DiffDelta
}
-func newDiffHunk(delta *C.git_diff_delta, hunk *C.git_diff_hunk) *DiffHunk {
+func newDiffHunkFromC(delta *C.git_diff_delta, hunk *C.git_diff_hunk) *DiffHunk {
return &DiffHunk{
- OldStart: int(hunk.old_start),
- OldLines: int(hunk.old_lines),
- NewStart: int(hunk.new_start),
- NewLines: int(hunk.new_lines),
- Header: C.GoStringN(&hunk.header[0], C.int(hunk.header_len)),
- DiffDelta: *newDiffDelta(delta),
+ OldStart: int(hunk.old_start),
+ OldLines: int(hunk.old_lines),
+ NewStart: int(hunk.new_start),
+ NewLines: int(hunk.new_lines),
+ Header: C.GoStringN(&hunk.header[0], C.int(hunk.header_len)),
+ DiffDelta: *newDiffDeltaFromC(delta),
}
}
type DiffLine struct {
- Origin DiffLineType
+ Origin DiffLineType
OldLineno int
NewLineno int
- NumLines int
- Content string
+ NumLines int
+ Content string
DiffHunk
}
-func newDiffLine(delta *C.git_diff_delta, hunk *C.git_diff_hunk, line *C.git_diff_line) *DiffLine {
+func newDiffLineFromC(delta *C.git_diff_delta, hunk *C.git_diff_hunk, line *C.git_diff_line) *DiffLine {
return &DiffLine{
- Origin: DiffLineType(line.origin),
+ Origin: DiffLineType(line.origin),
OldLineno: int(line.old_lineno),
NewLineno: int(line.new_lineno),
- NumLines: int(line.num_lines),
- Content: C.GoStringN(line.content, C.int(line.content_len)),
- DiffHunk: *newDiffHunk(delta, hunk),
+ NumLines: int(line.num_lines),
+ Content: C.GoStringN(line.content, C.int(line.content_len)),
+ DiffHunk: *newDiffHunkFromC(delta, hunk),
}
}
@@ -125,7 +128,7 @@ type Diff struct {
ptr *C.git_diff
}
-func newDiff(ptr *C.git_diff) *Diff {
+func newDiffFromC(ptr *C.git_diff) *Diff {
if ptr == nil {
return nil
}
@@ -138,100 +141,165 @@ func newDiff(ptr *C.git_diff) *Diff {
return diff
}
-func (diff *Diff) Free() {
+func (diff *Diff) Free() error {
+ if diff.ptr != nil {
+ return ErrInvalid
+ }
runtime.SetFinalizer(diff, nil)
C.git_diff_free(diff.ptr)
+ return nil
}
-func (diff *Diff) forEachFileWrap(ch chan *DiffDelta) {
- C._go_git_diff_foreach(diff.ptr, 1, 0, 0, unsafe.Pointer(&ch))
- close(ch)
+type diffForEachFileData struct {
+ Callback DiffForEachFileCallback
+ Error error
}
-func (diff *Diff) ForEachFile() chan *DiffDelta {
- ch := make(chan *DiffDelta, 0)
- go diff.forEachFileWrap(ch)
- return ch
+func (diff *Diff) ForEachFile(cb DiffForEachFileCallback) error {
+ if diff.ptr != nil {
+ return ErrInvalid
+ }
+
+ data := &diffForEachFileData{
+ Callback: cb,
+ }
+ ecode := C._go_git_diff_foreach(diff.ptr, 1, 0, 0, unsafe.Pointer(&data))
+ if ecode < 0 {
+ return data.Error
+ }
+ return nil
}
//export diffForEachFileCb
func diffForEachFileCb(delta *C.git_diff_delta, progress C.float, payload unsafe.Pointer) int {
- ch := *(*chan *DiffDelta)(payload)
+ data := *diffForEachFileData(payload)
- select {
- case ch <-newDiffDelta(delta):
- case <-ch:
+ err := data.Callback(newDiffDeltaFromC(delta))
+ if err != nil {
+ data.Error = err
return -1
}
return 0
}
-func (diff *Diff) forEachHunkWrap(ch chan *DiffHunk) {
- C._go_git_diff_foreach(diff.ptr, 0, 1, 0, unsafe.Pointer(&ch))
- close(ch)
+type diffForEachHunkData struct {
+ Callback DiffForEachHunkCallback
+ Error error
}
-func (diff *Diff) ForEachHunk() chan *DiffHunk {
- ch := make(chan *DiffHunk, 0)
- go diff.forEachHunkWrap(ch)
- return ch
+type DiffForEachHunkCallback func(*DiffHunk) error
+
+func (diff *Diff) ForEachHunk(cb DiffForEachHunkCallback) error {
+ if diff.ptr != nil {
+ return ErrInvalid
+ }
+ data := &diffForEachHunkData{
+ Callback: cb,
+ }
+ ecode := C._go_git_diff_foreach(diff.ptr, 0, 1, 0, unsafe.Pointer(data))
+ if ecode < 0 {
+ return data.Error
+ }
+ return nil
}
//export diffForEachHunkCb
func diffForEachHunkCb(delta *C.git_diff_delta, hunk *C.git_diff_hunk, payload unsafe.Pointer) int {
- ch := *(*chan *DiffHunk)(payload)
+ data := *diffForEachHunkData(payload)
- select {
- case ch <-newDiffHunk(delta, hunk):
- case <-ch:
+ err := data.Callback(newDiffHunkFromC(delta, hunk))
+ if err < 0 {
+ data.Error = err
return -1
}
return 0
}
-func (diff *Diff) forEachLineWrap(ch chan *DiffLine) {
- C._go_git_diff_foreach(diff.ptr, 0, 0, 1, unsafe.Pointer(&ch))
- close(ch)
+type diffForEachLineData struct {
+ Callback DiffForEachLineCallback
+ Error error
}
-func (diff *Diff) ForEachLine() chan *DiffLine {
- ch := make(chan *DiffLine, 0)
- go diff.forEachLineWrap(ch)
- return ch
+type DiffForEachLineCallback func(*DiffLine) error
+
+func (diff *Diff) ForEachLine(cb DiffForEachLineCallback) error {
+ if diff.ptr != nil {
+ return ErrInvalid
+ }
+
+ data := &diffForEachLineData{
+ Callback: cb,
+ }
+
+ ecode := C._go_git_diff_foreach(diff.ptr, 0, 0, 1, unsafe.Pointer(data))
+ if ecode < 0 {
+ return data.Error
+ }
+ return nil
}
//export diffForEachLineCb
func diffForEachLineCb(delta *C.git_diff_delta, hunk *C.git_diff_hunk, line *C.git_diff_line, payload unsafe.Pointer) int {
- ch := *(*chan *DiffLine)(payload)
- select {
- case ch <-newDiffLine(delta, hunk, line):
- case <-ch:
+ data := *diffForEachLineData(payload)
+
+ err := data.Callback(newDiffLineFromC(delta, hunk, line))
+ if err != nil {
+ data.Error = err
return -1
}
return 0
}
-func (diff *Diff) NumDeltas() int {
- return int(C.git_diff_num_deltas(diff.ptr))
+func (diff *Diff) NumDeltas() (int, error) {
+ if diff.ptr != nil {
+ return -1, ErrInvalid
+ }
+ return int(C.git_diff_num_deltas(diff.ptr)), nil
}
-func (diff *Diff) GetDelta(index int) *DiffDelta {
+func (diff *Diff) GetDelta(index int) (*DiffDelta, error) {
+ if diff.ptr != nil {
+ return nil, ErrInvalid
+ }
ptr := C.git_diff_get_delta(diff.ptr, C.size_t(index))
if ptr == nil {
return nil
}
- return newDiffDelta(ptr)
+ return newDiffDeltaFromC(ptr), nil
}
-func (diff *Diff) Patch(deltaIndex int) *Patch {
+func (diff *Diff) Patch(deltaIndex int) (*Patch, error) {
+ if diff.ptr != nil {
+ return nil, ErrInvalid
+ }
var patchPtr *C.git_patch
- C.git_patch_from_diff(&patchPtr, diff.ptr, C.size_t(deltaIndex))
+ ecode := C.git_patch_from_diff(&patchPtr, diff.ptr, C.size_t(deltaIndex))
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newPatchFromC(patchPtr), nil
+}
+
+func (v *Repository) DiffTreeToTree(oldTree, newTree *Tree) *Diff {
+ var diffPtr *C.git_diff
+ var oldPtr, newPtr *C.git_tree
+
+ if oldTree != nil {
+ oldPtr = oldTree.gitObject.ptr
+ }
+
+ if newTree != nil {
+ newPtr = newTree.gitObject.ptr
+ }
+
+ C.git_diff_tree_to_tree(&diffPtr, v.ptr, oldPtr, newPtr, nil)
- return newPatch(patchPtr)
+ return newDiff(diffPtr)
}
generated by cgit v1.2.3 (git 2.51.0) at 2025-11-06 12:16:22 +0000