diff options
| -rw-r--r-- | branch.go | 95 | ||||
| -rw-r--r-- | branch_test.go | 26 | ||||
| -rw-r--r-- | checkout.go | 19 | ||||
| -rw-r--r-- | git.go | 124 | ||||
| -rw-r--r-- | git_test.go | 7 | ||||
| -rw-r--r-- | index.go | 4 | ||||
| -rw-r--r-- | merge.go | 354 | ||||
| -rw-r--r-- | merge_test.go | 75 | ||||
| -rw-r--r-- | odb.go | 53 | ||||
| -rw-r--r-- | refdb.go | 51 | ||||
| -rw-r--r-- | reference.go | 74 | ||||
| -rw-r--r-- | reference_test.go | 33 | ||||
| -rw-r--r-- | remote.go | 32 | ||||
| -rw-r--r-- | repository.go | 31 | ||||
| -rw-r--r-- | walk.go | 5 | ||||
| -rw-r--r-- | wrapper.c | 22 |
16 files changed, 866 insertions, 139 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..456c302 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 @@ -15,15 +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") + ErrInvalid = errors.New("Invalid state for operation") ) func init() { @@ -65,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 } @@ -125,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 6a3aeaa..cbf3227 100644 --- a/git_test.go +++ b/git_test.go @@ -93,3 +93,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,7 +81,7 @@ func (v *Odb) Read(oid *Oid) (obj *OdbObject, err error) { } runtime.SetFinalizer(obj, (*OdbObject).Free) - return + return obj, nil } //export odbForEachCb @@ -63,9 +94,9 @@ func odbForEachCb(id *C.git_oid, payload unsafe.Pointer) int { select { case ch <- oid: case <-ch: - return -1 + return -1 } - return 0; + return 0 } func (v *Odb) forEachWrap(ch chan *Oid) { @@ -90,9 +121,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 +153,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 +220,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/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..98facc2 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 } @@ -190,6 +189,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 +205,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 +243,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 +268,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 +280,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..3e72ae7 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) { @@ -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 871c49c..bd6f773 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 ( @@ -51,6 +51,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) @@ -284,6 +300,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) @@ -295,7 +316,7 @@ func (v *Repository) Odb() (odb *Odb, err error) { } runtime.SetFinalizer(odb, (*Odb).Free) - return + return odb, nil } func (repo *Repository) Path() string { @@ -380,7 +401,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) } @@ -413,7 +435,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,6 +27,22 @@ 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; @@ -51,12 +69,11 @@ void _go_git_setup_diff_notify_callbacks(git_diff_options *opts) { } 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; @@ -87,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 */ |