git.go

package git

/*
#include <git2.h>
#include <git2/sys/openssl.h>
*/
import"C"
import (
"bytes"
"encoding/hex"
"errors"
"runtime"
"strings"
"unsafe"
)

//go:generate stringer -type ErrorClass -trimprefix ErrorClass -tags static
typeErrorClassint

const (
ErrorClassNoneErrorClass=C.GIT_ERROR_NONE
ErrorClassNoMemoryErrorClass=C.GIT_ERROR_NOMEMORY
ErrorClassOSErrorClass=C.GIT_ERROR_OS
ErrorClassInvalidErrorClass=C.GIT_ERROR_INVALID
ErrorClassReferenceErrorClass=C.GIT_ERROR_REFERENCE
ErrorClassZlibErrorClass=C.GIT_ERROR_ZLIB
ErrorClassRepositoryErrorClass=C.GIT_ERROR_REPOSITORY
ErrorClassConfigErrorClass=C.GIT_ERROR_CONFIG
ErrorClassRegexErrorClass=C.GIT_ERROR_REGEX
ErrorClassOdbErrorClass=C.GIT_ERROR_ODB
ErrorClassIndexErrorClass=C.GIT_ERROR_INDEX
ErrorClassObjectErrorClass=C.GIT_ERROR_OBJECT
ErrorClassNetErrorClass=C.GIT_ERROR_NET
ErrorClassTagErrorClass=C.GIT_ERROR_TAG
ErrorClassTreeErrorClass=C.GIT_ERROR_TREE
ErrorClassIndexerErrorClass=C.GIT_ERROR_INDEXER
ErrorClassSSLErrorClass=C.GIT_ERROR_SSL
ErrorClassSubmoduleErrorClass=C.GIT_ERROR_SUBMODULE
ErrorClassThreadErrorClass=C.GIT_ERROR_THREAD
ErrorClassStashErrorClass=C.GIT_ERROR_STASH
ErrorClassCheckoutErrorClass=C.GIT_ERROR_CHECKOUT
ErrorClassFetchHeadErrorClass=C.GIT_ERROR_FETCHHEAD
ErrorClassMergeErrorClass=C.GIT_ERROR_MERGE
ErrorClassSSHErrorClass=C.GIT_ERROR_SSH
ErrorClassFilterErrorClass=C.GIT_ERROR_FILTER
ErrorClassRevertErrorClass=C.GIT_ERROR_REVERT
ErrorClassCallbackErrorClass=C.GIT_ERROR_CALLBACK
ErrorClassRebaseErrorClass=C.GIT_ERROR_REBASE
ErrorClassPatchErrorClass=C.GIT_ERROR_PATCH
)

//go:generate stringer -type ErrorCode -trimprefix ErrorCode -tags static
typeErrorCodeint

