summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--checkout.go4
-rw-r--r--clone.go17
-rw-r--r--commit.go7
-rw-r--r--config.go311
-rw-r--r--git.go50
-rw-r--r--index.go54
-rw-r--r--odb.go30
-rw-r--r--odb_test.go27
-rw-r--r--packbuilder.go10
-rw-r--r--reference.go62
-rw-r--r--reference_test.go19
-rw-r--r--remote.go182
-rw-r--r--repository.go76
-rw-r--r--submodule.go44
-rw-r--r--tree.go8
-rw-r--r--walk.go8
16 files changed, 724 insertions, 185 deletions
diff --git a/checkout.go b/checkout.go
index f4c1d4e..d3cd47b 100644
--- a/checkout.go
+++ b/checkout.go
@@ -65,7 +65,7 @@ func (v *Repository) Checkout(opts *CheckoutOpts) error {
ret := C.git_checkout_head(v.ptr, &copts)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
@@ -81,7 +81,7 @@ func (v *Repository) CheckoutIndex(index *Index, opts *CheckoutOpts) error {
ret := C.git_checkout_index(v.ptr, index.ptr, &copts)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
diff --git a/clone.go b/clone.go
index 425e179..630c343 100644
--- a/clone.go
+++ b/clone.go
@@ -19,20 +19,20 @@ import (
type CloneOptions struct {
*CheckoutOpts
*RemoteCallbacks
- Bare bool
+ Bare bool
IgnoreCertErrors bool
- RemoteName string
- CheckoutBranch string
+ RemoteName string
+ CheckoutBranch string
}
func Clone(url string, path string, options *CloneOptions) (*Repository, error) {
repo := new(Repository)
- curl := C.CString(url)
- defer C.free(unsafe.Pointer(curl))
+ curl := C.CString(url)
+ defer C.free(unsafe.Pointer(curl))
- cpath := C.CString(path)
- defer C.free(unsafe.Pointer(cpath))
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
var copts C.git_clone_options
populateCloneOptions(&copts, options)
@@ -52,7 +52,7 @@ func Clone(url string, path string, options *CloneOptions) (*Repository, error)
defer runtime.UnlockOSThread()
ret := C.git_clone(&repo.ptr, curl, cpath, &copts)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
runtime.SetFinalizer(repo, (*Repository).Free)
@@ -77,4 +77,3 @@ func populateCloneOptions(ptr *C.git_clone_options, opts *CloneOptions) {
ptr.ignore_cert_errors = 0
}
}
-
diff --git a/commit.go b/commit.go
index 498669e..0edebb6 100644
--- a/commit.go
+++ b/commit.go
@@ -31,7 +31,7 @@ func (c Commit) Tree() (*Tree, error) {
err := C.git_commit_tree(&ptr, c.ptr)
if err < 0 {
- return nil, LastError()
+ return nil, MakeGitError(err)
}
return allocObject(ptr).(*Tree), nil
@@ -94,6 +94,11 @@ func (v *Signature) Offset() int {
}
func (sig *Signature) toC() *C.git_signature {
+
+ if sig == nil {
+ return nil
+ }
+
var out *C.git_signature
name := C.CString(sig.Name)
diff --git a/config.go b/config.go
index 2aa073a..6b1f093 100644
--- a/config.go
+++ b/config.go
@@ -10,11 +10,81 @@ import (
"unsafe"
)
+type ConfigLevel int
+
+const (
+ // System-wide configuration file; /etc/gitconfig on Linux systems
+ ConfigLevelSystem ConfigLevel = C.GIT_CONFIG_LEVEL_SYSTEM
+
+ // XDG compatible configuration file; typically ~/.config/git/config
+ ConfigLevelXDG ConfigLevel = C.GIT_CONFIG_LEVEL_XDG
+
+ // User-specific configuration file (also called Global configuration
+ // file); typically ~/.gitconfig
+ ConfigLevelGlobal ConfigLevel = C.GIT_CONFIG_LEVEL_GLOBAL
+
+ // Repository specific configuration file; $WORK_DIR/.git/config on
+ // non-bare repos
+ ConfigLevelLocal ConfigLevel = C.GIT_CONFIG_LEVEL_LOCAL
+
+ // Application specific configuration file; freely defined by applications
+ ConfigLevelApp ConfigLevel = C.GIT_CONFIG_LEVEL_APP
+
+ // Represents the highest level available config file (i.e. the most
+ // specific config file available that actually is loaded)
+ ConfigLevelHighest ConfigLevel = C.GIT_CONFIG_HIGHEST_LEVEL
+)
+
+type ConfigEntry struct {
+ Name string
+ Value string
+ Level ConfigLevel
+}
+
+func newConfigEntryFromC(centry *C.git_config_entry) *ConfigEntry {
+ return &ConfigEntry{
+ Name: C.GoString(centry.name),
+ Value: C.GoString(centry.value),
+ Level: ConfigLevel(centry.level),
+ }
+}
+
type Config struct {
ptr *C.git_config
}
-func (c *Config) LookupInt32(name string) (v int32, err error) {
+// NewConfig creates a new empty configuration object
+func NewConfig() (*Config, error) {
+ config := new(Config)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_config_new(&config.ptr); ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return config, nil
+}
+
+// AddFile adds a file-backed backend to the config object at the specified level.
+func (c *Config) AddFile(path string, level ConfigLevel, force bool) error {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+
+ ret := C.git_config_add_file_ondisk(c.ptr, cpath, C.git_config_level_t(level), cbool(force))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) LookupInt32(name string) (int32, error) {
var out C.int32_t
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
@@ -24,13 +94,13 @@ func (c *Config) LookupInt32(name string) (v int32, err error) {
ret := C.git_config_get_int32(&out, c.ptr, cname)
if ret < 0 {
- return 0, LastError()
+ return 0, MakeGitError(ret)
}
return int32(out), nil
}
-func (c *Config) LookupInt64(name string) (v int64, err error) {
+func (c *Config) LookupInt64(name string) (int64, error) {
var out C.int64_t
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
@@ -40,13 +110,13 @@ func (c *Config) LookupInt64(name string) (v int64, err error) {
ret := C.git_config_get_int64(&out, c.ptr, cname)
if ret < 0 {
- return 0, LastError()
+ return 0, MakeGitError(ret)
}
return int64(out), nil
}
-func (c *Config) LookupString(name string) (v string, err error) {
+func (c *Config) LookupString(name string) (string, error) {
var ptr *C.char
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
@@ -54,15 +124,91 @@ func (c *Config) LookupString(name string) (v string, err error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_config_get_string(&ptr, c.ptr, cname)
- if ret < 0 {
- return "", LastError()
+ if ret := C.git_config_get_string(&ptr, c.ptr, cname); ret < 0 {
+ return "", MakeGitError(ret)
}
return C.GoString(ptr), nil
}
-func (c *Config) Set(name, value string) (err error) {
+
+func (c *Config) LookupBool(name string) (bool, error) {
+ var out C.int
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_get_bool(&out, c.ptr, cname)
+ if ret < 0 {
+ return false, MakeGitError(ret)
+ }
+
+ return out != 0, nil
+}
+
+func (c *Config) NewMultivarIterator(name, regexp string) (*ConfigIterator, error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ var cregexp *C.char
+ if regexp == "" {
+ cregexp = nil
+ } else {
+ cregexp = C.CString(regexp)
+ defer C.free(unsafe.Pointer(cregexp))
+ }
+
+ iter := new(ConfigIterator)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_multivar_iterator_new(&iter.ptr, c.ptr, cname, cregexp)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ runtime.SetFinalizer(iter, (*ConfigIterator).Free)
+ return iter, nil
+}
+
+// NewIterator creates an iterator over each entry in the
+// configuration
+func (c *Config) NewIterator() (*ConfigIterator, error) {
+ iter := new(ConfigIterator)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_iterator_new(&iter.ptr, c.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return iter, nil
+}
+
+// NewIteratorGlob creates an iterator over each entry in the
+// configuration whose name matches the given regular expression
+func (c *Config) NewIteratorGlob(regexp string) (*ConfigIterator, error) {
+ iter := new(ConfigIterator)
+ cregexp := C.CString(regexp)
+ defer C.free(unsafe.Pointer(cregexp))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_iterator_glob_new(&iter.ptr, c.ptr, cregexp)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return iter, nil
+}
+
+func (c *Config) SetString(name, value string) (err error) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
@@ -74,7 +220,7 @@ func (c *Config) Set(name, value string) (err error) {
ret := C.git_config_set_string(c.ptr, cname, cvalue)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
@@ -84,3 +230,148 @@ func (c *Config) Free() {
runtime.SetFinalizer(c, nil)
C.git_config_free(c.ptr)
}
+
+func (c *Config) SetInt32(name string, value int32) (err error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ ret := C.git_config_set_int32(c.ptr, cname, C.int32_t(value))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) SetInt64(name string, value int64) (err error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_set_int64(c.ptr, cname, C.int64_t(value))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) SetBool(name string, value bool) (err error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_set_bool(c.ptr, cname, cbool(value))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) SetMultivar(name, regexp, value string) (err error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ cregexp := C.CString(regexp)
+ defer C.free(unsafe.Pointer(cregexp))
+
+ cvalue := C.CString(value)
+ defer C.free(unsafe.Pointer(cvalue))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_set_multivar(c.ptr, cname, cregexp, cvalue)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) Delete(name string) error {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_delete_entry(c.ptr, cname)
+
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+// OpenLevel creates a single-level focused config object from a multi-level one
+func (c *Config) OpenLevel(parent *Config, level ConfigLevel) (*Config, error) {
+ config := new(Config)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_open_level(&config.ptr, parent.ptr, C.git_config_level_t(level))
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return config, nil
+}
+
+// OpenOndisk creates a new config instance containing a single on-disk file
+func OpenOndisk(parent *Config, path string) (*Config, error) {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ config := new(Config)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_config_open_ondisk(&config.ptr, cpath); ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return config, nil
+}
+
+// Refresh refreshes the configuration to reflect any changes made externally e.g. on disk
+func (c *Config) Refresh() error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_config_refresh(c.ptr); ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+type ConfigIterator struct {
+ ptr *C.git_config_iterator
+}
+
+// Next returns the next entry for this iterator
+func (iter *ConfigIterator) Next() (*ConfigEntry, error) {
+ var centry *C.git_config_entry
+
+ ret := C.git_config_next(&centry, iter.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newConfigEntryFromC(centry), nil
+}
+
+func (iter *ConfigIterator) Free() {
+ runtime.SetFinalizer(iter, nil)
+ C.free(unsafe.Pointer(iter.ptr))
+}
+
diff --git a/git.go b/git.go
index 07892e4..db9522b 100644
--- a/git.go
+++ b/git.go
@@ -1,7 +1,7 @@
package git
/*
-#cgo pkg-config: --static libgit2
+#cgo pkg-config: libgit2
#include <git2.h>
#include <git2/errors.h>
*/
@@ -10,8 +10,8 @@ import (
"bytes"
"errors"
"runtime"
- "unsafe"
"strings"
+ "unsafe"
)
const (
@@ -61,8 +61,8 @@ func NewOidFromString(s string) (*Oid, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- if C.git_oid_fromstr(o.toC(), cs) < 0 {
- return nil, LastError()
+ if ret := C.git_oid_fromstr(o.toC(), cs); ret < 0 {
+ return nil, MakeGitError(ret)
}
return o, nil
@@ -93,7 +93,7 @@ func (oid *Oid) Equal(oid2 *Oid) bool {
}
func (oid *Oid) IsZero() bool {
- for _, a := range(oid.bytes) {
+ for _, a := range oid.bytes {
if a != '0' {
return false
}
@@ -123,38 +123,47 @@ func ShortenOids(ids []*Oid, minlen int) (int, error) {
buf[40] = 0
ret = C.git_oid_shorten_add(shorten, (*C.char)(unsafe.Pointer(&buf[0])))
if ret < 0 {
- return int(ret), LastError()
+ return int(ret), MakeGitError(ret)
}
}
return int(ret), nil
}
type GitError struct {
- Message string
- Code int
+ Message string
+ Class int
+ ErrorCode int
}
-func (e GitError) Error() string{
+func (e GitError) Error() string {
return e.Message
}
-func LastError() error {
+func IsNotExist(err error) bool {
+ return err.(*GitError).ErrorCode == C.GIT_ENOTFOUND
+}
+
+func IsExist(err error) bool {
+ return err.(*GitError).ErrorCode == C.GIT_EEXISTS
+}
+
+func MakeGitError(errorCode C.int) error {
err := C.giterr_last()
if err == nil {
- return &GitError{"No message", 0}
+ return &GitError{"No message", C.GITERR_INVALID, C.GIT_ERROR}
}
- return &GitError{C.GoString(err.message), int(err.klass)}
+ return &GitError{C.GoString(err.message), int(err.klass), int(errorCode)}
}
func cbool(b bool) C.int {
- if (b) {
+ if b {
return C.int(1)
}
return C.int(0)
}
func ucbool(b bool) C.uint {
- if (b) {
+ if b {
return C.uint(1)
}
return C.uint(0)
@@ -167,17 +176,16 @@ func Discover(start string, across_fs bool, ceiling_dirs []string) (string, erro
cstart := C.CString(start)
defer C.free(unsafe.Pointer(cstart))
- retpath := (*C.char)(C.malloc(C.GIT_PATH_MAX))
- defer C.free(unsafe.Pointer(retpath))
+ var buf C.git_buf
+ defer C.git_buf_free(&buf)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- r := C.git_repository_discover(retpath, C.GIT_PATH_MAX, cstart, cbool(across_fs), ceildirs)
-
- if r == 0 {
- return C.GoString(retpath), nil
+ ret := C.git_repository_discover(&buf, cstart, cbool(across_fs), ceildirs)
+ if ret < 0 {
+ return "", MakeGitError(ret)
}
- return "", LastError()
+ return C.GoString(buf.ptr), nil
}
diff --git a/index.go b/index.go
index ac5148c..6da3c98 100644
--- a/index.go
+++ b/index.go
@@ -6,7 +6,9 @@ package git
*/
import "C"
import (
+ "fmt"
"runtime"
+ "time"
"unsafe"
)
@@ -14,6 +16,17 @@ type Index struct {
ptr *C.git_index
}
+type IndexEntry struct {
+ Ctime time.Time
+ Mtime time.Time
+ Mode uint
+ Uid uint
+ Gid uint
+ Size uint
+ Id *Oid
+ Path string
+}
+
func newIndexFromC(ptr *C.git_index) *Index {
idx := &Index{ptr}
runtime.SetFinalizer(idx, (*Index).Free)
@@ -29,7 +42,7 @@ func (v *Index) AddByPath(path string) error {
ret := C.git_index_add_bypath(v.ptr, cstr)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
@@ -43,13 +56,50 @@ func (v *Index) WriteTree() (*Oid, error) {
ret := C.git_index_write_tree(oid.toC(), v.ptr)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return oid, nil
}
+func (v *Index) Write() (error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_index_write(v.ptr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
func (v *Index) Free() {
runtime.SetFinalizer(v, nil)
C.git_index_free(v.ptr)
}
+
+func (v *Index) EntryCount() uint {
+ return uint(C.git_index_entrycount(v.ptr))
+}
+
+func newIndexEntryFromC(entry *C.git_index_entry) *IndexEntry {
+ return &IndexEntry{
+ time.Unix(int64(entry.ctime.seconds), int64(entry.ctime.nanoseconds)),
+ time.Unix(int64(entry.mtime.seconds), int64(entry.mtime.nanoseconds)),
+ uint(entry.mode),
+ uint(entry.uid),
+ uint(entry.gid),
+ uint(entry.file_size),
+ newOidFromC(&entry.id),
+ C.GoString(entry.path),
+ }
+}
+
+func (v *Index) EntryByIndex(index uint) (*IndexEntry, error) {
+ centry := C.git_index_get_byindex(v.ptr, C.size_t(index))
+ if centry == nil {
+ return nil, fmt.Errorf("Index out of Bounds")
+ }
+ return newIndexEntryFromC(centry), nil
+}
diff --git a/odb.go b/odb.go
index 638ef74..daf63dd 100644
--- a/odb.go
+++ b/odb.go
@@ -32,7 +32,7 @@ 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 = LastError()
+ err = MakeGitError(ret)
}
return
@@ -46,7 +46,7 @@ func (v *Odb) Read(oid *Oid) (obj *OdbObject, err error) {
ret := C.git_odb_read(&obj.ptr, v.ptr, oid.toC())
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
runtime.SetFinalizer(obj, (*OdbObject).Free)
@@ -79,13 +79,29 @@ func (v *Odb) ForEach() chan *Oid {
return ch
}
+// Hash determines the object-ID (sha1) of a data buffer.
+func (v *Odb) Hash(data []byte, otype ObjectType) (oid *Oid, err error) {
+ oid = new(Oid)
+ header := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+ ptr := unsafe.Pointer(header.Data)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_hash(oid.toC(), ptr, C.size_t(header.Len), C.git_otype(otype));
+ if ret < 0 {
+ err = MakeGitError(ret)
+ }
+ return
+}
+
// NewReadStream opens a read stream from the ODB. Reading from it will give you the
// contents of the object.
func (v *Odb) NewReadStream(id *Oid) (*OdbReadStream, error) {
stream := new(OdbReadStream)
ret := C.git_odb_open_rstream(&stream.ptr, v.ptr, id.toC())
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
runtime.SetFinalizer(stream, (*OdbReadStream).Free)
@@ -99,7 +115,7 @@ func (v *Odb) NewWriteStream(size int, otype ObjectType) (*OdbWriteStream, error
stream := new(OdbWriteStream)
ret := C.git_odb_open_wstream(&stream.ptr, v.ptr, C.size_t(size), C.git_otype(otype))
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
runtime.SetFinalizer(stream, (*OdbWriteStream).Free)
@@ -148,7 +164,7 @@ func (stream *OdbReadStream) Read(data []byte) (int, error) {
size := C.size_t(header.Cap)
ret := C.git_odb_stream_read(stream.ptr, ptr, size)
if ret < 0 {
- return 0, LastError()
+ return 0, MakeGitError(ret)
}
header.Len = int(ret)
@@ -180,7 +196,7 @@ func (stream *OdbWriteStream) Write(data []byte) (int, error) {
ret := C.git_odb_stream_write(stream.ptr, ptr, size)
if ret < 0 {
- return 0, LastError()
+ return 0, MakeGitError(ret)
}
return len(data), nil
@@ -191,7 +207,7 @@ func (stream *OdbWriteStream) Write(data []byte) (int, error) {
func (stream *OdbWriteStream) Close() error {
ret := C.git_odb_stream_finalize_write(stream.Id.toC(), stream.ptr)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
diff --git a/odb_test.go b/odb_test.go
index 3c7624c..a4f8943 100644
--- a/odb_test.go
+++ b/odb_test.go
@@ -32,4 +32,31 @@ func TestOdbStream(t *testing.T) {
if stream.Id.Cmp(expectedId) != 0 {
t.Fatal("Wrong data written")
}
+}
+
+func TestOdbHash(t *testing.T) {
+
+ repo := createTestRepo(t)
+ defer os.RemoveAll(repo.Workdir())
+ _, _ = seedTestRepo(t, repo)
+
+ odb, error := repo.Odb()
+ checkFatal(t, error)
+
+ str := `tree 115fcae49287c82eb55bb275cbbd4556fbed72b7
+parent 66e1c476199ebcd3e304659992233132c5a52c6c
+author John Doe <[email protected]> 1390682018 +0000
+committer John Doe <[email protected]> 1390682018 +0000
+
+Initial commit.`;
+
+ oid, error := odb.Hash([]byte(str), ObjectCommit)
+ checkFatal(t, error)
+
+ coid, error := odb.Write([]byte(str), ObjectCommit)
+ checkFatal(t, error)
+
+ if oid.Cmp(coid) != 0 {
+ t.Fatal("Hash and write Oids are different")
+ }
} \ No newline at end of file
diff --git a/packbuilder.go b/packbuilder.go
index 333f183..70c4530 100644
--- a/packbuilder.go
+++ b/packbuilder.go
@@ -28,7 +28,7 @@ func (repo *Repository) NewPackbuilder() (*Packbuilder, error) {
ret := C.git_packbuilder_new(&builder.ptr, repo.ptr)
if ret != 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
runtime.SetFinalizer(builder, (*Packbuilder).Free)
return builder, nil
@@ -48,7 +48,7 @@ func (pb *Packbuilder) Insert(id *Oid, name string) error {
ret := C.git_packbuilder_insert(pb.ptr, id.toC(), cname)
if ret != 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -59,7 +59,7 @@ func (pb *Packbuilder) InsertCommit(id *Oid) error {
ret := C.git_packbuilder_insert_commit(pb.ptr, id.toC())
if ret != 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -70,7 +70,7 @@ func (pb *Packbuilder) InsertTree(id *Oid) error {
ret := C.git_packbuilder_insert_tree(pb.ptr, id.toC())
if ret != 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -88,7 +88,7 @@ func (pb *Packbuilder) WriteToFile(name string, mode os.FileMode) error {
ret := C.git_packbuilder_write(pb.ptr, cname, C.uint(mode.Perm()), nil, nil)
if ret != 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
diff --git a/reference.go b/reference.go
index 8e33354..45a3b22 100644
--- a/reference.go
+++ b/reference.go
@@ -11,6 +11,7 @@ import (
)
type ReferenceType int
+
const (
ReferenceSymbolic ReferenceType = C.GIT_REF_SYMBOLIC
ReferenceOid = C.GIT_REF_OID
@@ -27,31 +28,44 @@ func newReferenceFromC(ptr *C.git_reference) *Reference {
return ref
}
-func (v *Reference) SetSymbolicTarget(target string) (*Reference, error) {
+func (v *Reference) SetSymbolicTarget(target string, sig *Signature, msg string) (*Reference, error) {
var ptr *C.git_reference
+
ctarget := C.CString(target)
defer C.free(unsafe.Pointer(ctarget))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_reference_symbolic_set_target(&ptr, v.ptr, ctarget)
+ csig := sig.toC()
+ defer C.free(unsafe.Pointer(csig))
+
+ 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 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr), nil
}
-func (v *Reference) SetTarget(target *Oid) (*Reference, error) {
+func (v *Reference) SetTarget(target *Oid, sig *Signature, msg string) (*Reference, error) {
var ptr *C.git_reference
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_reference_set_target(&ptr, v.ptr, target.toC())
+ csig := sig.toC()
+ defer C.free(unsafe.Pointer(csig))
+
+ 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 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr), nil
@@ -65,24 +79,30 @@ func (v *Reference) Resolve() (*Reference, error) {
ret := C.git_reference_resolve(&ptr, v.ptr)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr), nil
}
-func (v *Reference) Rename(name string, force bool) (*Reference, error) {
+func (v *Reference) Rename(name string, force bool, sig *Signature, msg string) (*Reference, error) {
var ptr *C.git_reference
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
+ csig := sig.toC()
+ defer C.free(unsafe.Pointer(csig))
+
+ cmsg := C.CString(msg)
+ defer C.free(unsafe.Pointer(cmsg))
+
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_reference_rename(&ptr, v.ptr, cname, cbool(force))
+ ret := C.git_reference_rename(&ptr, v.ptr, cname, cbool(force), csig, cmsg)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr), nil
@@ -108,7 +128,7 @@ func (v *Reference) Delete() error {
ret := C.git_reference_delete(v.ptr)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
@@ -122,6 +142,18 @@ func (v *Reference) Type() ReferenceType {
return ReferenceType(C.git_reference_type(v.ptr))
}
+func (v *Reference) IsBranch() bool {
+ return C.git_reference_is_branch(v.ptr) == 1
+}
+
+func (v *Reference) IsRemote() bool {
+ return C.git_reference_is_remote(v.ptr) == 1
+}
+
+func (v *Reference) IsTag() bool {
+ return C.git_reference_is_tag(v.ptr) == 1
+}
+
func (v *Reference) Free() {
runtime.SetFinalizer(v, nil)
C.git_reference_free(v.ptr)
@@ -141,7 +173,7 @@ func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) {
ret := C.git_reference_iterator_new(&ptr, repo.ptr)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
iter := &ReferenceIterator{repo: repo, ptr: ptr}
@@ -162,7 +194,7 @@ func (repo *Repository) NewReferenceIteratorGlob(glob string) (*ReferenceIterato
ret := C.git_reference_iterator_glob_new(&ptr, repo.ptr, cstr)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
iter := &ReferenceIterator{repo: repo, ptr: ptr}
@@ -183,7 +215,7 @@ func (v *ReferenceIterator) NextName() (string, error) {
return "", ErrIterOver
}
if ret < 0 {
- return "", LastError()
+ return "", MakeGitError(ret)
}
return C.GoString(ptr), nil
@@ -215,7 +247,7 @@ func (v *ReferenceIterator) Next() (*Reference, error) {
return nil, ErrIterOver
}
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr), nil
diff --git a/reference_test.go b/reference_test.go
index f955a2c..156960a 100644
--- a/reference_test.go
+++ b/reference_test.go
@@ -14,7 +14,14 @@ func TestRefModification(t *testing.T) {
commitId, treeId := seedTestRepo(t, repo)
- _, err := repo.CreateReference("refs/tags/tree", treeId, true)
+ 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),
+ }
+ _, err = repo.CreateReference("refs/tags/tree", treeId, true, sig, "testTreeTag")
checkFatal(t, err)
tag, err := repo.LookupReference("refs/tags/tree")
@@ -45,7 +52,7 @@ func TestRefModification(t *testing.T) {
t.Fatalf("Wrong ref target")
}
- _, err = tag.Rename("refs/tags/renamed", false)
+ _, err = tag.Rename("refs/tags/renamed", false, nil, "")
checkFatal(t, err)
tag, err = repo.LookupReference("refs/tags/renamed")
checkFatal(t, err)
@@ -78,13 +85,13 @@ func TestIterator(t *testing.T) {
commitId, err := repo.CreateCommit("HEAD", sig, sig, message, tree)
checkFatal(t, err)
- _, err = repo.CreateReference("refs/heads/one", commitId, true)
+ _, err = repo.CreateReference("refs/heads/one", commitId, true, sig, "headOne")
checkFatal(t, err)
- _, err = repo.CreateReference("refs/heads/two", commitId, true)
+ _, err = repo.CreateReference("refs/heads/two", commitId, true, sig, "headTwo")
checkFatal(t, err)
- _, err = repo.CreateReference("refs/heads/three", commitId, true)
+ _, err = repo.CreateReference("refs/heads/three", commitId, true, sig, "headThree")
checkFatal(t, err)
iter, err := repo.NewReferenceIterator()
@@ -108,7 +115,6 @@ func TestIterator(t *testing.T) {
t.Fatal("Iteration not over")
}
-
sort.Strings(list)
compareStringList(t, expected, list)
@@ -129,7 +135,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()
diff --git a/remote.go b/remote.go
index 5300c42..38c1d47 100644
--- a/remote.go
+++ b/remote.go
@@ -19,10 +19,11 @@ type TransferProgress struct {
}
type RemoteCompletion uint
+
const (
RemoteCompletionDownload RemoteCompletion = C.GIT_REMOTE_COMPLETION_DOWNLOAD
- RemoteCompletionIndexing = C.GIT_REMOTE_COMPLETION_INDEXING
- RemoteCompletionError = C.GIT_REMOTE_COMPLETION_ERROR
+ RemoteCompletionIndexing = C.GIT_REMOTE_COMPLETION_INDEXING
+ RemoteCompletionError = C.GIT_REMOTE_COMPLETION_ERROR
)
type ProgressCallback func(str string) int
@@ -40,21 +41,21 @@ type RemoteCallbacks struct {
}
type Remote interface {
- Save() int
+ Save() error
Owner() Repository
Name() string
Url() string
PushUrl() string
-
- SetUrl(url string) int
- SetPushUrl(url string) int
- AddFetch(refspec string) int
- GetFetchRefspecs() (err int, refspecs []string)
- SetFetchRefspecs(refspecs []string) int
- AddPush(refspec string) int
- GetPushRefspecs() (err int, refspecs []string)
- SetPushRefspecs(refspecs []string) int
+ SetUrl(url string) error
+ SetPushUrl(url string) error
+
+ AddFetch(refspec string) error
+ GetFetchRefspecs() ([]string, error)
+ SetFetchRefspecs(refspecs []string) error
+ AddPush(refspec string) error
+ GetPushRefspecs() ([]string, error)
+ SetPushRefspecs(refspecs []string) error
ClearRefspecs()
RefspecCount() uint
}
@@ -164,20 +165,26 @@ func freeRemote(o *gitRemote) {
C.git_remote_free(o.ptr)
}
-func CreateRemote(repo *Repository, name string, url string) (int, Remote) {
+func CreateRemote(repo *Repository, name string, url string) (Remote, error) {
remote := &gitRemote{}
runtime.SetFinalizer(remote, freeRemote)
-
+
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
curl := C.CString(url)
defer C.free(unsafe.Pointer(curl))
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
ret := C.git_remote_create(&remote.ptr, repo.ptr, cname, curl)
- return int(ret), remote
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return remote, nil
}
-func CreateRemoteWithFetchspec(repo *Repository, name string, url string, fetch string) (int, Remote) {
+func CreateRemoteWithFetchspec(repo *Repository, name string, url string, fetch string) (Remote, error) {
remote := &gitRemote{}
runtime.SetFinalizer(remote, freeRemote)
@@ -188,11 +195,17 @@ func CreateRemoteWithFetchspec(repo *Repository, name string, url string, fetch
cfetch := C.CString(fetch)
defer C.free(unsafe.Pointer(cfetch))
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
ret := C.git_remote_create_with_fetchspec(&remote.ptr, repo.ptr, cname, curl, cfetch)
- return int(ret), remote
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return remote, nil
}
-func CreateRemoteInMemory(repo *Repository, fetch string, url string) (int, Remote) {
+func CreateRemoteInMemory(repo *Repository, fetch string, url string) (Remote, error) {
remote := &gitRemote{}
runtime.SetFinalizer(remote, freeRemote)
@@ -201,28 +214,48 @@ func CreateRemoteInMemory(repo *Repository, fetch string, url string) (int, Remo
cfetch := C.CString(fetch)
defer C.free(unsafe.Pointer(cfetch))
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
ret := C.git_remote_create_inmemory(&remote.ptr, repo.ptr, cfetch, curl)
- return int(ret), remote
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return remote, nil
}
-func LoadRemote(repo *Repository, name string) (int, Remote) {
+func LoadRemote(repo *Repository, name string) (Remote, error) {
remote := &gitRemote{}
runtime.SetFinalizer(remote, freeRemote)
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
ret := C.git_remote_load(&remote.ptr, repo.ptr, cname)
- return int(ret), remote
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return remote, nil
}
-func (o *gitRemote) Save() int {
- return int(C.git_remote_save(o.ptr))
+func (o *gitRemote) Save() error {
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_save(o.ptr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
}
func (o *gitRemote) Owner() Repository {
return Repository{C.git_remote_owner(o.ptr)}
-}
+}
func (o *gitRemote) Name() string {
return C.GoString(C.git_remote_name(o.ptr))
@@ -236,37 +269,68 @@ func (o *gitRemote) PushUrl() string {
return C.GoString(C.git_remote_pushurl(o.ptr))
}
-func (o *gitRemote) SetUrl(url string) int {
+func (o *gitRemote) SetUrl(url string) error {
curl := C.CString(url)
defer C.free(unsafe.Pointer(curl))
- return int(C.git_remote_set_url(o.ptr, curl))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_set_url(o.ptr, curl)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
}
-func (o *gitRemote) SetPushUrl(url string) int {
+func (o *gitRemote) SetPushUrl(url string) error {
curl := C.CString(url)
defer C.free(unsafe.Pointer(curl))
- return int(C.git_remote_set_pushurl(o.ptr, curl))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_set_pushurl(o.ptr, curl)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
}
-func (o *gitRemote) AddFetch(refspec string) int {
+func (o *gitRemote) AddFetch(refspec string) error {
crefspec := C.CString(refspec)
defer C.free(unsafe.Pointer(crefspec))
- return int(C.git_remote_add_fetch(o.ptr, crefspec))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_add_fetch(o.ptr, crefspec)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
}
-func (o *gitRemote) GetFetchRefspecs() (err int, refspecs []string) {
+func (o *gitRemote) GetFetchRefspecs() ([]string, error) {
crefspecs := C.git_strarray{}
- err = int(C.git_remote_get_fetch_refspecs(&crefspecs, o.ptr))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_get_fetch_refspecs(&crefspecs, o.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
defer C.git_strarray_free(&crefspecs)
- refspecs = make([]string, crefspecs.count)
+ refspecs := make([]string, crefspecs.count)
for i := 0; i < int(crefspecs.count); i++ {
refspecs[i] = C.GoString(C._go_git_get_strarray_n(&crefspecs, C.size_t(i)))
}
- return
+ return refspecs, nil
}
-func (o *gitRemote) SetFetchRefspecs(refspecs []string) int {
+func (o *gitRemote) SetFetchRefspecs(refspecs []string) error {
crefspecs := C.git_strarray{}
crefspecs.count = C.size_t(len(refspecs))
crefspecs.strings = (**C.char)(C.malloc(C.size_t(unsafe.Sizeof(unsafe.Pointer(nil)) * uintptr(crefspecs.count))))
@@ -275,28 +339,50 @@ func (o *gitRemote) SetFetchRefspecs(refspecs []string) int {
}
defer C.git_strarray_free(&crefspecs)
- return int(C.git_remote_set_fetch_refspecs(o.ptr, &crefspecs))
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_set_fetch_refspecs(o.ptr, &crefspecs)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
}
-func (o *gitRemote) AddPush(refspec string) int {
+func (o *gitRemote) AddPush(refspec string) error {
crefspec := C.CString(refspec)
defer C.free(unsafe.Pointer(crefspec))
- return int(C.git_remote_add_push(o.ptr, crefspec))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_add_push(o.ptr, crefspec)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
}
-func (o *gitRemote) GetPushRefspecs() (err int, refspecs []string) {
+func (o *gitRemote) GetPushRefspecs() ([]string, error) {
crefspecs := C.git_strarray{}
- err = int(C.git_remote_get_push_refspecs(&crefspecs, o.ptr))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_get_push_refspecs(&crefspecs, o.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
defer C.git_strarray_free(&crefspecs)
- refspecs = make([]string, crefspecs.count)
+ refspecs := make([]string, crefspecs.count)
for i := 0; i < int(crefspecs.count); i++ {
refspecs[i] = C.GoString(C._go_git_get_strarray_n(&crefspecs, C.size_t(i)))
}
- return
+ return refspecs, nil
}
-func (o *gitRemote) SetPushRefspecs(refspecs []string) int {
+func (o *gitRemote) SetPushRefspecs(refspecs []string) error {
crefspecs := C.git_strarray{}
crefspecs.count = C.size_t(len(refspecs))
crefspecs.strings = (**C.char)(C.malloc(C.size_t(unsafe.Sizeof(unsafe.Pointer(nil)) * uintptr(crefspecs.count))))
@@ -305,7 +391,14 @@ func (o *gitRemote) SetPushRefspecs(refspecs []string) int {
}
defer C.git_strarray_free(&crefspecs)
- return int(C.git_remote_set_push_refspecs(o.ptr, &crefspecs))
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_set_push_refspecs(o.ptr, &crefspecs)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
}
func (o *gitRemote) ClearRefspecs() {
@@ -315,4 +408,3 @@ func (o *gitRemote) ClearRefspecs() {
func (o *gitRemote) RefspecCount() uint {
return uint(C.git_remote_refspec_count(o.ptr))
}
-
diff --git a/repository.go b/repository.go
index 3a9068d..e78422e 100644
--- a/repository.go
+++ b/repository.go
@@ -26,7 +26,7 @@ func OpenRepository(path string) (*Repository, error) {
ret := C.git_repository_open(&repo.ptr, cpath)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
runtime.SetFinalizer(repo, (*Repository).Free)
@@ -44,7 +44,7 @@ func InitRepository(path string, isbare bool) (*Repository, error) {
ret := C.git_repository_init(&repo.ptr, cpath, ucbool(isbare))
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
runtime.SetFinalizer(repo, (*Repository).Free)
@@ -64,7 +64,7 @@ func (v *Repository) Config() (*Config, error) {
ret := C.git_repository_config(&config.ptr, v.ptr)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
runtime.SetFinalizer(config, (*Config).Free)
@@ -79,32 +79,32 @@ func (v *Repository) Index() (*Index, error) {
ret := C.git_repository_index(&ptr, v.ptr)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return newIndexFromC(ptr), nil
}
-func (v *Repository) lookupType(oid *Oid, t ObjectType) (Object, error) {
+func (v *Repository) lookupType(id *Oid, t ObjectType) (Object, error) {
var ptr *C.git_object
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_object_lookup(&ptr, v.ptr, oid.toC(), C.git_otype(t))
+ ret := C.git_object_lookup(&ptr, v.ptr, id.toC(), C.git_otype(t))
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return allocObject(ptr), nil
}
-func (v *Repository) Lookup(oid *Oid) (Object, error) {
- return v.lookupType(oid, ObjectAny)
+func (v *Repository) Lookup(id *Oid) (Object, error) {
+ return v.lookupType(id, ObjectAny)
}
-func (v *Repository) LookupTree(oid *Oid) (*Tree, error) {
- obj, err := v.lookupType(oid, ObjectTree)
+func (v *Repository) LookupTree(id *Oid) (*Tree, error) {
+ obj, err := v.lookupType(id, ObjectTree)
if err != nil {
return nil, err
}
@@ -112,8 +112,8 @@ func (v *Repository) LookupTree(oid *Oid) (*Tree, error) {
return obj.(*Tree), nil
}
-func (v *Repository) LookupCommit(oid *Oid) (*Commit, error) {
- obj, err := v.lookupType(oid, ObjectCommit)
+func (v *Repository) LookupCommit(id *Oid) (*Commit, error) {
+ obj, err := v.lookupType(id, ObjectCommit)
if err != nil {
return nil, err
}
@@ -121,8 +121,8 @@ func (v *Repository) LookupCommit(oid *Oid) (*Commit, error) {
return obj.(*Commit), nil
}
-func (v *Repository) LookupBlob(oid *Oid) (*Blob, error) {
- obj, err := v.lookupType(oid, ObjectBlob)
+func (v *Repository) LookupBlob(id *Oid) (*Blob, error) {
+ obj, err := v.lookupType(id, ObjectBlob)
if err != nil {
return nil, err
}
@@ -140,41 +140,56 @@ func (v *Repository) LookupReference(name string) (*Reference, error) {
ecode := C.git_reference_lookup(&ptr, v.ptr, cname)
if ecode < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ecode)
}
return newReferenceFromC(ptr), nil
}
-func (v *Repository) CreateReference(name string, oid *Oid, force bool) (*Reference, error) {
+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))
+
+ csig := sig.toC()
+ defer C.free(unsafe.Pointer(csig))
+
+ cmsg := C.CString(msg)
+ defer C.free(unsafe.Pointer(cmsg))
+
var ptr *C.git_reference
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ecode := C.git_reference_create(&ptr, v.ptr, cname, oid.toC(), cbool(force))
+ ecode := C.git_reference_create(&ptr, v.ptr, cname, id.toC(), cbool(force), csig, cmsg)
if ecode < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ecode)
}
return newReferenceFromC(ptr), nil
}
-func (v *Repository) CreateSymbolicReference(name, target string, force bool) (*Reference, error) {
+func (v *Repository) CreateSymbolicReference(name, target string, force bool, sig *Signature, msg string) (*Reference, error) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
+
ctarget := C.CString(target)
defer C.free(unsafe.Pointer(ctarget))
+
+ csig := sig.toC()
+ defer C.free(unsafe.Pointer(csig))
+
+ cmsg := C.CString(msg)
+ defer C.free(unsafe.Pointer(cmsg))
+
var ptr *C.git_reference
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ecode := C.git_reference_symbolic_create(&ptr, v.ptr, cname, ctarget, cbool(force))
+ ecode := C.git_reference_symbolic_create(&ptr, v.ptr, cname, ctarget, cbool(force), csig, cmsg)
if ecode < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ecode)
}
return newReferenceFromC(ptr), nil
@@ -188,7 +203,7 @@ func (v *Repository) Walk() (*RevWalk, error) {
ecode := C.git_revwalk_new(&walk.ptr, v.ptr)
if ecode < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ecode)
}
walk.repo = v
@@ -232,10 +247,10 @@ func (v *Repository) CreateCommit(
ret := C.git_commit_create(
oid.toC(), v.ptr, cref,
authorSig, committerSig,
- nil, cmsg, tree.ptr, C.int(nparents), parentsarg)
+ nil, cmsg, tree.ptr, C.size_t(nparents), parentsarg)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return oid, nil
@@ -253,7 +268,7 @@ func (v *Repository) Odb() (odb *Odb, err error) {
defer runtime.UnlockOSThread()
if ret := C.git_repository_odb(&odb.ptr, v.ptr); ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
runtime.SetFinalizer(odb, (*Odb).Free)
@@ -279,9 +294,10 @@ func (repo *Repository) SetWorkdir(workdir string, updateGitlink bool) error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- if C.git_repository_set_workdir(repo.ptr, cstr, cbool(updateGitlink)) < 0 {
- return LastError()
+ if ret := C.git_repository_set_workdir(repo.ptr, cstr, cbool(updateGitlink)); ret < 0 {
+ return MakeGitError(ret)
}
+
return nil
}
@@ -292,7 +308,7 @@ func (v *Repository) TreeBuilder() (*TreeBuilder, error) {
defer runtime.UnlockOSThread()
if ret := C.git_treebuilder_create(&bld.ptr, nil); ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
runtime.SetFinalizer(bld, (*TreeBuilder).Free)
@@ -311,7 +327,7 @@ func (v *Repository) RevparseSingle(spec string) (Object, error) {
ecode := C.git_revparse_single(&ptr, v.ptr, cspec)
if ecode < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ecode)
}
return allocObject(ptr), nil
diff --git a/submodule.go b/submodule.go
index dadc785..a94afd4 100644
--- a/submodule.go
+++ b/submodule.go
@@ -57,10 +57,11 @@ const (
)
type SubmoduleRecurse int
+
const (
- SubmoduleRecurseNo SubmoduleRecurse = C.GIT_SUBMODULE_RECURSE_NO
- SubmoduleRecurseYes = C.GIT_SUBMODULE_RECURSE_YES
- SubmoduleRecurseOnDemand = C.GIT_SUBMODULE_RECURSE_ONDEMAND
+ SubmoduleRecurseNo SubmoduleRecurse = C.GIT_SUBMODULE_RECURSE_NO
+ SubmoduleRecurseYes = C.GIT_SUBMODULE_RECURSE_YES
+ SubmoduleRecurseOndemand = C.GIT_SUBMODULE_RECURSE_ONDEMAND
)
func SubmoduleStatusIsUnmodified(status int) bool {
@@ -80,7 +81,7 @@ func (repo *Repository) LookupSubmodule(name string) (*Submodule, error) {
ret := C.git_submodule_lookup(&sub.ptr, repo.ptr, cname)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return sub, nil
@@ -101,7 +102,7 @@ func (repo *Repository) ForeachSubmodule(cbk SubmoduleCbk) error {
ret := C._go_git_visit_submodule(repo.ptr, unsafe.Pointer(&cbk))
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -119,7 +120,7 @@ func (repo *Repository) AddSubmodule(url, path string, use_git_link bool) (*Subm
ret := C.git_submodule_add_setup(&sub.ptr, repo.ptr, curl, cpath, cbool(use_git_link))
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return sub, nil
}
@@ -130,7 +131,7 @@ func (sub *Submodule) FinalizeAdd() error {
ret := C.git_submodule_add_finalize(sub.ptr)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -141,7 +142,7 @@ func (sub *Submodule) AddToIndex(write_index bool) error {
ret := C.git_submodule_add_to_index(sub.ptr, cbool(write_index))
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -152,7 +153,7 @@ func (sub *Submodule) Save() error {
ret := C.git_submodule_save(sub.ptr)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -187,7 +188,7 @@ func (sub *Submodule) SetUrl(url string) error {
ret := C.git_submodule_set_url(sub.ptr, curl)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -236,20 +237,17 @@ func (sub *Submodule) SetUpdate(update SubmoduleUpdate) SubmoduleUpdate {
return SubmoduleUpdate(o)
}
-func (sub *Submodule) FetchRecurseSubmodules() bool {
- if 0 == C.git_submodule_fetch_recurse_submodules(sub.ptr) {
- return false
- }
- return true
+func (sub *Submodule) FetchRecurseSubmodules() SubmoduleRecurse {
+ return SubmoduleRecurse(C.git_submodule_fetch_recurse_submodules(sub.ptr))
}
-func (sub *Submodule) SetFetchRecurseSubmodules(v SubmoduleRecurse) error {
+func (sub *Submodule) SetFetchRecurseSubmodules(recurse SubmoduleRecurse) error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_submodule_set_fetch_recurse_submodules(sub.ptr, C.git_submodule_recurse_t(v))
+ ret := C.git_submodule_set_fetch_recurse_submodules(sub.ptr, C.git_submodule_recurse_t(recurse))
if ret < 0 {
- return LastError()
+ return MakeGitError(C.int(ret))
}
return nil
}
@@ -260,7 +258,7 @@ func (sub *Submodule) Init(overwrite bool) error {
ret := C.git_submodule_init(sub.ptr, cbool(overwrite))
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -271,7 +269,7 @@ func (sub *Submodule) Sync() error {
ret := C.git_submodule_sync(sub.ptr)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -284,7 +282,7 @@ func (sub *Submodule) Open() (*Repository, error) {
ret := C.git_submodule_open(&repo.ptr, sub.ptr)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return repo, nil
}
@@ -295,7 +293,7 @@ func (sub *Submodule) Reload() error {
ret := C.git_submodule_reload(sub.ptr)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
@@ -306,7 +304,7 @@ func (repo *Repository) ReloadAllSubmodules() error {
ret := C.git_submodule_reload_all(repo.ptr)
if ret < 0 {
- return LastError()
+ return MakeGitError(ret)
}
return nil
}
diff --git a/tree.go b/tree.go
index 8c74e5d..b3340d6 100644
--- a/tree.go
+++ b/tree.go
@@ -67,7 +67,7 @@ func (t Tree) EntryByPath(path string) (*TreeEntry, error) {
ret := C.git_tree_entry_bypath(&entry, t.ptr, cpath)
if ret < 0 {
- return nil, LastError()
+ return nil, MakeGitError(ret)
}
return newTreeEntry(entry), nil
@@ -109,7 +109,7 @@ func (t Tree) Walk(callback TreeWalkCallback) error {
)
if err < 0 {
- return LastError()
+ return MakeGitError(err)
}
return nil
@@ -134,7 +134,7 @@ func (v *TreeBuilder) Insert(filename string, id *Oid, filemode int) (error) {
err := C.git_treebuilder_insert(nil, v.ptr, cfilename, id.toC(), C.git_filemode_t(filemode))
if err < 0 {
- return LastError()
+ return MakeGitError(err)
}
return nil
@@ -149,7 +149,7 @@ func (v *TreeBuilder) Write() (*Oid, error) {
err := C.git_treebuilder_write(oid.toC(), v.repo.ptr, v.ptr)
if err < 0 {
- return nil, LastError()
+ return nil, MakeGitError(err)
}
return oid, nil
diff --git a/walk.go b/walk.go
index 6979b6b..cdc1a20 100644
--- a/walk.go
+++ b/walk.go
@@ -40,22 +40,22 @@ func (v *RevWalk) PushHead() (err error) {
ecode := C.git_revwalk_push_head(v.ptr)
if ecode < 0 {
- err = LastError()
+ err = MakeGitError(ecode)
}
return
}
-func (v *RevWalk) Next(oid *Oid) (err error) {
+func (v *RevWalk) Next(id *Oid) (err error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
- ret := C.git_revwalk_next(oid.toC(), v.ptr)
+ ret := C.git_revwalk_next(id.toC(), v.ptr)
switch {
case ret == ITEROVER:
err = io.EOF
case ret < 0:
- err = LastError()
+ err = MakeGitError(ret)
}
return
generated by cgit v1.2.3 (git 2.51.0) at 2025-11-07 07:18:08 +0000