diff options
| -rw-r--r-- | branch.go | 95 | ||||
| -rw-r--r-- | branch_test.go | 26 | ||||
| -rw-r--r-- | checkout.go | 21 | ||||
| -rw-r--r-- | diff.go | 428 | ||||
| -rw-r--r-- | diff_test.go | 96 | ||||
| -rw-r--r-- | git.go | 123 | ||||
| -rw-r--r-- | git_test.go | 43 | ||||
| -rw-r--r-- | index.go | 4 | ||||
| -rw-r--r-- | merge.go | 354 | ||||
| -rw-r--r-- | merge_test.go | 75 | ||||
| -rw-r--r-- | odb.go | 95 | ||||
| -rw-r--r-- | odb_test.go | 36 | ||||
| -rw-r--r-- | packbuilder.go | 58 | ||||
| -rw-r--r-- | patch.go | 48 | ||||
| -rw-r--r-- | patch_test.go | 34 | ||||
| -rw-r--r-- | push_test.go | 2 | ||||
| -rw-r--r-- | refdb.go | 51 | ||||
| -rw-r--r-- | reference.go | 87 | ||||
| -rw-r--r-- | reference_test.go | 35 | ||||
| -rw-r--r-- | remote.go | 32 | ||||
| -rw-r--r-- | repository.go | 88 | ||||
| -rw-r--r-- | walk.go | 5 | ||||
| -rw-r--r-- | wrapper.c | 47 |
23 files changed, 1693 insertions, 190 deletions
@@ -20,10 +20,70 @@ const ( ) type Branch struct { - Reference + *Reference } -func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool, signature *Signature, msg string) (*Reference, error) { +func (r *Reference) Branch() *Branch { + return &Branch{Reference: r} +} + +type BranchIterator struct { + ptr *C.git_branch_iterator + repo *Repository +} + +type BranchInfo struct { + Branch *Branch + Type BranchType +} + +func newBranchIteratorFromC(repo *Repository, ptr *C.git_branch_iterator) *BranchIterator { + i := &BranchIterator{repo: repo, ptr: ptr} + runtime.SetFinalizer(i, (*BranchIterator).Free) + return i +} + +func (i *BranchIterator) Next() (*Branch, BranchType, error) { + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + var refPtr *C.git_reference + var refType C.git_branch_t + + ecode := C.git_branch_next(&refPtr, &refType, i.ptr) + + if ecode < 0 { + return nil, BranchLocal, MakeGitError(ecode) + } + + branch := newReferenceFromC(refPtr).Branch() + + return branch, BranchType(refType), nil +} + +func (i *BranchIterator) Free() { + runtime.SetFinalizer(i, nil) + C.git_branch_iterator_free(i.ptr) +} + +func (repo *Repository) NewBranchIterator(flags BranchType) (*BranchIterator, error) { + + refType := C.git_branch_t(flags) + var ptr *C.git_branch_iterator + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ecode := C.git_branch_iterator_new(&ptr, repo.ptr, refType) + if ecode < 0 { + return nil, MakeGitError(ecode) + } + + return newBranchIteratorFromC(repo, ptr), nil +} + +func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool, signature *Signature, msg string) (*Branch, error) { ref := new(Reference) cBranchName := C.CString(branchName) @@ -47,14 +107,14 @@ func (repo *Repository) CreateBranch(branchName string, target *Commit, force bo if ret < 0 { return nil, MakeGitError(ret) } - return ref, nil + return ref.Branch(), nil } func (b *Branch) Delete() error { runtime.LockOSThread() defer runtime.UnlockOSThread() - ret := C.git_branch_delete(b.ptr) + ret := C.git_branch_delete(b.Reference.ptr) if ret < 0 { return MakeGitError(ret) } @@ -62,7 +122,7 @@ func (b *Branch) Delete() error { } func (b *Branch) Move(newBranchName string, force bool, signature *Signature, msg string) (*Branch, error) { - newBranch := new(Branch) + var ptr *C.git_reference cNewBranchName := C.CString(newBranchName) cForce := cbool(force) @@ -80,11 +140,11 @@ func (b *Branch) Move(newBranchName string, force bool, signature *Signature, ms runtime.LockOSThread() defer runtime.UnlockOSThread() - ret := C.git_branch_move(&newBranch.ptr, b.ptr, cNewBranchName, cForce, cSignature, cmsg) + ret := C.git_branch_move(&ptr, b.Reference.ptr, cNewBranchName, cForce, cSignature, cmsg) if ret < 0 { return nil, MakeGitError(ret) } - return newBranch, nil + return newReferenceFromC(ptr).Branch(), nil } func (b *Branch) IsHead() (bool, error) { @@ -92,7 +152,7 @@ func (b *Branch) IsHead() (bool, error) { runtime.LockOSThread() defer runtime.UnlockOSThread() - ret := C.git_branch_is_head(b.ptr) + ret := C.git_branch_is_head(b.Reference.ptr) switch ret { case 1: return true, nil @@ -104,17 +164,18 @@ func (b *Branch) IsHead() (bool, error) { } func (repo *Repository) LookupBranch(branchName string, bt BranchType) (*Branch, error) { - branch := new(Branch) + var ptr *C.git_reference + cName := C.CString(branchName) runtime.LockOSThread() defer runtime.UnlockOSThread() - ret := C.git_branch_lookup(&branch.ptr, repo.ptr, cName, C.git_branch_t(bt)) + ret := C.git_branch_lookup(&ptr, repo.ptr, cName, C.git_branch_t(bt)) if ret < 0 { return nil, MakeGitError(ret) } - return branch, nil + return newReferenceFromC(ptr).Branch(), nil } func (b *Branch) Name() (string, error) { @@ -124,7 +185,7 @@ func (b *Branch) Name() (string, error) { runtime.LockOSThread() defer runtime.UnlockOSThread() - ret := C.git_branch_name(&cName, b.ptr) + ret := C.git_branch_name(&cName, b.Reference.ptr) if ret < 0 { return "", MakeGitError(ret) } @@ -155,24 +216,24 @@ func (b *Branch) SetUpstream(upstreamName string) error { runtime.LockOSThread() defer runtime.UnlockOSThread() - ret := C.git_branch_set_upstream(b.ptr, cName) + ret := C.git_branch_set_upstream(b.Reference.ptr, cName) if ret < 0 { return MakeGitError(ret) } return nil } -func (b *Branch) Upstream() (*Branch, error) { - upstream := new(Branch) +func (b *Branch) Upstream() (*Reference, error) { + var ptr *C.git_reference runtime.LockOSThread() defer runtime.UnlockOSThread() - ret := C.git_branch_upstream(&upstream.ptr, b.ptr) + ret := C.git_branch_upstream(&ptr, b.Reference.ptr) if ret < 0 { return nil, MakeGitError(ret) } - return upstream, nil + return newReferenceFromC(ptr), nil } func (repo *Repository) UpstreamName(canonicalBranchName string) (string, error) { diff --git a/branch_test.go b/branch_test.go new file mode 100644 index 0000000..44f6338 --- /dev/null +++ b/branch_test.go @@ -0,0 +1,26 @@ +package git + +import ( + "testing" +) + +func TestBranchIterator(t *testing.T) { + + repo := createTestRepo(t) + seedTestRepo(t, repo) + + i, err := repo.NewBranchIterator(BranchLocal) + checkFatal(t, err) + + b, bt, err := i.Next() + checkFatal(t, err) + if name, _ := b.Name(); name != "master" { + t.Fatalf("expected master") + } else if bt != BranchLocal { + t.Fatalf("expected BranchLocal, not %v", t) + } + b, bt, err = i.Next() + if !IsErrorCode(err, ErrIterOver) { + t.Fatal("expected iterover") + } +} diff --git a/checkout.go b/checkout.go index 5b72b9a..8974a8c 100644 --- a/checkout.go +++ b/checkout.go @@ -5,8 +5,8 @@ package git */ import "C" import ( - "runtime" "os" + "runtime" ) type CheckoutStrategy uint @@ -32,10 +32,19 @@ const ( type CheckoutOpts struct { Strategy CheckoutStrategy // Default will be a dry run - DisableFilters bool // Don't apply filters like CRLF conversion - DirMode os.FileMode // Default is 0755 - FileMode os.FileMode // Default is 0644 or 0755 as dictated by blob - FileOpenFlags int // Default is O_CREAT | O_TRUNC | O_WRONLY + DisableFilters bool // Don't apply filters like CRLF conversion + DirMode os.FileMode // Default is 0755 + FileMode os.FileMode // Default is 0644 or 0755 as dictated by blob + FileOpenFlags int // Default is O_CREAT | O_TRUNC | O_WRONLY +} + +func (opts *CheckoutOpts) toC() *C.git_checkout_options { + if opts == nil { + return nil + } + c := C.git_checkout_options{} + populateCheckoutOpts(&c, opts) + return &c } // Convert the CheckoutOpts struct to the corresponding @@ -46,7 +55,7 @@ func populateCheckoutOpts(ptr *C.git_checkout_options, opts *CheckoutOpts) *C.gi return nil } - C.git_checkout_init_opts(ptr, 1) + C.git_checkout_init_options(ptr, 1) ptr.checkout_strategy = C.uint(opts.Strategy) ptr.disable_filters = cbool(opts.DisableFilters) ptr.dir_mode = C.uint(opts.DirMode.Perm()) @@ -0,0 +1,428 @@ +package git + +/* +#include <git2.h> + +extern int _go_git_diff_foreach(git_diff *diff, int eachFile, int eachHunk, int eachLine, void *payload); +extern void _go_git_setup_diff_notify_callbacks(git_diff_options* opts); +*/ +import "C" +import ( + "errors" + "runtime" + "unsafe" +) + +type DiffFlag int + +const ( + DiffFlagBinary DiffFlag = C.GIT_DIFF_FLAG_BINARY + DiffFlagNotBinary = C.GIT_DIFF_FLAG_NOT_BINARY + DiffFlagValidOid = C.GIT_DIFF_FLAG_VALID_ID +) + +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 +) + +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 + + DiffLineFileHdr = C.GIT_DIFF_LINE_FILE_HDR + DiffLineHunkHdr = C.GIT_DIFF_LINE_HUNK_HDR + DiffLineBinary = C.GIT_DIFF_LINE_BINARY +) + +type DiffFile struct { + Path string + Oid *Oid + Size int + Flags DiffFlag + Mode uint16 +} + +func diffFileFromC(file *C.git_diff_file) DiffFile { + return DiffFile{ + Path: C.GoString(file.path), + Oid: newOidFromC(&file.id), + Size: int(file.size), + Flags: DiffFlag(file.flags), + Mode: uint16(file.mode), + } +} + +type DiffDelta struct { + Status Delta + Flags DiffFlag + Similarity uint16 + OldFile DiffFile + NewFile DiffFile +} + +func diffDeltaFromC(delta *C.git_diff_delta) DiffDelta { + return DiffDelta{ + Status: Delta(delta.status), + Flags: DiffFlag(delta.flags), + Similarity: uint16(delta.similarity), + OldFile: diffFileFromC(&delta.old_file), + NewFile: diffFileFromC(&delta.new_file), + } +} + +type DiffHunk struct { + OldStart int + OldLines int + NewStart int + NewLines int + Header string +} + +func diffHunkFromC(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)), + } +} + +type DiffLine struct { + Origin DiffLineType + OldLineno int + NewLineno int + NumLines int + Content string +} + +func diffLineFromC(delta *C.git_diff_delta, hunk *C.git_diff_hunk, line *C.git_diff_line) DiffLine { + return DiffLine{ + 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)), + } +} + +type Diff struct { + ptr *C.git_diff +} + +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, error) { + if diff.ptr == nil { + return DiffDelta{}, ErrInvalid + } + ptr := C.git_diff_get_delta(diff.ptr, C.size_t(index)) + return diffDeltaFromC(ptr), nil +} + +func newDiffFromC(ptr *C.git_diff) *Diff { + if ptr == nil { + return nil + } + + diff := &Diff{ + ptr: ptr, + } + + runtime.SetFinalizer(diff, (*Diff).Free) + return diff +} + +func (diff *Diff) Free() error { + if diff.ptr == nil { + return ErrInvalid + } + runtime.SetFinalizer(diff, nil) + C.git_diff_free(diff.ptr) + diff.ptr = nil + return nil +} + +type diffForEachData struct { + FileCallback DiffForEachFileCallback + HunkCallback DiffForEachHunkCallback + LineCallback DiffForEachLineCallback + Error error +} + +type DiffForEachFileCallback func(DiffDelta, float64) (DiffForEachHunkCallback, error) + +type DiffDetail int + +const ( + DiffDetailFiles DiffDetail = iota + DiffDetailHunks + DiffDetailLines +) + +func (diff *Diff) ForEach(cbFile DiffForEachFileCallback, detail DiffDetail) error { + if diff.ptr == nil { + return ErrInvalid + } + + intHunks := C.int(0) + if detail >= DiffDetailHunks { + intHunks = C.int(1) + } + + intLines := C.int(0) + if detail >= DiffDetailLines { + intLines = C.int(1) + } + + data := &diffForEachData{ + FileCallback: cbFile, + } + ecode := C._go_git_diff_foreach(diff.ptr, 1, intHunks, intLines, 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 { + data := (*diffForEachData)(payload) + + data.HunkCallback = nil + if data.FileCallback != nil { + cb, err := data.FileCallback(diffDeltaFromC(delta), float64(progress)) + if err != nil { + data.Error = err + return -1 + } + data.HunkCallback = cb + } + + return 0 +} + +type DiffForEachHunkCallback func(DiffHunk) (DiffForEachLineCallback, error) + +//export diffForEachHunkCb +func diffForEachHunkCb(delta *C.git_diff_delta, hunk *C.git_diff_hunk, payload unsafe.Pointer) int { + data := (*diffForEachData)(payload) + + data.LineCallback = nil + if data.HunkCallback != nil { + cb, err := data.HunkCallback(diffHunkFromC(delta, hunk)) + if err != nil { + data.Error = err + return -1 + } + data.LineCallback = cb + } + + return 0 +} + +type DiffForEachLineCallback func(DiffLine) error + +//export diffForEachLineCb +func diffForEachLineCb(delta *C.git_diff_delta, hunk *C.git_diff_hunk, line *C.git_diff_line, payload unsafe.Pointer) int { + + data := (*diffForEachData)(payload) + + err := data.LineCallback(diffLineFromC(delta, hunk, line)) + if err != nil { + data.Error = err + return -1 + } + + return 0 +} + +func (diff *Diff) Patch(deltaIndex int) (*Patch, error) { + if diff.ptr == nil { + return nil, ErrInvalid + } + var patchPtr *C.git_patch + + ecode := C.git_patch_from_diff(&patchPtr, diff.ptr, C.size_t(deltaIndex)) + if ecode < 0 { + return nil, MakeGitError(ecode) + } + + return newPatchFromC(patchPtr), nil +} + +type DiffOptionsFlag int + +const ( + DiffNormal DiffOptionsFlag = C.GIT_DIFF_NORMAL + DiffReverse = C.GIT_DIFF_REVERSE + DiffIncludeIgnored = C.GIT_DIFF_INCLUDE_IGNORED + DiffRecurseIgnoredDirs = C.GIT_DIFF_RECURSE_IGNORED_DIRS + DiffIncludeUntracked = C.GIT_DIFF_INCLUDE_UNTRACKED + DiffRecurseUntracked = C.GIT_DIFF_RECURSE_UNTRACKED_DIRS + DiffIncludeUnmodified = C.GIT_DIFF_INCLUDE_UNMODIFIED + DiffIncludeTypeChange = C.GIT_DIFF_INCLUDE_TYPECHANGE + DiffIncludeTypeChangeTrees = C.GIT_DIFF_INCLUDE_TYPECHANGE_TREES + DiffIgnoreFilemode = C.GIT_DIFF_IGNORE_FILEMODE + DiffIgnoreSubmodules = C.GIT_DIFF_IGNORE_SUBMODULES + DiffIgnoreCase = C.GIT_DIFF_IGNORE_CASE + + DiffDisablePathspecMatch = C.GIT_DIFF_DISABLE_PATHSPEC_MATCH + DiffSkipBinaryCheck = C.GIT_DIFF_SKIP_BINARY_CHECK + DiffEnableFastUntrackedDirs = C.GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS + + DiffForceText = C.GIT_DIFF_FORCE_TEXT + DiffForceBinary = C.GIT_DIFF_FORCE_BINARY + + DiffIgnoreWhitespace = C.GIT_DIFF_IGNORE_WHITESPACE + DiffIgnoreWhitespaceChange = C.GIT_DIFF_IGNORE_WHITESPACE_CHANGE + DiffIgnoreWitespaceEol = C.GIT_DIFF_IGNORE_WHITESPACE_EOL + + DiffShowUntrackedContent = C.GIT_DIFF_SHOW_UNTRACKED_CONTENT + DiffShowUnmodified = C.GIT_DIFF_SHOW_UNMODIFIED + DiffPatience = C.GIT_DIFF_PATIENCE + DiffMinimal = C.GIT_DIFF_MINIMAL +) + +type DiffNotifyCallback func(diffSoFar *Diff, deltaToAdd DiffDelta, matchedPathspec string) error + +type DiffOptions struct { + Flags DiffOptionsFlag + IgnoreSubmodules SubmoduleIgnore + Pathspec []string + NotifyCallback DiffNotifyCallback + + ContextLines uint16 + InterhunkLines uint16 + IdAbbrev uint16 + + MaxSize int + + OldPrefix string + NewPrefix string +} + +func DefaultDiffOptions() (DiffOptions, error) { + opts := C.git_diff_options{} + ecode := C.git_diff_init_options(&opts, C.GIT_DIFF_OPTIONS_VERSION) + if ecode < 0 { + return DiffOptions{}, MakeGitError(ecode) + } + + return DiffOptions{ + Flags: DiffOptionsFlag(opts.flags), + IgnoreSubmodules: SubmoduleIgnore(opts.ignore_submodules), + Pathspec: makeStringsFromCStrings(opts.pathspec.strings, int(opts.pathspec.count)), + ContextLines: uint16(opts.context_lines), + InterhunkLines: uint16(opts.interhunk_lines), + IdAbbrev: uint16(opts.id_abbrev), + MaxSize: int(opts.max_size), + }, nil +} + +var ( + ErrDeltaSkip = errors.New("Skip delta") +) + +type diffNotifyData struct { + Callback DiffNotifyCallback + Diff *Diff + Error error +} + +//export diffNotifyCb +func diffNotifyCb(_diff_so_far unsafe.Pointer, delta_to_add *C.git_diff_delta, matched_pathspec *C.char, payload unsafe.Pointer) int { + diff_so_far := (*C.git_diff)(_diff_so_far) + data := (*diffNotifyData)(payload) + if data != nil { + if data.Diff == nil { + data.Diff = newDiffFromC(diff_so_far) + } + + err := data.Callback(data.Diff, diffDeltaFromC(delta_to_add), C.GoString(matched_pathspec)) + + if err == ErrDeltaSkip { + return 1 + } else if err != nil { + data.Error = err + return -1 + } else { + return 0 + } + } + return 0 +} + +func (v *Repository) DiffTreeToTree(oldTree, newTree *Tree, opts *DiffOptions) (*Diff, error) { + var diffPtr *C.git_diff + var oldPtr, newPtr *C.git_tree + + if oldTree != nil { + oldPtr = oldTree.cast_ptr + } + + if newTree != nil { + newPtr = newTree.cast_ptr + } + + cpathspec := C.git_strarray{} + var copts *C.git_diff_options + var notifyData *diffNotifyData + if opts != nil { + notifyData = &diffNotifyData{ + Callback: opts.NotifyCallback, + } + if opts.Pathspec != nil { + cpathspec.count = C.size_t(len(opts.Pathspec)) + cpathspec.strings = makeCStringsFromStrings(opts.Pathspec) + defer freeStrarray(&cpathspec) + } + + copts = &C.git_diff_options{ + version: C.GIT_DIFF_OPTIONS_VERSION, + flags: C.uint32_t(opts.Flags), + ignore_submodules: C.git_submodule_ignore_t(opts.IgnoreSubmodules), + pathspec: cpathspec, + context_lines: C.uint16_t(opts.ContextLines), + interhunk_lines: C.uint16_t(opts.InterhunkLines), + id_abbrev: C.uint16_t(opts.IdAbbrev), + max_size: C.git_off_t(opts.MaxSize), + } + + if opts.NotifyCallback != nil { + C._go_git_setup_diff_notify_callbacks(copts) + copts.notify_payload = unsafe.Pointer(notifyData) + } + } + + ecode := C.git_diff_tree_to_tree(&diffPtr, v.ptr, oldPtr, newPtr, copts) + if ecode < 0 { + return nil, MakeGitError(ecode) + } + + if notifyData != nil && notifyData.Diff != nil { + return notifyData.Diff, nil + } + return newDiffFromC(diffPtr), nil +} diff --git a/diff_test.go b/diff_test.go new file mode 100644 index 0000000..b688294 --- /dev/null +++ b/diff_test.go @@ -0,0 +1,96 @@ +package git + +import ( + "errors" + "os" + "testing" +) + +func TestDiffTreeToTree(t *testing.T) { + repo := createTestRepo(t) + defer repo.Free() + defer os.RemoveAll(repo.Workdir()) + + _, originalTreeId := seedTestRepo(t, repo) + originalTree, err := repo.LookupTree(originalTreeId) + + checkFatal(t, err) + + _, newTreeId := updateReadme(t, repo, "file changed\n") + + newTree, err := repo.LookupTree(newTreeId) + checkFatal(t, err) + + callbackInvoked := false + opts := DiffOptions{ + NotifyCallback: func(diffSoFar *Diff, delta DiffDelta, matchedPathSpec string) error { + callbackInvoked = true + return nil + }, + } + + diff, err := repo.DiffTreeToTree(originalTree, newTree, &opts) + checkFatal(t, err) + if !callbackInvoked { + t.Fatal("callback not invoked") + } + + if diff == nil { + t.Fatal("no diff returned") + } + + files := make([]string, 0) + hunks := make([]DiffHunk, 0) + lines := make([]DiffLine, 0) + err = diff.ForEach(func(file DiffDelta, progress float64) (DiffForEachHunkCallback, error) { + files = append(files, file.OldFile.Path) + return func(hunk DiffHunk) (DiffForEachLineCallback, error) { + hunks = append(hunks, hunk) + return func(line DiffLine) error { + lines = append(lines, line) + return nil + }, nil + }, nil + }, DiffDetailLines) + + checkFatal(t, err) + + if len(files) != 1 { + t.Fatal("Incorrect number of files in diff") + } + + if files[0] != "README" { + t.Fatal("File in diff was expected to be README") + } + + if len(hunks) != 1 { + t.Fatal("Incorrect number of hunks in diff") + } + + if hunks[0].OldStart != 1 || hunks[0].NewStart != 1 { + t.Fatal("Incorrect hunk") + } + + if len(lines) != 2 { + t.Fatal("Incorrect number of lines in diff") + } + + if lines[0].Content != "foo\n" { + t.Fatal("Incorrect lines in diff") + } + + if lines[1].Content != "file changed\n" { + t.Fatal("Incorrect lines in diff") + } + + errTest := errors.New("test error") + + err = diff.ForEach(func(file DiffDelta, progress float64) (DiffForEachHunkCallback, error) { + return nil, errTest + }, DiffDetailLines) + + if err != errTest { + t.Fatal("Expected custom error to be returned") + } + +} @@ -15,14 +15,82 @@ import ( "unsafe" ) +type ErrorClass int + const ( - ITEROVER = C.GIT_ITEROVER - EEXISTS = C.GIT_EEXISTS - ENOTFOUND = C.GIT_ENOTFOUND + ErrClassNone ErrorClass = C.GITERR_NONE + ErrClassNoMemory = C.GITERR_NOMEMORY + ErrClassOs = C.GITERR_OS + ErrClassInvalid = C.GITERR_INVALID + ErrClassReference = C.GITERR_REFERENCE + ErrClassZlib = C.GITERR_ZLIB + ErrClassRepository = C.GITERR_REPOSITORY + ErrClassConfig = C.GITERR_CONFIG + ErrClassRegex = C.GITERR_REGEX + ErrClassOdb = C.GITERR_ODB + ErrClassIndex = C.GITERR_INDEX + ErrClassObject = C.GITERR_OBJECT + ErrClassNet = C.GITERR_NET + ErrClassTag = C.GITERR_TAG + ErrClassTree = C.GITERR_TREE + ErrClassIndexer = C.GITERR_INDEXER + ErrClassSSL = C.GITERR_SSL + ErrClassSubmodule = C.GITERR_SUBMODULE + ErrClassThread = C.GITERR_THREAD + ErrClassStash = C.GITERR_STASH + ErrClassCheckout = C.GITERR_CHECKOUT + ErrClassFetchHead = C.GITERR_FETCHHEAD + ErrClassMerge = C.GITERR_MERGE + ErrClassSsh = C.GITERR_SSH + ErrClassFilter = C.GITERR_FILTER + ErrClassRevert = C.GITERR_REVERT + ErrClassCallback = C.GITERR_CALLBACK +) + +type ErrorCode int + +const ( + + // No error + ErrOk ErrorCode = C.GIT_OK + // Generic error + ErrGeneric = C.GIT_ERROR + // Requested object could not be found + ErrNotFound = C.GIT_ENOTFOUND + // Object exists preventing operation + ErrExists = C.GIT_EEXISTS + // More than one object matches + ErrAmbigious = C.GIT_EAMBIGUOUS + // Output buffer too short to hold data + ErrBuffs = C.GIT_EBUFS + // GIT_EUSER is a special error that is never generated by libgit2 + // code. You can return it from a callback (e.g to stop an iteration) + // to know that it was generated by the callback and not by libgit2. + ErrUser = C.GIT_EUSER + // Operation not allowed on bare repository + ErrBareRepo = C.GIT_EBAREREPO + // HEAD refers to branch with no commits + ErrUnbornBranch = C.GIT_EUNBORNBRANCH + // Merge in progress prevented operation + ErrUnmerged = C.GIT_EUNMERGED + // Reference was not fast-forwardable + ErrNonFastForward = C.GIT_ENONFASTFORWARD + // Name/ref spec was not in a valid format + ErrInvalidSpec = C.GIT_EINVALIDSPEC + // Merge conflicts prevented operation + ErrMergeConflict = C.GIT_EMERGECONFLICT + // Lock file prevented operation + ErrLocked = C.GIT_ELOCKED + // Reference value does not match expected + ErrModified = C.GIT_EMODIFIED + // Internal only + ErrPassthrough = C.GIT_PASSTHROUGH + // Signals end of iteration with iterator + ErrIterOver = C.GIT_ITEROVER ) var ( - ErrIterOver = errors.New("Iteration is over") + ErrInvalid = errors.New("Invalid state for operation") ) func init() { @@ -64,6 +132,10 @@ func NewOid(s string) (*Oid, error) { return nil, error } + if len(slice) != 20 { + return nil, &GitError{"Invalid Oid", ErrClassNone, ErrGeneric} + } + copy(o[:], slice[:20]) return o, nil } @@ -124,29 +196,50 @@ func ShortenOids(ids []*Oid, minlen int) (int, error) { } type GitError struct { - Message string - Class int - ErrorCode int + Message string + Class ErrorClass + Code ErrorCode } func (e GitError) Error() string { return e.Message } -func IsNotExist(err error) bool { - return err.(*GitError).ErrorCode == C.GIT_ENOTFOUND +func IsErrorClass(err error, c ErrorClass) bool { + + if err == nil { + return false + } + if gitError, ok := err.(*GitError); ok { + return gitError.Class == c + } + return false } -func IsExist(err error) bool { - return err.(*GitError).ErrorCode == C.GIT_EEXISTS +func IsErrorCode(err error, c ErrorCode) bool { + if err == nil { + return false + } + if gitError, ok := err.(*GitError); ok { + return gitError.Code == c + } + return false } func MakeGitError(errorCode C.int) error { - err := C.giterr_last() - if err == nil { - return &GitError{"No message", C.GITERR_INVALID, C.GIT_ERROR} + + var errMessage string + var errClass ErrorClass + if errorCode != ErrIterOver { + err := C.giterr_last() + if err != nil { + errMessage = C.GoString(err.message) + errClass = ErrorClass(err.klass) + } else { + errClass = ErrClassInvalid + } } - return &GitError{C.GoString(err.message), int(err.klass), int(errorCode)} + return &GitError{errMessage, errClass, ErrorCode(errorCode)} } func MakeGitError2(err int) error { diff --git a/git_test.go b/git_test.go index 6542ca0..56adeed 100644 --- a/git_test.go +++ b/git_test.go @@ -2,6 +2,7 @@ package git import ( "io/ioutil" + "path" "testing" "time" ) @@ -15,6 +16,7 @@ func createTestRepo(t *testing.T) *Repository { tmpfile := "README" err = ioutil.WriteFile(path+"/"+tmpfile, []byte("foo\n"), 0644) + checkFatal(t, err) return repo @@ -55,6 +57,40 @@ func seedTestRepo(t *testing.T, repo *Repository) (*Oid, *Oid) { return commitId, treeId } +func updateReadme(t *testing.T, repo *Repository, content string) (*Oid, *Oid) { + loc, err := time.LoadLocation("Europe/Berlin") + checkFatal(t, err) + sig := &Signature{ + Name: "Rand Om Hacker", + Email: "[email protected]", + When: time.Date(2013, 03, 06, 14, 30, 0, 0, loc), + } + + tmpfile := "README" + err = ioutil.WriteFile(path.Join(path.Dir(path.Dir(repo.Path())), tmpfile), []byte(content), 0644) + checkFatal(t, err) + + idx, err := repo.Index() + checkFatal(t, err) + err = idx.AddByPath("README") + checkFatal(t, err) + treeId, err := idx.WriteTree() + checkFatal(t, err) + + currentBranch, err := repo.Head() + checkFatal(t, err) + currentTip, err := repo.LookupCommit(currentBranch.Target()) + checkFatal(t, err) + + message := "This is a commit\n" + tree, err := repo.LookupTree(treeId) + checkFatal(t, err) + commitId, err := repo.CreateCommit("HEAD", sig, sig, message, tree, currentTip) + checkFatal(t, err) + + return commitId, treeId +} + func TestOidZero(t *testing.T) { var zeroId Oid @@ -62,3 +98,10 @@ func TestOidZero(t *testing.T) { t.Error("Zero Oid is not zero") } } + +func TestEmptyOid(t *testing.T) { + _, err := NewOid("") + if err == nil || !IsErrorCode(err, ErrGeneric) { + t.Fatal("Should have returned invalid error") + } +} @@ -266,10 +266,6 @@ func (v *IndexConflictIterator) Next() (IndexConflict, error) { defer runtime.UnlockOSThread() ecode := C.git_index_conflict_next(&cancestor, &cour, &ctheir, v.ptr) - if ecode == C.GIT_ITEROVER { - return IndexConflict{}, ErrIterOver - } - if ecode < 0 { return IndexConflict{}, MakeGitError(ecode) } diff --git a/merge.go b/merge.go new file mode 100644 index 0000000..48a28b0 --- /dev/null +++ b/merge.go @@ -0,0 +1,354 @@ +package git + +/* +#include <git2.h> +#include <git2/errors.h> + +extern git_merge_head** _go_git_make_merge_head_array(size_t len); +extern void _go_git_merge_head_array_set(git_merge_head** array, git_merge_head* ptr, size_t n); +extern git_merge_head* _go_git_merge_head_array_get(git_merge_head** array, size_t n); + +*/ +import "C" +import ( + "runtime" + "unsafe" +) + +type MergeHead struct { + ptr *C.git_merge_head +} + +func newMergeHeadFromC(c *C.git_merge_head) *MergeHead { + mh := &MergeHead{ptr: c} + runtime.SetFinalizer(mh, (*MergeHead).Free) + return mh +} + +func (mh *MergeHead) Free() { + runtime.SetFinalizer(mh, nil) + C.git_merge_head_free(mh.ptr) +} + +func (r *Repository) MergeHeadFromFetchHead(branchName string, remoteURL string, oid *Oid) (*MergeHead, error) { + mh := &MergeHead{} + + cbranchName := C.CString(branchName) + defer C.free(unsafe.Pointer(cbranchName)) + + cremoteURL := C.CString(remoteURL) + defer C.free(unsafe.Pointer(cremoteURL)) + + ret := C.git_merge_head_from_fetchhead(&mh.ptr, r.ptr, cbranchName, cremoteURL, oid.toC()) + if ret < 0 { + return nil, MakeGitError(ret) + } + runtime.SetFinalizer(mh, (*MergeHead).Free) + return mh, nil +} + +func (r *Repository) MergeHeadFromId(oid *Oid) (*MergeHead, error) { + mh := &MergeHead{} + + ret := C.git_merge_head_from_id(&mh.ptr, r.ptr, oid.toC()) + if ret < 0 { + return nil, MakeGitError(ret) + } + runtime.SetFinalizer(mh, (*MergeHead).Free) + return mh, nil +} + +func (r *Repository) MergeHeadFromRef(ref *Reference) (*MergeHead, error) { + mh := &MergeHead{} + + ret := C.git_merge_head_from_ref(&mh.ptr, r.ptr, ref.ptr) + if ret < 0 { + return nil, MakeGitError(ret) + } + runtime.SetFinalizer(mh, (*MergeHead).Free) + return mh, nil +} + +type MergeTreeFlag int + +const ( + MergeTreeFindRenames MergeTreeFlag = C.GIT_MERGE_TREE_FIND_RENAMES +) + +type MergeOptions struct { + Version uint + Flags MergeTreeFlag + + RenameThreshold uint + TargetLimit uint + FileFavor MergeFileFavor + + //TODO: Diff similarity metric +} + +func mergeOptionsFromC(opts *C.git_merge_options) MergeOptions { + return MergeOptions{ + Version: uint(opts.version), + Flags: MergeTreeFlag(opts.flags), + RenameThreshold: uint(opts.rename_threshold), + TargetLimit: uint(opts.target_limit), + FileFavor: MergeFileFavor(opts.file_favor), + } +} + +func DefaultMergeOptions() (MergeOptions, error) { + opts := C.git_merge_options{} + ecode := C.git_merge_init_options(&opts, C.GIT_MERGE_OPTIONS_VERSION) + if ecode < 0 { + return MergeOptions{}, MakeGitError(ecode) + } + return mergeOptionsFromC(&opts), nil +} + +func (mo *MergeOptions) toC() *C.git_merge_options { + if mo == nil { + return nil + } + return &C.git_merge_options{ + version: C.uint(mo.Version), + flags: C.git_merge_tree_flag_t(mo.Flags), + rename_threshold: C.uint(mo.RenameThreshold), + target_limit: C.uint(mo.TargetLimit), + file_favor: C.git_merge_file_favor_t(mo.FileFavor), + } +} + +type MergeFileFavor int + +const ( + MergeFileFavorNormal MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_NORMAL + MergeFileFavorOurs = C.GIT_MERGE_FILE_FAVOR_OURS + MergeFileFavorTheirs = C.GIT_MERGE_FILE_FAVOR_THEIRS + MergeFileFavorUnion = C.GIT_MERGE_FILE_FAVOR_UNION +) + +func (r *Repository) Merge(theirHeads []*MergeHead, mergeOptions *MergeOptions, checkoutOptions *CheckoutOpts) error { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + cMergeOpts := mergeOptions.toC() + cCheckoutOpts := checkoutOptions.toC() + + gmerge_head_array := make([]*C.git_merge_head, len(theirHeads)) + for i := 0; i < len(theirHeads); i++ { + gmerge_head_array[i] = theirHeads[i].ptr + } + ptr := unsafe.Pointer(&gmerge_head_array[0]) + err := C.git_merge(r.ptr, (**C.git_merge_head)(ptr), C.size_t(len(theirHeads)), cMergeOpts, cCheckoutOpts) + if err < 0 { + return MakeGitError(err) + } + return nil +} + +type MergeAnalysis int + +const ( + MergeAnalysisNone MergeAnalysis = C.GIT_MERGE_ANALYSIS_NONE + MergeAnalysisNormal = C.GIT_MERGE_ANALYSIS_NORMAL + MergeAnalysisUpToDate = C.GIT_MERGE_ANALYSIS_UP_TO_DATE + MergeAnalysisFastForward = C.GIT_MERGE_ANALYSIS_FASTFORWARD + MergeAnalysisUnborn = C.GIT_MERGE_ANALYSIS_UNBORN +) + +func (r *Repository) MergeAnalysis(theirHeads []*MergeHead) (MergeAnalysis, error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + gmerge_head_array := make([]*C.git_merge_head, len(theirHeads)) + for i := 0; i < len(theirHeads); i++ { + gmerge_head_array[i] = theirHeads[i].ptr + } + ptr := unsafe.Pointer(&gmerge_head_array[0]) + var analysis C.git_merge_analysis_t + err := C.git_merge_analysis(&analysis, r.ptr, (**C.git_merge_head)(ptr), C.size_t(len(theirHeads))) + if err < 0 { + return MergeAnalysisNone, MakeGitError(err) + } + return MergeAnalysis(analysis), nil + +} + +func (r *Repository) MergeCommits(ours *Commit, theirs *Commit, options *MergeOptions) (*Index, error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + copts := options.toC() + + idx := &Index{} + + ret := C.git_merge_commits(&idx.ptr, r.ptr, ours.cast_ptr, theirs.cast_ptr, copts) + if ret < 0 { + return nil, MakeGitError(ret) + } + runtime.SetFinalizer(idx, (*Index).Free) + return idx, nil +} + +func (r *Repository) MergeTrees(ancestor *Tree, ours *Tree, theirs *Tree, options *MergeOptions) (*Index, error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + copts := options.toC() + + idx := &Index{} + + ret := C.git_merge_trees(&idx.ptr, r.ptr, ancestor.cast_ptr, ours.cast_ptr, theirs.cast_ptr, copts) + if ret < 0 { + return nil, MakeGitError(ret) + } + runtime.SetFinalizer(idx, (*Index).Free) + return idx, nil +} + +func (r *Repository) MergeBase(one *Oid, two *Oid) (*Oid, error) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + var oid C.git_oid + ret := C.git_merge_base(&oid, r.ptr, one.toC(), two.toC()) + if ret < 0 { + return nil, MakeGitError(ret) + } + return newOidFromC(&oid), nil +} + +//TODO: int git_merge_base_many(git_oid *out, git_repository *repo, size_t length, const git_oid input_array[]); +//TODO: GIT_EXTERN(int) git_merge_base_octopus(git_oid *out,git_repository *repo,size_t length,const git_oid input_array[]); + +type MergeFileResult struct { + Automergeable bool + Path string + Mode uint + Contents []byte + ptr *C.git_merge_file_result +} + +func newMergeFileResultFromC(c *C.git_merge_file_result) *MergeFileResult { + var path string + if c.path != nil { + path = C.GoString(c.path) + } + + originalBytes := C.GoBytes(unsafe.Pointer(c.ptr), C.int(c.len)) + gobytes := make([]byte, len(originalBytes)) + copy(gobytes, originalBytes) + r := &MergeFileResult{ + Automergeable: c.automergeable != 0, + Path: path, + Mode: uint(c.mode), + Contents: gobytes, + ptr: c, + } + + runtime.SetFinalizer(r, (*MergeFileResult).Free) + return r +} + +func (r *MergeFileResult) Free() { + runtime.SetFinalizer(r, nil) + C.git_merge_file_result_free(r.ptr) +} + +type MergeFileInput struct { + Path string + Mode uint + Contents []byte +} + +// populate a C struct with merge file input, make sure to use freeMergeFileInput to clean up allocs +func populateCMergeFileInput(c *C.git_merge_file_input, input MergeFileInput) { + c.path = C.CString(input.Path) + c.ptr = (*C.char)(unsafe.Pointer(&input.Contents[0])) + c.size = C.size_t(len(input.Contents)) + c.mode = C.uint(input.Mode) +} + +func freeCMergeFileInput(c *C.git_merge_file_input) { + C.free(unsafe.Pointer(c.path)) +} + +type MergeFileFlags int + +const ( + MergeFileDefault MergeFileFlags = C.GIT_MERGE_FILE_DEFAULT + + MergeFileStyleMerge = C.GIT_MERGE_FILE_STYLE_MERGE + MergeFileStyleDiff = C.GIT_MERGE_FILE_STYLE_DIFF3 + MergeFileStyleSimplifyAlnum = C.GIT_MERGE_FILE_SIMPLIFY_ALNUM +) + +type MergeFileOptions struct { + AncestorLabel string + OurLabel string + TheirLabel string + Favor MergeFileFavor + Flags MergeFileFlags +} + +func mergeFileOptionsFromC(c C.git_merge_file_options) MergeFileOptions { + return MergeFileOptions{ + AncestorLabel: C.GoString(c.ancestor_label), + OurLabel: C.GoString(c.our_label), + TheirLabel: C.GoString(c.their_label), + Favor: MergeFileFavor(c.favor), + Flags: MergeFileFlags(c.flags), + } +} + +func populateCMergeFileOptions(c *C.git_merge_file_options, options MergeFileOptions) { + c.ancestor_label = C.CString(options.AncestorLabel) + c.our_label = C.CString(options.OurLabel) + c.their_label = C.CString(options.TheirLabel) + c.favor = C.git_merge_file_favor_t(options.Favor) + c.flags = C.git_merge_file_flags_t(options.Flags) +} + +func freeCMergeFileOptions(c *C.git_merge_file_options) { + C.free(unsafe.Pointer(c.ancestor_label)) + C.free(unsafe.Pointer(c.our_label)) + C.free(unsafe.Pointer(c.their_label)) +} + +func MergeFile(ancestor MergeFileInput, ours MergeFileInput, theirs MergeFileInput, options *MergeFileOptions) (*MergeFileResult, error) { + + var cancestor C.git_merge_file_input + var cours C.git_merge_file_input + var ctheirs C.git_merge_file_input + + populateCMergeFileInput(&cancestor, ancestor) + defer freeCMergeFileInput(&cancestor) + populateCMergeFileInput(&cours, ours) + defer freeCMergeFileInput(&cours) + populateCMergeFileInput(&ctheirs, theirs) + defer freeCMergeFileInput(&ctheirs) + + var copts *C.git_merge_file_options + if options != nil { + copts = &C.git_merge_file_options{} + ecode := C.git_merge_file_init_options(copts, C.GIT_MERGE_FILE_OPTIONS_VERSION) + if ecode < 0 { + return nil, MakeGitError(ecode) + } + populateCMergeFileOptions(copts, *options) + } + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + var result C.git_merge_file_result + ecode := C.git_merge_file(&result, &cancestor, &cours, &ctheirs, copts) + if ecode < 0 { + return nil, MakeGitError(ecode) + } + + return newMergeFileResultFromC(&result), nil + +} + +// TODO: GIT_EXTERN(int) git_merge_file_from_index(git_merge_file_result *out,git_repository *repo,const git_index_entry *ancestor, const git_index_entry *ours, const git_index_entry *theirs, const git_merge_file_options *opts); diff --git a/merge_test.go b/merge_test.go new file mode 100644 index 0000000..3f9dc33 --- /dev/null +++ b/merge_test.go @@ -0,0 +1,75 @@ +package git + +import ( + "testing" +) + +func TestMergeWithSelf(t *testing.T) { + + repo := createTestRepo(t) + seedTestRepo(t, repo) + + master, err := repo.LookupReference("refs/heads/master") + checkFatal(t, err) + + mergeHead, err := repo.MergeHeadFromRef(master) + checkFatal(t, err) + + mergeHeads := make([]*MergeHead, 1) + mergeHeads[0] = mergeHead + err = repo.Merge(mergeHeads, nil, nil) + checkFatal(t, err) +} + +func TestMergeAnalysisWithSelf(t *testing.T) { + + repo := createTestRepo(t) + seedTestRepo(t, repo) + + master, err := repo.LookupReference("refs/heads/master") + checkFatal(t, err) + + mergeHead, err := repo.MergeHeadFromRef(master) + checkFatal(t, err) + + mergeHeads := make([]*MergeHead, 1) + mergeHeads[0] = mergeHead + a, err := repo.MergeAnalysis(mergeHeads) + checkFatal(t, err) + + if a != MergeAnalysisUpToDate { + t.Fatalf("Expected up to date merge, not %v", a) + } +} + +func TestMergeSameFile(t *testing.T) { + + file := MergeFileInput{ + Path: "test", + Mode: 33188, + Contents: []byte("hello world"), + } + + result, err := MergeFile(file, file, file, nil) + checkFatal(t, err) + if !result.Automergeable { + t.Fatal("expected automergeable") + } + if result.Path != file.Path { + t.Fatal("path was incorrect") + } + if result.Mode != file.Mode { + t.Fatal("mode was incorrect") + } + + compareBytes(t, file.Contents, result.Contents) + +} + +func compareBytes(t *testing.T, expected, actual []byte) { + for i, v := range expected { + if actual[i] != v { + t.Fatalf("Bad bytes") + } + } +} @@ -5,18 +5,49 @@ package git #include <git2/errors.h> extern int _go_git_odb_foreach(git_odb *db, void *payload); +extern void _go_git_odb_backend_free(git_odb_backend *backend); */ import "C" import ( - "unsafe" "reflect" "runtime" + "unsafe" ) type Odb struct { ptr *C.git_odb } +type OdbBackend struct { + ptr *C.git_odb_backend +} + +func NewOdb() (odb *Odb, err error) { + odb = new(Odb) + + ret := C.git_odb_new(&odb.ptr) + if ret < 0 { + return nil, MakeGitError(ret) + } + + runtime.SetFinalizer(odb, (*Odb).Free) + return odb, nil +} + +func NewOdbBackendFromC(ptr *C.git_odb_backend) (backend *OdbBackend) { + backend = &OdbBackend{ptr} + return backend +} + +func (v *Odb) AddBackend(backend *OdbBackend, priority int) (err error) { + ret := C.git_odb_add_backend(v.ptr, backend.ptr, C.int(priority)) + if ret < 0 { + backend.Free() + return MakeGitError(ret) + } + return nil +} + func (v *Odb) Exists(oid *Oid) bool { ret := C.git_odb_exists(v.ptr, oid.toC()) return ret != 0 @@ -32,10 +63,10 @@ func (v *Odb) Write(data []byte, otype ObjectType) (oid *Oid, err error) { ret := C.git_odb_write(oid.toC(), v.ptr, unsafe.Pointer(hdr.Data), C.size_t(hdr.Len), C.git_otype(otype)) if ret < 0 { - err = MakeGitError(ret) + return nil, MakeGitError(ret) } - return + return oid, nil } func (v *Odb) Read(oid *Oid) (obj *OdbObject, err error) { @@ -50,33 +81,43 @@ func (v *Odb) Read(oid *Oid) (obj *OdbObject, err error) { } runtime.SetFinalizer(obj, (*OdbObject).Free) - return + return obj, nil +} + +type OdbForEachCallback func(id *Oid) error + +type foreachData struct { + callback OdbForEachCallback + err error } //export odbForEachCb func odbForEachCb(id *C.git_oid, payload unsafe.Pointer) int { - ch := *(*chan *Oid)(payload) - oid := newOidFromC(id) - // Because the channel is unbuffered, we never read our own data. If ch is - // readable, the user has sent something on it, which means we should - // abort. - select { - case ch <- oid: - case <-ch: - return -1 + data := (*foreachData)(payload) + + err := data.callback(newOidFromC(id)) + if err != nil { + data.err = err + return C.GIT_EUSER } - return 0; -} -func (v *Odb) forEachWrap(ch chan *Oid) { - C._go_git_odb_foreach(v.ptr, unsafe.Pointer(&ch)) - close(ch) + return 0 } -func (v *Odb) ForEach() chan *Oid { - ch := make(chan *Oid, 0) - go v.forEachWrap(ch) - return ch +func (v *Odb) ForEach(callback OdbForEachCallback) error { + data := foreachData { + callback: callback, + err: nil, + } + + ret := C._go_git_odb_foreach(v.ptr, unsafe.Pointer(&data)) + if ret == C.GIT_EUSER { + return data.err + } else if ret < 0 { + return MakeGitError(ret) + } + + return nil } // Hash determines the object-ID (sha1) of a data buffer. @@ -90,9 +131,9 @@ func (v *Odb) Hash(data []byte, otype ObjectType) (oid *Oid, err error) { ret := C.git_odb_hash(oid.toC(), ptr, C.size_t(header.Len), C.git_otype(otype)); if ret < 0 { - err = MakeGitError(ret) + return nil, MakeGitError(ret) } - return + return oid, nil } // NewReadStream opens a read stream from the ODB. Reading from it will give you the @@ -122,6 +163,10 @@ func (v *Odb) NewWriteStream(size int, otype ObjectType) (*OdbWriteStream, error return stream, nil } +func (v *OdbBackend) Free() { + C._go_git_odb_backend_free(v.ptr) +} + type OdbObject struct { ptr *C.git_odb_object } @@ -185,7 +230,7 @@ func (stream *OdbReadStream) Free() { type OdbWriteStream struct { ptr *C.git_odb_stream - Id Oid + Id Oid } // Write writes to the stream diff --git a/odb_test.go b/odb_test.go index 17b3ad2..14a3658 100644 --- a/odb_test.go +++ b/odb_test.go @@ -3,6 +3,7 @@ package git import ( "io" "os" + "errors" "testing" ) @@ -48,7 +49,7 @@ parent 66e1c476199ebcd3e304659992233132c5a52c6c author John Doe <[email protected]> 1390682018 +0000 committer John Doe <[email protected]> 1390682018 +0000 -Initial commit.`; +Initial commit.` oid, error := odb.Hash([]byte(str), ObjectCommit) checkFatal(t, error) @@ -60,3 +61,36 @@ Initial commit.`; t.Fatal("Hash and write Oids are different") } } + +func TestOdbForeach(t *testing.T) { + repo := createTestRepo(t) + defer os.RemoveAll(repo.Workdir()) + _, _ = seedTestRepo(t, repo) + + odb, err := repo.Odb() + checkFatal(t, err) + + expect := 3 + count := 0 + err = odb.ForEach(func(id *Oid) error { + count++ + return nil + }) + + checkFatal(t, err) + if count != expect { + t.Fatalf("Expected %v objects, got %v") + } + + expect = 1 + count = 0 + to_return := errors.New("not really an error") + err = odb.ForEach(func(id *Oid) error { + count++ + return to_return + }) + + if err != to_return { + t.Fatalf("Odb.ForEach() did not return the expected error, got %v", err) + } +} diff --git a/packbuilder.go b/packbuilder.go index 70c4530..666f5c4 100644 --- a/packbuilder.go +++ b/packbuilder.go @@ -94,55 +94,51 @@ func (pb *Packbuilder) WriteToFile(name string, mode os.FileMode) error { } func (pb *Packbuilder) Write(w io.Writer) error { - ch, stop := pb.ForEach() - for slice := range ch { + return pb.ForEach(func(slice []byte) error { _, err := w.Write(slice) - if err != nil { - close(stop) - return err - } - } - return nil + return err + }) } func (pb *Packbuilder) Written() uint32 { return uint32(C.git_packbuilder_written(pb.ptr)) } +type PackbuilderForeachCallback func([]byte) error type packbuilderCbData struct { - ch chan<- []byte - stop <-chan bool + callback PackbuilderForeachCallback + err error } //export packbuilderForEachCb func packbuilderForEachCb(buf unsafe.Pointer, size C.size_t, payload unsafe.Pointer) int { data := (*packbuilderCbData)(payload) - ch := data.ch - stop := data.stop - slice := C.GoBytes(buf, C.int(size)) - select { - case <- stop: - return -1 - case ch <- slice: + + err := data.callback(slice) + if err != nil { + data.err = err + return C.GIT_EUSER } return 0 } -func (pb *Packbuilder) forEachWrap(data *packbuilderCbData) { - C._go_git_packbuilder_foreach(pb.ptr, unsafe.Pointer(data)) - close(data.ch) -} +// ForEach repeatedly calls the callback with new packfile data until +// there is no more data or the callback returns an error +func (pb *Packbuilder) ForEach(callback PackbuilderForeachCallback) error { + data := packbuilderCbData{ + callback: callback, + err: nil, + } -// Foreach sends the packfile as slices through the "data" channel. If -// you want to stop the pack-building process (e.g. there's an error -// writing to the output), close or write a value into the "stop" -// channel. -func (pb *Packbuilder) ForEach() (<-chan []byte, chan<- bool) { - ch := make(chan []byte) - stop := make(chan bool) - data := packbuilderCbData{ch, stop} - go pb.forEachWrap(&data) - return ch, stop + err := C._go_git_packbuilder_foreach(pb.ptr, unsafe.Pointer(&data)) + if err == C.GIT_EUSER { + return data.err + } + if err < 0 { + return MakeGitError(err) + } + + return nil } diff --git a/patch.go b/patch.go new file mode 100644 index 0000000..0665501 --- /dev/null +++ b/patch.go @@ -0,0 +1,48 @@ +package git + +/* +#include <git2.h> +*/ +import "C" +import ( + "runtime" +) + +type Patch struct { + ptr *C.git_patch +} + +func newPatchFromC(ptr *C.git_patch) *Patch { + if ptr == nil { + return nil + } + + patch := &Patch{ + ptr: ptr, + } + + runtime.SetFinalizer(patch, (*Patch).Free) + return patch +} + +func (patch *Patch) Free() error { + if patch.ptr == nil { + return ErrInvalid + } + runtime.SetFinalizer(patch, nil) + C.git_patch_free(patch.ptr) + patch.ptr = nil + return nil +} + +func (patch *Patch) String() (string, error) { + if patch.ptr == nil { + return "", ErrInvalid + } + var buf C.git_buf + ecode := C.git_patch_to_buf(&buf, patch.ptr) + if ecode < 0 { + return "", MakeGitError(ecode) + } + return C.GoString(buf.ptr), nil +} diff --git a/patch_test.go b/patch_test.go new file mode 100644 index 0000000..569eac2 --- /dev/null +++ b/patch_test.go @@ -0,0 +1,34 @@ +package git + +import ( + "strings" + "testing" +) + +func TestPatch(t *testing.T) { + repo := createTestRepo(t) + defer repo.Free() + //defer os.RemoveAll(repo.Workdir()) + + _, originalTreeId := seedTestRepo(t, repo) + originalTree, err := repo.LookupTree(originalTreeId) + + checkFatal(t, err) + + _, newTreeId := updateReadme(t, repo, "file changed\n") + + newTree, err := repo.LookupTree(newTreeId) + checkFatal(t, err) + + diff, err := repo.DiffTreeToTree(originalTree, newTree, nil) + checkFatal(t, err) + + patch, err := diff.Patch(0) + checkFatal(t, err) + + patchStr, err := patch.String() + checkFatal(t, err) + if strings.Index(patchStr, "diff --git a/README b/README\nindex 257cc56..820734a 100644\n--- a/README\n+++ b/README\n@@ -1 +1 @@\n-foo\n+file changed") == -1 { + t.Fatalf("patch was bad") + } +} diff --git a/push_test.go b/push_test.go index c1e6a22..65f4dd2 100644 --- a/push_test.go +++ b/push_test.go @@ -1,7 +1,6 @@ package git import ( - "log" "os" "testing" "time" @@ -45,7 +44,6 @@ func Test_Push_ToRemote(t *testing.T) { checkFatal(t, err) err = push.StatusForeach(func(ref string, msg string) int { - log.Printf("%s -> %s", ref, msg) return 0 }) checkFatal(t, err) diff --git a/refdb.go b/refdb.go new file mode 100644 index 0000000..46fbb63 --- /dev/null +++ b/refdb.go @@ -0,0 +1,51 @@ +package git + +/* +#include <git2.h> +#include <git2/errors.h> +#include <git2/sys/refdb_backend.h> + +extern void _go_git_refdb_backend_free(git_refdb_backend *backend); +*/ +import "C" +import ( + "runtime" +) + +type Refdb struct { + ptr *C.git_refdb +} + +type RefdbBackend struct { + ptr *C.git_refdb_backend +} + +func (v *Repository) NewRefdb() (refdb *Refdb, err error) { + refdb = new(Refdb) + + ret := C.git_refdb_new(&refdb.ptr, v.ptr) + if ret < 0 { + return nil, MakeGitError(ret) + } + + runtime.SetFinalizer(refdb, (*Refdb).Free) + return refdb, nil +} + +func NewRefdbBackendFromC(ptr *C.git_refdb_backend) (backend *RefdbBackend) { + backend = &RefdbBackend{ptr} + return backend +} + +func (v *Refdb) SetBackend(backend *RefdbBackend) (err error) { + ret := C.git_refdb_set_backend(v.ptr, backend.ptr) + if ret < 0 { + backend.Free() + return MakeGitError(ret) + } + return nil +} + +func (v *RefdbBackend) Free() { + C._go_git_refdb_backend_free(v.ptr) +} diff --git a/reference.go b/reference.go index d246c55..8c8b282 100644 --- a/reference.go +++ b/reference.go @@ -22,9 +22,8 @@ type Reference struct { } func newReferenceFromC(ptr *C.git_reference) *Reference { - ref := &Reference{ptr} + ref := &Reference{ptr: ptr} runtime.SetFinalizer(ref, (*Reference).Free) - return ref } @@ -149,6 +148,19 @@ func (v *Reference) Delete() error { return nil } +func (v *Reference) Peel(t ObjectType) (Object, error) { + var cobj *C.git_object + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + if err := C.git_reference_peel(&cobj, v.ptr, C.git_otype(t)); err < 0 { + return nil, MakeGitError(err) + } + + return allocObject(cobj), nil +} + // Cmp compares both references, retursn 0 on equality, otherwise a // stable sorting. func (v *Reference) Cmp(ref2 *Reference) int { @@ -190,6 +202,10 @@ type ReferenceIterator struct { repo *Repository } +type ReferenceNameIterator struct { + *ReferenceIterator +} + // NewReferenceIterator creates a new iterator over reference names func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) { var ptr *C.git_reference_iterator @@ -202,11 +218,28 @@ func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) { return nil, MakeGitError(ret) } - iter := &ReferenceIterator{repo: repo, ptr: ptr} + iter := &ReferenceIterator{ptr: ptr, repo: repo} runtime.SetFinalizer(iter, (*ReferenceIterator).Free) return iter, nil } +// NewReferenceIterator creates a new branch iterator over reference names +func (repo *Repository) NewReferenceNameIterator() (*ReferenceNameIterator, error) { + var ptr *C.git_reference_iterator + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ret := C.git_reference_iterator_new(&ptr, repo.ptr) + if ret < 0 { + return nil, MakeGitError(ret) + } + + iter := &ReferenceIterator{ptr: ptr, repo: repo} + runtime.SetFinalizer(iter, (*ReferenceIterator).Free) + return iter.Names(), nil +} + // NewReferenceIteratorGlob creates an iterator over reference names // that match the speicified glob. The glob is of the usual fnmatch // type. @@ -223,23 +256,24 @@ func (repo *Repository) NewReferenceIteratorGlob(glob string) (*ReferenceIterato return nil, MakeGitError(ret) } - iter := &ReferenceIterator{repo: repo, ptr: ptr} + iter := &ReferenceIterator{ptr: ptr} runtime.SetFinalizer(iter, (*ReferenceIterator).Free) return iter, nil } +func (i *ReferenceIterator) Names() *ReferenceNameIterator { + return &ReferenceNameIterator{i} +} + // NextName retrieves the next reference name. If the iteration is over, // the returned error is git.ErrIterOver -func (v *ReferenceIterator) NextName() (string, error) { +func (v *ReferenceNameIterator) Next() (string, error) { var ptr *C.char runtime.LockOSThread() defer runtime.UnlockOSThread() ret := C.git_reference_next_name(&ptr, v.ptr) - if ret == ITEROVER { - return "", ErrIterOver - } if ret < 0 { return "", MakeGitError(ret) } @@ -247,31 +281,11 @@ func (v *ReferenceIterator) NextName() (string, error) { return C.GoString(ptr), nil } -// Create a channel from the iterator. You can use range on the -// returned channel to iterate over all the references names. The channel -// will be closed in case any error is found. -func (v *ReferenceIterator) NameIter() <-chan string { - ch := make(chan string) - go func() { - defer close(ch) - name, err := v.NextName() - for err == nil { - ch <- name - name, err = v.NextName() - } - }() - - return ch -} - // Next retrieves the next reference. If the iterationis over, the // returned error is git.ErrIterOver func (v *ReferenceIterator) Next() (*Reference, error) { var ptr *C.git_reference ret := C.git_reference_next(&ptr, v.ptr) - if ret == ITEROVER { - return nil, ErrIterOver - } if ret < 0 { return nil, MakeGitError(ret) } @@ -279,23 +293,6 @@ func (v *ReferenceIterator) Next() (*Reference, error) { return newReferenceFromC(ptr), nil } -// Create a channel from the iterator. You can use range on the -// returned channel to iterate over all the references names. The channel -// will be closed in case any error is found. -func (v *ReferenceIterator) Iter() <-chan *Reference { - ch := make(chan *Reference) - go func() { - defer close(ch) - name, err := v.Next() - for err == nil { - ch <- name - name, err = v.Next() - } - }() - - return ch -} - // Free the reference iterator func (v *ReferenceIterator) Free() { runtime.SetFinalizer(v, nil) diff --git a/reference_test.go b/reference_test.go index ffa9f35..cb7a5fc 100644 --- a/reference_test.go +++ b/reference_test.go @@ -60,7 +60,7 @@ func TestRefModification(t *testing.T) { } -func TestIterator(t *testing.T) { +func TestReferenceIterator(t *testing.T) { repo := createTestRepo(t) defer os.RemoveAll(repo.Workdir()) @@ -106,12 +106,13 @@ func TestIterator(t *testing.T) { } // test some manual iteration - name, err := iter.NextName() + nameIter := iter.Names() + name, err := nameIter.Next() for err == nil { list = append(list, name) - name, err = iter.NextName() + name, err = nameIter.Next() } - if err != ErrIterOver { + if !IsErrorCode(err, ErrIterOver) { t.Fatal("Iteration not over") } @@ -127,7 +128,7 @@ func TestIterator(t *testing.T) { count++ _, err = iter.Next() } - if err != ErrIterOver { + if !IsErrorCode(err, ErrIterOver) { t.Fatal("Iteration not over") } @@ -135,28 +136,6 @@ func TestIterator(t *testing.T) { t.Fatalf("Wrong number of references returned %v", count) } - // test the channel iteration - list = []string{} - iter, err = repo.NewReferenceIterator() - for name := range iter.NameIter() { - list = append(list, name) - } - - sort.Strings(list) - compareStringList(t, expected, list) - - iter, err = repo.NewReferenceIteratorGlob("refs/heads/t*") - expected = []string{ - "refs/heads/three", - "refs/heads/two", - } - - list = []string{} - for name := range iter.NameIter() { - list = append(list, name) - } - - compareStringList(t, expected, list) } func TestUtil(t *testing.T) { @@ -182,7 +161,7 @@ func TestUtil(t *testing.T) { hasLog, err := repo.HasLog("refs/heads/foo") checkFatal(t, err) if !hasLog { - t.Fatalf("branches ahve logs by default") + t.Fatalf("branches have logs by default") } } @@ -38,14 +38,14 @@ const ( RemoteCompletionError = C.GIT_REMOTE_COMPLETION_ERROR ) -type ProgressCallback func(str string) int +type TransportMessageCallback func(str string) int type CompletionCallback func(RemoteCompletion) int type CredentialsCallback func(url string, username_from_url string, allowed_types CredType) (int, *Cred) type TransferProgressCallback func(stats TransferProgress) int type UpdateTipsCallback func(refname string, a *Oid, b *Oid) int type RemoteCallbacks struct { - ProgressCallback + SidebandProgressCallback TransportMessageCallback CompletionCallback CredentialsCallback TransferProgressCallback @@ -65,14 +65,14 @@ func populateRemoteCallbacks(ptr *C.git_remote_callbacks, callbacks *RemoteCallb ptr.payload = unsafe.Pointer(callbacks) } -//export progressCallback -func progressCallback(_str *C.char, _len C.int, data unsafe.Pointer) int { +//export sidebandProgressCallback +func sidebandProgressCallback(_str *C.char, _len C.int, data unsafe.Pointer) int { callbacks := (*RemoteCallbacks)(data) - if callbacks.ProgressCallback == nil { + if callbacks.SidebandProgressCallback == nil { return 0 } str := C.GoStringN(_str, _len) - return callbacks.ProgressCallback(str) + return callbacks.SidebandProgressCallback(str) } //export completionCallback @@ -127,6 +127,26 @@ func RemoteIsValidName(name string) bool { return false } +func (r *Remote) SetCheckCert(check bool) { + C.git_remote_check_cert(r.ptr, cbool(check)) +} + +func (r *Remote) SetCallbacks(callbacks *RemoteCallbacks) error { + var ccallbacks C.git_remote_callbacks + + populateRemoteCallbacks(&ccallbacks, callbacks) + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ecode := C.git_remote_set_callbacks(r.ptr, &ccallbacks) + if ecode < 0 { + return MakeGitError(ecode) + } + + return nil +} + func (r *Remote) Free() { runtime.SetFinalizer(r, nil) C.git_remote_free(r.ptr) diff --git a/repository.go b/repository.go index 02dcff6..5ae10f2 100644 --- a/repository.go +++ b/repository.go @@ -2,7 +2,7 @@ package git /* #include <git2.h> -#include <git2/errors.h> +#include <git2/sys/repository.h> */ import "C" import ( @@ -69,6 +69,22 @@ func InitRepository(path string, isbare bool) (*Repository, error) { return repo, nil } +func NewRepositoryWrapOdb(odb *Odb) (repo *Repository, err error) { + repo = new(Repository) + + ret := C.git_repository_wrap_odb(&repo.ptr, odb.ptr) + if ret < 0 { + return nil, MakeGitError(ret) + } + + runtime.SetFinalizer(repo, (*Repository).Free) + return repo, nil +} + +func (v *Repository) SetRefdb(refdb *Refdb) { + C.git_repository_set_refdb(v.ptr, refdb.ptr) +} + func (v *Repository) Free() { runtime.SetFinalizer(v, nil) C.git_repository_free(v.ptr) @@ -164,6 +180,63 @@ func (v *Repository) LookupReference(name string) (*Reference, error) { return newReferenceFromC(ptr), nil } +func (v *Repository) Head() (*Reference, error) { + var ptr *C.git_reference + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ecode := C.git_repository_head(&ptr, v.ptr) + if ecode < 0 { + return nil, MakeGitError(ecode) + } + + return newReferenceFromC(ptr), nil +} + +func (v *Repository) SetHead(refname string, sig *Signature, msg string) error { + cname := C.CString(refname) + defer C.free(unsafe.Pointer(cname)) + + csig := sig.toC() + defer C.free(unsafe.Pointer(csig)) + + var cmsg *C.char + if msg != "" { + cmsg = C.CString(msg) + defer C.free(unsafe.Pointer(cmsg)) + } + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ecode := C.git_repository_set_head(v.ptr, cname, csig, cmsg) + if ecode != 0 { + return MakeGitError(ecode) + } + return nil +} + +func (v *Repository) SetHeadDetached(id *Oid, sig *Signature, msg string) error { + csig := sig.toC() + defer C.free(unsafe.Pointer(csig)) + + var cmsg *C.char + if msg != "" { + cmsg = C.CString(msg) + defer C.free(unsafe.Pointer(cmsg)) + } + + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + ecode := C.git_repository_set_head_detached(v.ptr, id.toC(), csig, cmsg) + if ecode != 0 { + return MakeGitError(ecode) + } + return nil +} + func (v *Repository) CreateReference(name string, id *Oid, force bool, sig *Signature, msg string) (*Reference, error) { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) @@ -288,6 +361,11 @@ func (v *Odb) Free() { C.git_odb_free(v.ptr) } +func (v *Refdb) Free() { + runtime.SetFinalizer(v, nil) + C.git_refdb_free(v.ptr) +} + func (v *Repository) Odb() (odb *Odb, err error) { odb = new(Odb) @@ -299,7 +377,7 @@ func (v *Repository) Odb() (odb *Odb, err error) { } runtime.SetFinalizer(odb, (*Odb).Free) - return + return odb, nil } func (repo *Repository) Path() string { @@ -384,7 +462,8 @@ func (v *Repository) EnsureLog(name string) error { runtime.LockOSThread() defer runtime.UnlockOSThread() - if ret := C.git_reference_ensure_log(v.ptr, cname); ret < 0 { + ret := C.git_reference_ensure_log(v.ptr, cname) + if ret < 0 { return MakeGitError(ret) } @@ -417,7 +496,8 @@ func (v *Repository) DwimReference(name string) (*Reference, error) { defer runtime.UnlockOSThread() var ptr *C.git_reference - if ret := C.git_reference_dwim(&ptr, v.ptr, cname); ret < 0 { + ret := C.git_reference_dwim(&ptr, v.ptr, cname) + if ret < 0 { return nil, MakeGitError(ret) } @@ -7,7 +7,6 @@ package git import "C" import ( - "io" "runtime" "unsafe" ) @@ -158,8 +157,6 @@ func (v *RevWalk) Next(id *Oid) (err error) { ret := C.git_revwalk_next(id.toC(), v.ptr) switch { - case ret == ITEROVER: - err = io.EOF case ret < 0: err = MakeGitError(ret) } @@ -173,7 +170,7 @@ func (v *RevWalk) Iterate(fun RevWalkIterator) (err error) { oid := new(Oid) for { err = v.Next(oid) - if err == io.EOF { + if IsErrorCode(err, ErrIterOver) { return nil } if err != nil { @@ -1,5 +1,7 @@ #include "_cgo_export.h" #include "git2.h" +#include "git2/sys/odb_backend.h" +#include "git2/sys/refdb_backend.h" #include "git2/submodule.h" #include "git2/pack.h" @@ -25,13 +27,53 @@ int _go_git_odb_foreach(git_odb *db, void *payload) return git_odb_foreach(db, (git_odb_foreach_cb)&odbForEachCb, payload); } +void _go_git_odb_backend_free(git_odb_backend *backend) +{ + if (backend->free) + backend->free(backend); + + return; +} + +void _go_git_refdb_backend_free(git_refdb_backend *backend) +{ + if (backend->free) + backend->free(backend); + + return; +} + +int _go_git_diff_foreach(git_diff *diff, int eachFile, int eachHunk, int eachLine, void *payload) +{ + git_diff_file_cb fcb = NULL; + git_diff_hunk_cb hcb = NULL; + git_diff_line_cb lcb = NULL; + + if (eachFile) { + fcb = (git_diff_file_cb)&diffForEachFileCb; + } + + if (eachHunk) { + hcb = (git_diff_hunk_cb)&diffForEachHunkCb; + } + + if (eachLine) { + lcb = (git_diff_line_cb)&diffForEachLineCb; + } + + return git_diff_foreach(diff, fcb, hcb, lcb, payload); +} + +void _go_git_setup_diff_notify_callbacks(git_diff_options *opts) { + opts->notify_cb = (git_diff_notify_cb)diffNotifyCb; +} + void _go_git_setup_callbacks(git_remote_callbacks *callbacks) { - typedef int (*progress_cb)(const char *str, int len, void *data); typedef int (*completion_cb)(git_remote_completion_type type, void *data); typedef int (*credentials_cb)(git_cred **cred, const char *url, const char *username_from_url, unsigned int allowed_types, void *data); typedef int (*transfer_progress_cb)(const git_transfer_progress *stats, void *data); typedef int (*update_tips_cb)(const char *refname, const git_oid *a, const git_oid *b, void *data); - callbacks->progress = (progress_cb)progressCallback; + callbacks->sideband_progress = (git_transport_message_cb)sidebandProgressCallback; callbacks->completion = (completion_cb)completionCallback; callbacks->credentials = (credentials_cb)credentialsCallback; callbacks->transfer_progress = (transfer_progress_cb)transferProgressCallback; @@ -62,4 +104,5 @@ int _go_git_blob_create_fromchunks(git_oid *id, { return git_blob_create_fromchunks(id, repo, hintpath, _go_blob_chunk_cb, payload); } + /* EOF */ |