const (
// ErrorCodeOK indicates that the operation completed successfully.
ErrorCodeOKErrorCode=C.GIT_OK

// ErrorCodeGeneric represents a generic error.
ErrorCodeGenericErrorCode=C.GIT_ERROR
// ErrorCodeNotFound represents that the requested object could not be found
ErrorCodeNotFoundErrorCode=C.GIT_ENOTFOUND
// ErrorCodeExists represents that the object exists preventing operation.
ErrorCodeExistsErrorCode=C.GIT_EEXISTS
// ErrorCodeAmbiguous represents that more than one object matches.
ErrorCodeAmbiguousErrorCode=C.GIT_EAMBIGUOUS
// ErrorCodeBuffs represents that the output buffer is too short to hold data.
ErrorCodeBuffsErrorCode=C.GIT_EBUFS

// ErrorCodeUser 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.
ErrorCodeUserErrorCode=C.GIT_EUSER

// ErrorCodeBareRepo represents that the operation not allowed on bare repository
ErrorCodeBareRepoErrorCode=C.GIT_EBAREREPO
// ErrorCodeUnbornBranch represents that HEAD refers to branch with no commits.
ErrorCodeUnbornBranchErrorCode=C.GIT_EUNBORNBRANCH
// ErrorCodeUnmerged represents that a merge in progress prevented operation.
ErrorCodeUnmergedErrorCode=C.GIT_EUNMERGED
// ErrorCodeNonFastForward represents that the reference was not fast-forwardable.
ErrorCodeNonFastForwardErrorCode=C.GIT_ENONFASTFORWARD
// ErrorCodeInvalidSpec represents that the name/ref spec was not in a valid format.
ErrorCodeInvalidSpecErrorCode=C.GIT_EINVALIDSPEC
// ErrorCodeConflict represents that checkout conflicts prevented operation.
ErrorCodeConflictErrorCode=C.GIT_ECONFLICT
// ErrorCodeLocked represents that lock file prevented operation.
ErrorCodeLockedErrorCode=C.GIT_ELOCKED
// ErrorCodeModified represents that the reference value does not match expected.
ErrorCodeModifiedErrorCode=C.GIT_EMODIFIED
// ErrorCodeAuth represents that the authentication failed.
ErrorCodeAuthErrorCode=C.GIT_EAUTH
// ErrorCodeCertificate represents that the server certificate is invalid.
ErrorCodeCertificateErrorCode=C.GIT_ECERTIFICATE
// ErrorCodeApplied represents that the patch/merge has already been applied.
ErrorCodeAppliedErrorCode=C.GIT_EAPPLIED
// ErrorCodePeel represents that the requested peel operation is not possible.
ErrorCodePeelErrorCode=C.GIT_EPEEL
// ErrorCodeEOF represents an unexpected EOF.
ErrorCodeEOFErrorCode=C.GIT_EEOF
// ErrorCodeInvalid represents an invalid operation or input.
ErrorCodeInvalidErrorCode=C.GIT_EINVALID
// ErrorCodeUIncommitted represents that uncommitted changes in index prevented operation.
ErrorCodeUncommittedErrorCode=C.GIT_EUNCOMMITTED
// ErrorCodeDirectory represents that the operation is not valid for a directory.
ErrorCodeDirectoryErrorCode=C.GIT_EDIRECTORY
// ErrorCodeMergeConflict represents that a merge conflict exists and cannot continue.
ErrorCodeMergeConflictErrorCode=C.GIT_EMERGECONFLICT

// ErrorCodePassthrough represents that a user-configured callback refused to act.
ErrorCodePassthroughErrorCode=C.GIT_PASSTHROUGH
// ErrorCodeIterOver signals end of iteration with iterator.
ErrorCodeIterOverErrorCode=C.GIT_ITEROVER
// ErrorCodeRetry is an internal-only error code.
ErrorCodeRetryErrorCode=C.GIT_RETRY
// ErrorCodeMismatch represents a hashsum mismatch in object.
ErrorCodeMismatchErrorCode=C.GIT_EMISMATCH
// ErrorCodeIndexDirty represents that unsaved changes in the index would be overwritten.
ErrorCodeIndexDirtyErrorCode=C.GIT_EINDEXDIRTY
// ErrorCodeApplyFail represents that a patch application failed.
ErrorCodeApplyFailErrorCode=C.GIT_EAPPLYFAIL
)

var (
ErrInvalid=errors.New("Invalid state for operation")
)

// doNotCompare is an idiomatic way of making structs non-comparable to avoid
// future field additions to make them non-comparable.
typedoNotCompare [0]func()

varpointerHandles*HandleList
varremotePointers*remotePointerList

funcinit() {
initLibGit2()
}

funcinitLibGit2() {
pointerHandles=NewHandleList()
remotePointers=newRemotePointerList()

C.git_libgit2_init()
features:=Features()

// Due to the multithreaded nature of Go and its interaction with
// calling C functions, we cannot work with a library that was not built
// with multi-threading support. The most likely outcome is a segfault
// or panic at an incomprehensible time, so let's make it easy by
// panicking right here.
iffeatures&FeatureThreads==0 {
panic("libgit2 was not built with threading support")
 }

iffeatures&FeatureHTTPS==0 {
iferr:=registerManagedHTTP(); err!=nil {
panic(err)
 }
 } else {
// This is not something we should be doing, as we may be stomping all over
// someone else's setup. The user should do this themselves or use some
// binding/wrapper which does it in such a way that they can be sure
// they're the only ones setting it up.
C.git_openssl_set_locking()
 }
iffeatures&FeatureSSH==0 {
iferr:=registerManagedSSH(); err!=nil {
panic(err)
 }
 }
}

// Shutdown frees all the resources acquired by libgit2. Make sure no
// references to any git2go objects are live before calling this.
// After this is called, invoking any function from this library will result in
// undefined behavior, so make sure this is called carefully.
funcShutdown() {
iferr:=unregisterManagedTransports(); err!=nil {
panic(err)
 }
pointerHandles.Clear()
remotePointers.clear()

C.git_libgit2_shutdown()
}

// ReInit reinitializes the global state, this is useful if the effective user
// id has changed and you want to update the stored search paths for gitconfig
// files. This function frees any references to objects, so it should be called
// before any other functions are called.
funcReInit() {
Shutdown()
initLibGit2()
}

// Oid represents the id for a Git object.
typeOid [20]byte

funcnewOidFromC(coid*C.git_oid) *Oid {
ifcoid==nil {
returnnil
 }

oid:=new(Oid)
copy(oid[0:20], C.GoBytes(unsafe.Pointer(coid), 20))
returnoid
}

