jcarr
/
git2go
1
0
Fork 0
Code Issues 52 Pull Requests 31 Packages Projects Releases Wiki Activity

merge with latest

This commit is contained in:
Jesse Ezell 2014-03-11 12:55:57 -07:00
parent 9fb7a746e0 1cf8117814
commit 634acbe498
11 changed files with 506 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
.travis.yml Normal file
View File

@ -0,0 +1,12 @@
language: go
go:
- 1.0
- 1.1
- tip
env:
- PKG_CONFIG_PATH=libgit2/install/lib/pkgconfig LD_LIBRARY_PATH=libgit2/install/lib
install:
- script/build-libgit2.sh

65
blob.go
View File

@ -3,9 +3,18 @@ package git
/*
#include <git2.h>
#include <git2/errors.h>
#include <string.h>
extern int _go_git_blob_create_fromchunks(git_oid *id,
git_repository *repo,
const char *hintpath,
void *payload);
*/
import "C"
import (
"io"
"runtime"
"unsafe"
)
@ -13,13 +22,65 @@ type Blob struct {
gitObject
}
func (v Blob) Size() int64 {
func (v *Blob) Size() int64 {
return int64(C.git_blob_rawsize(v.ptr))
}
func (v Blob) Contents() []byte {
func (v *Blob) Contents() []byte {
size := C.int(C.git_blob_rawsize(v.ptr))
buffer := unsafe.Pointer(C.git_blob_rawcontent(v.ptr))
return C.GoBytes(buffer, size)
}
func (repo *Repository) CreateBlobFromBuffer(data []byte) (*Oid, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
oid := C.git_oid{}
ecode := C.git_blob_create_frombuffer(&oid, repo.ptr, unsafe.Pointer(&data[0]), C.size_t(len(data)))
if ecode < 0 {
return nil, MakeGitError(ecode)
}
return newOidFromC(&oid), nil
}
type BlobChunkCallback func(maxLen int) ([]byte, error)
type BlobCallbackData struct {
Callback BlobChunkCallback
Error error
}
//export blobChunkCb
func blobChunkCb(buffer *C.char, maxLen C.size_t, payload unsafe.Pointer) int {
data := (*BlobCallbackData)(payload)
goBuf, err := data.Callback(int(maxLen))
if err == io.EOF {
return 1
} else if err != nil {
data.Error = err
return -1
}
C.memcpy(unsafe.Pointer(buffer), unsafe.Pointer(&goBuf), C.size_t(len(goBuf)))
return 0
}
func (repo *Repository) CreateBlobFromChunks(hintPath string, callback BlobChunkCallback) (*Oid, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var chintPath *C.char = nil
if len(hintPath) > 0 {
C.CString(hintPath)
defer C.free(unsafe.Pointer(chintPath))
}
oid := C.git_oid{}
payload := &BlobCallbackData{Callback: callback}
ecode := C._go_git_blob_create_fromchunks(&oid, repo.ptr, chintPath, unsafe.Pointer(payload))
if payload.Error != nil {
return nil, payload.Error
}
if ecode < 0 {
return nil, MakeGitError(ecode)
}
return newOidFromC(&oid), nil
}

193
branch.go Normal file
View File

@ -0,0 +1,193 @@
package git
/*
#cgo pkg-config: libgit2
#include <git2.h>
#include <git2/errors.h>
*/
import "C"
import (
"runtime"
"unsafe"
)
type BranchType uint
const (
BranchLocal BranchType = C.GIT_BRANCH_LOCAL
BranchRemote = C.GIT_BRANCH_REMOTE
)
type Branch struct {
Reference
}
func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool, signature *Signature, msg string) (*Reference, error) {
ref := new(Reference)
cBranchName := C.CString(branchName)
cForce := cbool(force)
cSignature := signature.toC()
defer C.git_signature_free(cSignature)
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_create(&ref.ptr, repo.ptr, cBranchName, target.ptr, cForce, cSignature, cmsg)
if ret < 0 {
return nil, MakeGitError(ret)
}
return ref, nil
}
func (b *Branch) Delete() error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_delete(b.ptr)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
func (b *Branch) Move(newBranchName string, force bool, signature *Signature, msg string) (*Branch, error) {
newBranch := new(Branch)
cNewBranchName := C.CString(newBranchName)
cForce := cbool(force)
cSignature := signature.toC()
defer C.git_signature_free(cSignature)
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_move(&newBranch.ptr, b.ptr, cNewBranchName, cForce, cSignature, cmsg)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newBranch, nil
}
func (b *Branch) IsHead() (bool, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_is_head(b.ptr)
switch ret {
case 1:
return true, nil
case 0:
return false, nil
}
return false, MakeGitError(ret)
}
func (repo *Repository) LookupBranch(branchName string, bt BranchType) (*Branch, error) {
branch := new(Branch)
cName := C.CString(branchName)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_lookup(&branch.ptr, repo.ptr, cName, C.git_branch_t(bt))
if ret < 0 {
return nil, MakeGitError(ret)
}
return branch, nil
}
func (b *Branch) Name() (string, error) {
var cName *C.char
defer C.free(unsafe.Pointer(cName))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_name(&cName, b.ptr)
if ret < 0 {
return "", MakeGitError(ret)
}
return C.GoString(cName), nil
}
func (repo *Repository) RemoteName(canonicalBranchName string) (string, error) {
cName := C.CString(canonicalBranchName)
nameBuf := C.git_buf{}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_remote_name(&nameBuf, repo.ptr, cName)
if ret < 0 {
return "", MakeGitError(ret)
}
defer C.git_buf_free(&nameBuf)
return C.GoString(nameBuf.ptr), nil
}
func (b *Branch) SetUpstream(upstreamName string) error {
cName := C.CString(upstreamName)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_set_upstream(b.ptr, cName)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
func (b *Branch) Upstream() (*Branch, error) {
upstream := new(Branch)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_upstream(&upstream.ptr, b.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
return upstream, nil
}
func (repo *Repository) UpstreamName(canonicalBranchName string) (string, error) {
cName := C.CString(canonicalBranchName)
nameBuf := C.git_buf{}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_upstream_name(&nameBuf, repo.ptr, cName)
if ret < 0 {
return "", MakeGitError(ret)
}
defer C.git_buf_free(&nameBuf)
return C.GoString(nameBuf.ptr), nil
}

43
checkout.go
View File

@ -2,10 +2,6 @@ package git
/*
#include <git2.h>
git_checkout_opts git_checkout_opts_init() {
git_checkout_opts ret = GIT_CHECKOUT_OPTS_INIT;
return ret;
}
*/
import "C"
import (
@ -42,28 +38,34 @@ type CheckoutOpts struct {
FileOpenFlags int // Default is O_CREAT | O_TRUNC | O_WRONLY
}
// Convert the CheckoutOpts struct to the corresponding C-struct
func populateCheckoutOpts(ptr *C.git_checkout_opts, opts *CheckoutOpts) {
*ptr = C.git_checkout_opts_init()
// Convert the CheckoutOpts struct to the corresponding
// C-struct. Returns a pointer to ptr, or nil if opts is nil, in order
// to help with what to pass.
func populateCheckoutOpts(ptr *C.git_checkout_options, opts *CheckoutOpts) *C.git_checkout_options {
if opts == nil {
return
return nil
}
C.git_checkout_init_opts(ptr, 1)
ptr.checkout_strategy = C.uint(opts.Strategy)
ptr.disable_filters = cbool(opts.DisableFilters)
ptr.dir_mode = C.uint(opts.DirMode.Perm())
ptr.file_mode = C.uint(opts.FileMode.Perm())
return ptr
}
// Updates files in the index and the working tree to match the content of
// the commit pointed at by HEAD.
func (v *Repository) Checkout(opts *CheckoutOpts) error {
var copts C.git_checkout_opts
populateCheckoutOpts(&copts, opts)
// the commit pointed at by HEAD. opts may be nil.
func (v *Repository) CheckoutHead(opts *CheckoutOpts) error {
var copts C.git_checkout_options
ptr := populateCheckoutOpts(&copts, opts)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_checkout_head(v.ptr, &copts)
ret := C.git_checkout_head(v.ptr, ptr)
if ret < 0 {
return MakeGitError(ret)
}
@ -71,15 +73,22 @@ func (v *Repository) Checkout(opts *CheckoutOpts) error {
return nil
}
// Updates files in the working tree to match the content of the index.
// Updates files in the working tree to match the content of the given
// index. If index is nil, the repository's index will be used. opts
// may be nil.
func (v *Repository) CheckoutIndex(index *Index, opts *CheckoutOpts) error {
var copts C.git_checkout_opts
populateCheckoutOpts(&copts, opts)
var copts C.git_checkout_options
ptr := populateCheckoutOpts(&copts, opts)
var iptr *C.git_index = nil
if index != nil {
iptr = index.ptr
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_checkout_index(v.ptr, index.ptr, &copts)
ret := C.git_checkout_index(v.ptr, iptr, ptr)
if ret < 0 {
return MakeGitError(ret)
}

38
reference.go
View File

@ -40,8 +40,13 @@ func (v *Reference) SetSymbolicTarget(target string, sig *Signature, msg string)
csig := sig.toC()
defer C.free(unsafe.Pointer(csig))
cmsg := C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
ret := C.git_reference_symbolic_set_target(&ptr, v.ptr, ctarget, csig, cmsg)
if ret < 0 {
@ -60,8 +65,13 @@ func (v *Reference) SetTarget(target *Oid, sig *Signature, msg string) (*Referen
csig := sig.toC()
defer C.free(unsafe.Pointer(csig))
cmsg := C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
ret := C.git_reference_set_target(&ptr, v.ptr, target.toC(), csig, cmsg)
if ret < 0 {
@ -93,8 +103,13 @@ func (v *Reference) Rename(name string, force bool, sig *Signature, msg string)
csig := sig.toC()
defer C.free(unsafe.Pointer(csig))
cmsg := C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
@ -134,6 +149,17 @@ func (v *Reference) Delete() error {
return nil
}
// Cmp compares both references, retursn 0 on equality, otherwise a
// stable sorting.
func (v *Reference) Cmp(ref2 *Reference) int {
return int(C.git_reference_cmp(v.ptr, ref2.ptr))
}
// Shorthand returns a "human-readable" short reference name
func (v *Reference) Shorthand() string {
return C.GoString(C.git_reference_shorthand(v.ptr))
}
func (v *Reference) Name() string {
return C.GoString(C.git_reference_name(v.ptr))
}

27
reference_test.go
View File

@ -159,6 +159,33 @@ func TestIterator(t *testing.T) {
compareStringList(t, expected, list)
}
func TestUtil(t *testing.T) {
repo := createTestRepo(t)
defer os.RemoveAll(repo.Workdir())
commitId, _ := seedTestRepo(t, repo)
ref, err := repo.CreateReference("refs/heads/foo", commitId, true, nil, "")
checkFatal(t, err)
ref2, err := repo.DwimReference("foo")
checkFatal(t, err)
if ref.Cmp(ref2) != 0 {
t.Fatalf("foo didn't dwim to the right thing")
}
if ref.Shorthand() != "foo" {
t.Fatalf("refs/heads/foo has no foo shorthand")
}
hasLog, err := repo.HasLog("refs/heads/foo")
checkFatal(t, err)
if !hasLog {
t.Fatalf("branches ahve logs by default")
}
}
func compareStringList(t *testing.T, expected, actual []string) {
for i, v := range expected {
if actual[i] != v {

91
repository.go
View File

@ -153,8 +153,13 @@ func (v *Repository) CreateReference(name string, id *Oid, force bool, sig *Sign
csig := sig.toC()
defer C.free(unsafe.Pointer(csig))
cmsg := C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
var ptr *C.git_reference
@ -179,8 +184,13 @@ func (v *Repository) CreateSymbolicReference(name, target string, force bool, si
csig := sig.toC()
defer C.free(unsafe.Pointer(csig))
cmsg := C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
var ptr *C.git_reference
@ -196,19 +206,18 @@ func (v *Repository) CreateSymbolicReference(name, target string, force bool, si
}
func (v *Repository) Walk() (*RevWalk, error) {
walk := new(RevWalk)
var walkPtr *C.git_revwalk
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C.git_revwalk_new(&walk.ptr, v.ptr)
ecode := C.git_revwalk_new(&walkPtr, v.ptr)
if ecode < 0 {
return nil, MakeGitError(ecode)
}
walk.repo = v
runtime.SetFinalizer(walk, freeRevWalk)
return walk, nil
return revWalkFromC(v, walkPtr), nil
}
func (v *Repository) CreateCommit(
@ -316,6 +325,21 @@ func (v *Repository) TreeBuilder() (*TreeBuilder, error) {
return bld, nil
}
func (v *Repository) TreeBuilderFromTree(tree *Tree) (*TreeBuilder, error) {
bld := new(TreeBuilder)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if ret := C.git_treebuilder_create(&bld.ptr, tree.ptr); ret < 0 {
return nil, MakeGitError(ret)
}
runtime.SetFinalizer(bld, (*TreeBuilder).Free)
bld.repo = v
return bld, nil
}
func (v *Repository) RevparseSingle(spec string) (Object, error) {
cspec := C.CString(spec)
defer C.free(unsafe.Pointer(cspec))
@ -332,3 +356,52 @@ func (v *Repository) RevparseSingle(spec string) (Object, error) {
return allocObject(ptr), nil
}
// EnsureLog ensures that there is a reflog for the given reference
// name and creates an empty one if necessary.
func (v *Repository) EnsureLog(name string) error {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if ret := C.git_reference_ensure_log(v.ptr, cname); ret < 0 {
return MakeGitError(ret)
}
return nil
}
// HasLog returns whether there is a reflog for the given reference
// name
func (v *Repository) HasLog(name string) (bool, error) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_has_log(v.ptr, cname)
if ret < 0 {
return false, MakeGitError(ret)
}
return ret == 1, nil
}
// DwimReference looks up a reference by DWIMing its short name
func (v *Repository) DwimReference(name string) (*Reference, error) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var ptr *C.git_reference
if ret := C.git_reference_dwim(&ptr, v.ptr, cname); ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr), nil
}

17
script/build-libgit2.sh Executable file
View File

@ -0,0 +1,17 @@
#!/bin/sh
set -ex
git clone --depth 1 --single-branch git://github.com/libgit2/libgit2 libgit2
cd libgit2
cmake -DTHREADSAFE=ON \
-DBUILD_CLAR=OFF \
-DCMAKE_INSTALL_PREFIX=$PWD/install \
.
make install
# Let the Go build system know where to find libgit2
export LD_LIBRARY_PATH="$TMPDIR/libgit2/install/lib"
export PKG_CONFIG_PATH="$TMPDIR/libgit2/install/lib/pkgconfig"

38
tree.go
View File

@ -14,13 +14,14 @@ import (
)
type Filemode int
const (
FilemodeNew Filemode = C.GIT_FILEMODE_NEW
FilemodeTree = C.GIT_FILEMODE_TREE
FilemodeBlob = C.GIT_FILEMODE_BLOB
FilemodeBlobExecutable = C.GIT_FILEMODE_BLOB_EXECUTABLE
FilemodeLink = C.GIT_FILEMODE_LINK
FilemodeCommit = C.GIT_FILEMODE_COMMIT
FilemodeNew Filemode = C.GIT_FILEMODE_NEW
FilemodeTree = C.GIT_FILEMODE_TREE
FilemodeBlob = C.GIT_FILEMODE_BLOB
FilemodeBlobExecutable = C.GIT_FILEMODE_BLOB_EXECUTABLE
FilemodeLink = C.GIT_FILEMODE_LINK
FilemodeCommit = C.GIT_FILEMODE_COMMIT
)
type Tree struct {
@ -28,9 +29,9 @@ type Tree struct {
}
type TreeEntry struct {
Name string
Id *Oid
Type ObjectType
Name string
Id *Oid
Type ObjectType
Filemode int
}
@ -116,7 +117,7 @@ func (t Tree) Walk(callback TreeWalkCallback) error {
}
type TreeBuilder struct {
ptr *C.git_treebuilder
ptr *C.git_treebuilder
repo *Repository
}
@ -125,7 +126,7 @@ func (v *TreeBuilder) Free() {
C.git_treebuilder_free(v.ptr)
}
func (v *TreeBuilder) Insert(filename string, id *Oid, filemode int) (error) {
func (v *TreeBuilder) Insert(filename string, id *Oid, filemode int) error {
cfilename := C.CString(filename)
defer C.free(unsafe.Pointer(cfilename))
@ -140,6 +141,21 @@ func (v *TreeBuilder) Insert(filename string, id *Oid, filemode int) (error) {
return nil
}
func (v *TreeBuilder) Remove(filename string) error {
cfilename := C.CString(filename)
defer C.free(unsafe.Pointer(cfilename))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C.git_treebuilder_remove(v.ptr, cfilename)
if err < 0 {
return MakeGitError(err)
}
return nil
}
func (v *TreeBuilder) Write() (*Oid, error) {
oid := new(Oid)

21
walk.go
View File

@ -14,11 +14,12 @@ import (
// RevWalk
type SortType uint
const (
SortNone SortType = C.GIT_SORT_NONE
SortTopological = C.GIT_SORT_TOPOLOGICAL
SortTime = C.GIT_SORT_TIME
SortReverse = C.GIT_SORT_REVERSE
SortNone SortType = C.GIT_SORT_NONE
SortTopological = C.GIT_SORT_TOPOLOGICAL
SortTime = C.GIT_SORT_TIME
SortReverse = C.GIT_SORT_REVERSE
)
type RevWalk struct {
@ -26,6 +27,12 @@ type RevWalk struct {
repo *Repository
}
func revWalkFromC(repo *Repository, c *C.git_revwalk) *RevWalk {
v := &RevWalk{ptr: c, repo: repo}
runtime.SetFinalizer(v, (*RevWalk).Free)
return v
}
func (v *RevWalk) Reset() {
C.git_revwalk_reset(v.ptr)
}
@ -92,6 +99,8 @@ func (v *RevWalk) Sorting(sm SortType) {
C.git_revwalk_sorting(v.ptr, C.uint(sm))
}
func freeRevWalk(walk *RevWalk) {
C.git_revwalk_free(walk.ptr)
func (v *RevWalk) Free() {
runtime.SetFinalizer(v, nil)
C.git_revwalk_free(v.ptr)
}

12
wrapper.c
View File

@ -63,4 +63,16 @@ int _go_git_push_set_callbacks(git_push *push, void *packbuilder_progress_data,
return git_push_set_callbacks(push, packbuilderProgress, packbuilder_progress_data, pushTransferProgress, transfer_progress_data);
}
int _go_blob_chunk_cb(char *buffer, size_t maxLen, void *payload)
{
return blobChunkCb(buffer, maxLen, payload);
}
int _go_git_blob_create_fromchunks(git_oid *id,
git_repository *repo,
const char *hintpath,
void *payload)
{
return git_blob_create_fromchunks(id, repo, hintpath, _go_blob_chunk_cb, payload);
}
/* EOF */