funcNewOidFromBytes(b []byte) *Oid {
oid:=new(Oid)
copy(oid[0:20], b[0:20])
returnoid
}

func (oid*Oid) toC() *C.git_oid {
return (*C.git_oid)(unsafe.Pointer(oid))
}

funcNewOid(sstring) (*Oid, error) {
iflen(s) >C.GIT_OID_HEXSZ {
returnnil, errors.New("string is too long for oid")
 }

o:=new(Oid)

slice, err:=hex.DecodeString(s)
iferr!=nil {
returnnil, err
 }

iflen(slice) !=20 {
returnnil, &GitError{"invalid oid", ErrorClassNone, ErrorCodeGeneric}
 }

copy(o[:], slice[:20])
returno, nil
}

func (oid*Oid) String() string {
returnhex.EncodeToString(oid[:])
}

func (oid*Oid) Cmp(oid2*Oid) int {
returnbytes.Compare(oid[:], oid2[:])
}

func (oid*Oid) Copy() *Oid {
ret:=*oid
return&ret
}

func (oid*Oid) Equal(oid2*Oid) bool {
return*oid==*oid2
}

func (oid*Oid) IsZero() bool {
return*oid==Oid{}
}

func (oid*Oid) NCmp(oid2*Oid, nuint) int {
returnbytes.Compare(oid[:n], oid2[:n])
}

funcShortenOids(ids []*Oid, minlenint) (int, error) {
shorten:=C.git_oid_shorten_new(C.size_t(minlen))
ifshorten==nil {
panic("Out of memory")
 }
deferC.git_oid_shorten_free(shorten)

varret C.int

runtime.LockOSThread()
deferruntime.UnlockOSThread()

for_, id:=rangeids {
buf:=make([]byte, 41)
C.git_oid_fmt((*C.char)(unsafe.Pointer(&buf[0])), id.toC())
buf[40] =0
ret=C.git_oid_shorten_add(shorten, (*C.char)(unsafe.Pointer(&buf[0])))
ifret<0 {
returnint(ret), MakeGitError(ret)
 }
 }
runtime.KeepAlive(ids)
returnint(ret), nil
}

typeGitErrorstruct {
Messagestring
ClassErrorClass
CodeErrorCode
}

func (eGitError) Error() string {
returne.Message
}

funcIsErrorClass(errerror, cErrorClass) bool {
iferr==nil {
returnfalse
 }
ifgitError, ok:=err.(*GitError); ok {
returngitError.Class==c
 }
returnfalse
}

funcIsErrorCode(errerror, cErrorCode) bool {
iferr==nil {
returnfalse
 }
ifgitError, ok:=err.(*GitError); ok {
returngitError.Code==c
 }
returnfalse
}

funcMakeGitError(c C.int) error {
varerrMessagestring
varerrClassErrorClass
errorCode:=ErrorCode(c)
iferrorCode!=ErrorCodeIterOver {
err:=C.git_error_last()
iferr!=nil {
errMessage=C.GoString(err.message)
errClass=ErrorClass(err.klass)
 } else {
errClass=ErrorClassInvalid
 }
 }
iferrMessage=="" {
errMessage=errorCode.String()
 }
return&GitError{errMessage, errClass, errorCode}
}

funcMakeGitError2(errint) error {
returnMakeGitError(C.int(err))
}

funccbool(bbool) C.int {
ifb {
returnC.int(1)
 }
returnC.int(0)
}

funcucbool(bbool) C.uint {
ifb {
returnC.uint(1)
 }
returnC.uint(0)
}

funcsetCallbackError(errorMessage**C.char, errerror) C.int {
iferr!=nil {
*errorMessage=C.CString(err.Error())
ifgitError, ok:=err.(*GitError); ok {
returnC.int(gitError.Code)
 }
returnC.int(ErrorCodeUser)
 }
returnC.int(ErrorCodeOK)
}

funcDiscover(startstring, across_fsbool, ceiling_dirs []string) (string, error) {
ceildirs:=C.CString(strings.Join(ceiling_dirs, string(C.GIT_PATH_LIST_SEPARATOR)))
deferC.free(unsafe.Pointer(ceildirs))

cstart:=C.CString(start)
deferC.free(unsafe.Pointer(cstart))

varbuf C.git_buf
deferC.git_buf_dispose(&buf)

runtime.LockOSThread()
deferruntime.UnlockOSThread()

ret:=C.git_repository_discover(&buf, cstart, cbool(across_fs), ceildirs)
ifret<0 {
return"", MakeGitError(ret)
 }

returnC.GoString(buf.ptr), nil
}