git

package module
v30.7.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 27, 2022 License: MIT Imports: 24 Imported by: 0

README

git2go

GoDoc Build Status

Go bindings for libgit2.

Which Go version to use

Due to the fact that Go 1.11 module versions have semantic meaning and don't necessarily align with libgit2's release schedule, please consult the following table for a mapping between libgit2 and git2go module versions:

libgit2 git2go
main (will be v31)
1.0 v30
0.99 v29
0.28 v28
0.27 v27

You can import them in your project with the version's major number as a suffix. For example, if you have libgit2 v1.0 installed, you'd import git2go v30 with

go get github.com/libgit2/git2go/v30

import "github.com/libgit2/git2go/v30"

which will ensure there are no sudden changes to the API.

The main branch follows the tip of libgit2 itself (with some lag) and as such has no guarantees on the stability of libgit2's API. Thus this only supports statically linking against libgit2.

Which branch to send Pull requests to

If there's something version-specific that you'd want to contribute to, you can send them to the release-${MAJOR}.${MINOR} branches, which follow libgit2's releases.

Installing

This project wraps the functionality provided by libgit2. It thus needs it in order to perform the work.

This project wraps the functionality provided by libgit2. If you're using a versioned branch, install it to your system via your system's package manager and then install git2go.

Versioned branch, dynamic linking

When linking dynamically against a released version of libgit2, install it via your system's package manager. CGo will take care of finding its pkg-config file and set up the linking. Import via Go modules, e.g. to work against libgit2 v1.0

import "github.com/libgit2/git2go/v30"
Versioned branch, static linking

Follow the instructions for Versioned branch, dynamic linking, but pass the -tags static,system_libgit2 flag to all go commands that build any binaries. For instance:

go build -tags static,system_libgit2 github.com/my/project/...
go test -tags static,system_libgit2 github.com/my/project/...
go install -tags static,system_libgit2 github.com/my/project/...
main branch, or vendored static linking

If using main or building a branch with the vendored libgit2 statically, we need to build libgit2 first. In order to build it, you need cmake, pkg-config and a C compiler. You will also need the development packages for OpenSSL (outside of Windows or macOS) and LibSSH2 installed if you want libgit2 to support HTTPS and SSH respectively. Note that even if libgit2 is included in the resulting binary, its dependencies will not be.

Run go get -d github.com/libgit2/git2go to download the code and go to your $GOPATH/src/github.com/libgit2/git2go directory. From there, we need to build the C code and put it into the resulting go binary.

git submodule update --init # get libgit2
make install-static

will compile libgit2, link it into git2go and install it. The main branch is set up to follow the specific libgit2 version that is vendored, so trying dynamic linking may or may not work depending on the exact versions involved.

In order to let Go pass the correct flags to pkg-config, -tags static needs to be passed to all go commands that build any binaries. For instance:

go build -tags static github.com/my/project/...
go test -tags static github.com/my/project/...
go install -tags static github.com/my/project/...

One thing to take into account is that since Go expects the pkg-config file to be within the same directory where make install-static was called, so the go.mod file may need to have a replace directive so that the correct setup is achieved. So if git2go is checked out at $GOPATH/src/github.com/libgit2/git2go and your project at $GOPATH/src/github.com/my/project, the go.mod file of github.com/my/project might need to have a line like

replace github.com/libgit2/git2go/v30 => ../../libgit2/git2go

Parallelism and network operations

libgit2 may use OpenSSL and LibSSH2 for performing encrypted network connections. For now, git2go asks libgit2 to set locking for OpenSSL. This makes HTTPS connections thread-safe, but it is fragile and will likely stop doing it soon. This may also make SSH connections thread-safe if your copy of libssh2 is linked against OpenSSL. Check libgit2's THREADSAFE.md for more information.

Running the tests

For the stable version, go test will work as usual. For the main branch, similarly to installing, running the tests requires building a local libgit2 library, so the Makefile provides a wrapper that makes sure it's built

make test-static

Alternatively, you can build the library manually first and then run the tests

make install-static
go test -v -tags static ./...

License

M to the I to the T. See the LICENSE file if you've never seen an MIT license before.

Authors

  • Carlos Martín (@carlosmn)
  • Vicent Martí (@vmg)

Documentation

Index

Constants

View Source 
const (
	CheckoutNotifyNone      CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_NONE
	CheckoutNotifyConflict  CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_CONFLICT
	CheckoutNotifyDirty     CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_DIRTY
	CheckoutNotifyUpdated   CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_UPDATED
	CheckoutNotifyUntracked CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_UNTRACKED
	CheckoutNotifyIgnored   CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_IGNORED
	CheckoutNotifyAll       CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_ALL

	CheckoutNone                      CheckoutStrategy = C.GIT_CHECKOUT_NONE                         // Dry run, no actual updates
	CheckoutSafe                      CheckoutStrategy = C.GIT_CHECKOUT_SAFE                         // Allow safe updates that cannot overwrite uncommitted data
	CheckoutForce                     CheckoutStrategy = C.GIT_CHECKOUT_FORCE                        // Allow all updates to force working directory to look like index
	CheckoutRecreateMissing           CheckoutStrategy = C.GIT_CHECKOUT_RECREATE_MISSING             // Allow checkout to recreate missing files
	CheckoutAllowConflicts            CheckoutStrategy = C.GIT_CHECKOUT_ALLOW_CONFLICTS              // Allow checkout to make safe updates even if conflicts are found
	CheckoutRemoveUntracked           CheckoutStrategy = C.GIT_CHECKOUT_REMOVE_UNTRACKED             // Remove untracked files not in index (that are not ignored)
	CheckoutRemoveIgnored             CheckoutStrategy = C.GIT_CHECKOUT_REMOVE_IGNORED               // Remove ignored files not in index
	CheckoutUpdateOnly                CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_ONLY                  // Only update existing files, don't create new ones
	CheckoutDontUpdateIndex           CheckoutStrategy = C.GIT_CHECKOUT_DONT_UPDATE_INDEX            // Normally checkout updates index entries as it goes; this stops that
	CheckoutNoRefresh                 CheckoutStrategy = C.GIT_CHECKOUT_NO_REFRESH                   // Don't refresh index/config/etc before doing checkout
	CheckoutSkipUnmerged              CheckoutStrategy = C.GIT_CHECKOUT_SKIP_UNMERGED                // Allow checkout to skip unmerged files
	CheckoutUseOurs                   CheckoutStrategy = C.GIT_CHECKOUT_USE_OURS                     // For unmerged files, checkout stage 2 from index
	CheckoutUseTheirs                 CheckoutStrategy = C.GIT_CHECKOUT_USE_THEIRS                   // For unmerged files, checkout stage 3 from index
	CheckoutDisablePathspecMatch      CheckoutStrategy = C.GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH       // Treat pathspec as simple list of exact match file paths
	CheckoutSkipLockedDirectories     CheckoutStrategy = C.GIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES      // Ignore directories in use, they will be left empty
	CheckoutDontOverwriteIgnored      CheckoutStrategy = C.GIT_CHECKOUT_DONT_OVERWRITE_IGNORED       // Don't overwrite ignored files that exist in the checkout target
	CheckoutConflictStyleMerge        CheckoutStrategy = C.GIT_CHECKOUT_CONFLICT_STYLE_MERGE         // Write normal merge files for conflicts
	CheckoutConflictStyleDiff3        CheckoutStrategy = C.GIT_CHECKOUT_CONFLICT_STYLE_DIFF3         // Include common ancestor data in diff3 format files for conflicts
	CheckoutDontRemoveExisting        CheckoutStrategy = C.GIT_CHECKOUT_DONT_REMOVE_EXISTING         // Don't overwrite existing files or folders
	CheckoutDontWriteIndex            CheckoutStrategy = C.GIT_CHECKOUT_DONT_WRITE_INDEX             // Normally checkout writes the index upon completion; this prevents that
	CheckoutUpdateSubmodules          CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_SUBMODULES            // Recursively checkout submodules with same options (NOT IMPLEMENTED)
	CheckoutUpdateSubmodulesIfChanged CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_SUBMODULES_IF_CHANGED // Recursively checkout submodules if HEAD moved in super repo (NOT IMPLEMENTED)
)
View Source 
const (
	CredTypeUserpassPlaintext = CredentialTypeUserpassPlaintext
	CredTypeSshKey            = CredentialTypeSSHKey
	CredTypeSshCustom         = CredentialTypeSSHCustom
	CredTypeDefault           = CredentialTypeDefault
)
View Source 
const (
	// Deprecated: FeatureHttps is a deprecated alias of FeatureHTTPS.
	FeatureHttps = FeatureHTTPS

	// Deprecated: FeatureSsh is a deprecated alias of FeatureSSH.
	FeatureSsh = FeatureSSH
)
View Source 
const (
	// Deprecated: ErrClassNone is a deprecated alias of ErrorClassNone.
	ErrClassNone = ErrorClassNone
	// Deprecated: ErrClassNoMemory is a deprecated alias of ErrorClassNoMemory.
	ErrClassNoMemory = ErrorClassNoMemory
	// Deprecated: ErrClassOs is a deprecated alias of ErrorClassOS.
	ErrClassOs = ErrorClassOS
	// Deprecated: ErrClassInvalid is a deprecated alias of ErrorClassInvalid.
	ErrClassInvalid = ErrorClassInvalid
	// Deprecated: ErrClassReference is a deprecated alias of ErrorClassReference.
	ErrClassReference = ErrorClassReference
	// Deprecated: ErrClassZlib is a deprecated alias of ErrorClassZlib.
	ErrClassZlib = ErrorClassZlib
	// Deprecated: ErrClassRepository is a deprecated alias of ErrorClassRepository.
	ErrClassRepository = ErrorClassRepository
	// Deprecated: ErrClassConfig is a deprecated alias of ErrorClassConfig.
	ErrClassConfig = ErrorClassConfig
	// Deprecated: ErrClassRegex is a deprecated alias of ErrorClassRegex.
	ErrClassRegex = ErrorClassRegex
	// Deprecated: ErrClassOdb is a deprecated alias of ErrorClassOdb.
	ErrClassOdb = ErrorClassOdb
	// Deprecated: ErrClassIndex is a deprecated alias of ErrorClassIndex.
	ErrClassIndex = ErrorClassIndex
	// Deprecated: ErrClassObject is a deprecated alias of ErrorClassObject.
	ErrClassObject = ErrorClassObject
	// Deprecated: ErrClassNet is a deprecated alias of ErrorClassNet.
	ErrClassNet = ErrorClassNet
	// Deprecated: ErrClassTag is a deprecated alias of ErrorClassTag.
	ErrClassTag = ErrorClassTag
	// Deprecated: ErrClassTree is a deprecated alias of ErrorClassTree.
	ErrClassTree = ErrorClassTree
	// Deprecated: ErrClassIndexer is a deprecated alias of ErrorClassIndexer.
	ErrClassIndexer = ErrorClassIndexer
	// Deprecated: ErrClassSSL is a deprecated alias of ErrorClassSSL.
	ErrClassSSL = ErrorClassSSL
	// Deprecated: ErrClassSubmodule is a deprecated alias of ErrorClassSubmodule.
	ErrClassSubmodule = ErrorClassSubmodule
	// Deprecated: ErrClassThread is a deprecated alias of ErrorClassThread.
	ErrClassThread = ErrorClassThread
	// Deprecated: ErrClassStash is a deprecated alias of ErrorClassStash.
	ErrClassStash = ErrorClassStash
	// Deprecated: ErrClassCheckout is a deprecated alias of ErrorClassCheckout.
	ErrClassCheckout = ErrorClassCheckout
	// Deprecated: ErrClassFetchHead is a deprecated alias of ErrorClassFetchHead.
	ErrClassFetchHead = ErrorClassFetchHead
	// Deprecated: ErrClassMerge is a deprecated alias of ErrorClassMerge.
	ErrClassMerge = ErrorClassMerge
	// Deprecated: ErrClassSsh is a deprecated alias of ErrorClassSSH.
	ErrClassSsh = ErrorClassSSH
	// Deprecated: ErrClassFilter is a deprecated alias of ErrorClassFilter.
	ErrClassFilter = ErrorClassFilter
	// Deprecated: ErrClassRevert is a deprecated alias of ErrorClassRevert.
	ErrClassRevert = ErrorClassRevert
	// Deprecated: ErrClassCallback is a deprecated alias of ErrorClassCallback.
	ErrClassCallback = ErrorClassCallback
	// Deprecated: ErrClassRebase is a deprecated alias of ErrorClassRebase.
	ErrClassRebase = ErrorClassRebase
	// Deprecated: ErrClassPatch is a deprecated alias of ErrorClassPatch.
	ErrClassPatch = ErrorClassPatch
)
View Source 
const (
	// Deprecated: ErrOk is a deprecated alias of ErrorCodeOK.
	ErrOk = ErrorCodeOK
	// Deprecated: ErrGeneric is a deprecated alias of ErrorCodeGeneric.
	ErrGeneric = ErrorCodeGeneric
	// Deprecated: ErrNotFound is a deprecated alias of ErrorCodeNotFound.
	ErrNotFound = ErrorCodeNotFound
	// Deprecated: ErrExists is a deprecated alias of ErrorCodeExists.
	ErrExists = ErrorCodeExists
	// Deprecated: ErrAmbiguous is a deprecated alias of ErrorCodeAmbiguous.
	ErrAmbiguous = ErrorCodeAmbiguous
	// Deprecated: ErrAmbigious is a deprecated alias of ErrorCodeAmbiguous.
	ErrAmbigious = ErrorCodeAmbiguous
	// Deprecated: ErrBuffs is a deprecated alias of ErrorCodeBuffs.
	ErrBuffs = ErrorCodeBuffs
	// Deprecated: ErrUser is a deprecated alias of ErrorCodeUser.
	ErrUser = ErrorCodeUser
	// Deprecated: ErrBareRepo is a deprecated alias of ErrorCodeBareRepo.
	ErrBareRepo = ErrorCodeBareRepo
	// Deprecated: ErrUnbornBranch is a deprecated alias of ErrorCodeUnbornBranch.
	ErrUnbornBranch = ErrorCodeUnbornBranch
	// Deprecated: ErrUnmerged is a deprecated alias of ErrorCodeUnmerged.
	ErrUnmerged = ErrorCodeUnmerged
	// Deprecated: ErrNonFastForward is a deprecated alias of ErrorCodeNonFastForward.
	ErrNonFastForward = ErrorCodeNonFastForward
	// Deprecated: ErrInvalidSpec is a deprecated alias of ErrorCodeInvalidSpec.
	ErrInvalidSpec = ErrorCodeInvalidSpec
	// Deprecated: ErrConflict is a deprecated alias of ErrorCodeConflict.
	ErrConflict = ErrorCodeConflict
	// Deprecated: ErrLocked is a deprecated alias of ErrorCodeLocked.
	ErrLocked = ErrorCodeLocked
	// Deprecated: ErrModified is a deprecated alias of ErrorCodeModified.
	ErrModified = ErrorCodeModified
	// Deprecated: ErrAuth is a deprecated alias of ErrorCodeAuth.
	ErrAuth = ErrorCodeAuth
	// Deprecated: ErrCertificate is a deprecated alias of ErrorCodeCertificate.
	ErrCertificate = ErrorCodeCertificate
	// Deprecated: ErrApplied is a deprecated alias of ErrorCodeApplied.
	ErrApplied = ErrorCodeApplied
	// Deprecated: ErrPeel is a deprecated alias of ErrorCodePeel.
	ErrPeel = ErrorCodePeel
	// Deprecated: ErrEOF is a deprecated alias of ErrorCodeEOF.
	ErrEOF = ErrorCodeEOF
	// Deprecated: ErrUncommitted is a deprecated alias of ErrorCodeUncommitted.
	ErrUncommitted = ErrorCodeUncommitted
	// Deprecated: ErrDirectory is a deprecated alias of ErrorCodeDirectory.
	ErrDirectory = ErrorCodeDirectory
	// Deprecated: ErrMergeConflict is a deprecated alias of ErrorCodeMergeConflict.
	ErrMergeConflict = ErrorCodeMergeConflict
	// Deprecated: ErrPassthrough is a deprecated alias of ErrorCodePassthrough.
	ErrPassthrough = ErrorCodePassthrough
	// Deprecated: ErrIterOver is a deprecated alias of ErrorCodeIterOver.
	ErrIterOver = ErrorCodeIterOver
	// Deprecated: ErrApplyFail is a deprecated alias of ErrorCodeApplyFail.
	ErrApplyFail = ErrorCodeApplyFail
)
View Source 
const (
	RemoteCompletionDownload RemoteCompletion = C.GIT_REMOTE_COMPLETION_DOWNLOAD
	RemoteCompletionIndexing RemoteCompletion = C.GIT_REMOTE_COMPLETION_INDEXING
	RemoteCompletionError    RemoteCompletion = C.GIT_REMOTE_COMPLETION_ERROR

	ConnectDirectionFetch ConnectDirection = C.GIT_DIRECTION_FETCH
	ConnectDirectionPush  ConnectDirection = C.GIT_DIRECTION_PUSH
)
View Source 
const (
	// Deprecated: DiffIgnoreWhitespaceEol is a deprecated alias of DiffIgnoreWhitespaceEOL.
	DiffIgnoreWitespaceEol = DiffIgnoreWhitespaceEOL
)

Variables

View Source 
var (
	ErrDeltaSkip = errors.New("Skip delta")
)
View Source 
var (
	ErrInvalid = errors.New("Invalid state for operation")
)
View Source 
var ErrRebaseNoOperation = errors.New("no current rebase operation")

Error returned if there is no current rebase operation

View Source 
var RebaseNoOperation uint = ^uint(0)

Special value indicating that there is no currently active operation

Functions

func CachedMemory 

func CachedMemory() (current int, allowed int, err error)

func CallbackGitTreeWalk deprecated 

func CallbackGitTreeWalk(_root *C.char, entry *C.git_tree_entry, ptr unsafe.Pointer) C.int

Deprecated: CallbackGitTreeWalk is not used.

func ConfigFindGlobal 

func ConfigFindGlobal() (string, error)

func ConfigFindProgramdata 

func ConfigFindProgramdata() (string, error)

ConfigFindProgramdata locate the path to the configuration file in ProgramData.

Look for the file in %PROGRAMDATA%\Git\config used by portable git.

func ConfigFindSystem 

func ConfigFindSystem() (string, error)

func ConfigFindXDG 

func ConfigFindXDG() (string, error)

func DiffBlobs 

func DiffBlobs(oldBlob *Blob, oldAsPath string, newBlob *Blob, newAsPath string, opts *DiffOptions, fileCallback DiffForEachFileCallback, detail DiffDetail) error

DiffBlobs performs a diff between two arbitrary blobs. You can pass whatever file names you'd like for them to appear as in the diff.

func Discover 

func Discover(start string, across_fs bool, ceiling_dirs []string) (string, error)

func EnableCaching 

func EnableCaching(enabled bool) error

func EnableFsyncGitDir 

func EnableFsyncGitDir(enabled bool) error

func EnableStrictHashVerification 

func EnableStrictHashVerification(enabled bool) error

func GetCachedMemory 

func GetCachedMemory() (current int, allowed int, err error)

deprecated: You should use `CachedMemory()` instead.

func IsErrorClass 

func IsErrorClass(err error, c ErrorClass) bool

func IsErrorCode 

func IsErrorCode(err error, c ErrorCode) bool

func MakeGitError 

func MakeGitError(c C.int) error

func MakeGitError2 

func MakeGitError2(err int) error

func MwindowMappedLimit 

func MwindowMappedLimit() (int, error)

func MwindowSize 

func MwindowSize() (int, error)

func ReInit 

func ReInit()

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.

func ReferenceIsValidName 

func ReferenceIsValidName(name string) bool

ReferenceIsValidName returns whether the reference name is well-formed.

Valid reference names must follow one of two patterns:

1. Top-level names must contain only capital letters and underscores, and must begin and end with a letter. (e.g. "HEAD", "ORIG_HEAD").

2. Names prefixed with "refs/" can be almost anything. You must avoid the characters '~', '^', ':', ' \ ', '?', '[', and '*', and the sequences ".." and " @ {" which have special meaning to revparse.

func ReferenceNormalizeName 

func ReferenceNormalizeName(name string, flags ReferenceFormat) (string, error)

ReferenceNormalizeName normalizes the reference name and checks validity.

This will normalize the reference name by removing any leading slash '/' characters and collapsing runs of adjacent slashes between name components into a single slash.

See git_reference_symbolic_create() for rules about valid names.

func RemoteIsValidName 

func RemoteIsValidName(name string) bool

RemoteIsValidName returns whether the remote name is well-formed.

func SearchPath 

func SearchPath(level ConfigLevel) (string, error)

func SetCacheMaxSize 

func SetCacheMaxSize(maxSize int) error

func SetCacheObjectLimit 

func SetCacheObjectLimit(objectType ObjectType, size int) error

func SetMwindowMappedLimit 

func SetMwindowMappedLimit(size int) error

func SetMwindowSize 

func SetMwindowSize(size int) error

func SetSearchPath 

func SetSearchPath(level ConfigLevel, path string) error

func ShortenOids 

func ShortenOids(ids []*Oid, minlen int) (int, error)

func Shutdown 

func Shutdown()

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.

func SubmoduleStatusIsUnmodified 

func SubmoduleStatusIsUnmodified(status int) bool

func SubmoduleVisitor deprecated 

func SubmoduleVisitor(csub unsafe.Pointer, name *C.char, handle unsafe.Pointer) C.int

Deprecated: SubmoduleVisitor is not used.

Types

type AnnotatedCommit 

type AnnotatedCommit struct {
	// contains filtered or unexported fields
}

func (*AnnotatedCommit) Free 

func (mh *AnnotatedCommit) Free()

func (*AnnotatedCommit) Id 

func (mh *AnnotatedCommit) Id() *Oid

type ApplyDeltaCallback 

type ApplyDeltaCallback func(*DiffDelta) (apply bool, err error)

ApplyDeltaCallback is a callback that will be made per hunk when applying a patch.

type ApplyHunkCallback 

type ApplyHunkCallback func(*DiffHunk) (apply bool, err error)

ApplyHunkCallback is a callback that will be made per delta (file) when applying a patch.

type ApplyLocation 

type ApplyLocation int

ApplyLocation represents the possible application locations for applying diffs. 

const (
	// ApplyLocationWorkdir applies the patch to the workdir, leaving the
	// index untouched. This is the equivalent of `git apply` with no location
	// argument.
	ApplyLocationWorkdir ApplyLocation = C.GIT_APPLY_LOCATION_WORKDIR
	// ApplyLocationIndex applies the patch to the index, leaving the working
	// directory untouched. This is the equivalent of `git apply --cached`.
	ApplyLocationIndex ApplyLocation = C.GIT_APPLY_LOCATION_INDEX
	// ApplyLocationBoth applies the patch to both the working directory and
	// the index. This is the equivalent of `git apply --index`.
	ApplyLocationBoth ApplyLocation = C.GIT_APPLY_LOCATION_BOTH
)

type ApplyOptions 

type ApplyOptions struct {
	ApplyHunkCallback  ApplyHunkCallback
	ApplyDeltaCallback ApplyDeltaCallback
	Flags              uint
}

ApplyOptions has 2 callbacks that are called for hunks or deltas If these functions return an error, abort the apply process immediately. If the first return value is true, the delta/hunk will be applied. If it is false, the delta/hunk will not be applied. In either case, the rest of the apply process will continue.

func DefaultApplyOptions 

func DefaultApplyOptions() (*ApplyOptions, error)

DefaultApplyOptions returns default options for applying diffs or patches.

type Blame 

type Blame struct {
	// contains filtered or unexported fields
}

func (*Blame) Free 

func (blame *Blame) Free() error

func (*Blame) HunkByIndex 

func (blame *Blame) HunkByIndex(index int) (BlameHunk, error)

func (*Blame) HunkByLine 

func (blame *Blame) HunkByLine(lineno int) (BlameHunk, error)

func (*Blame) HunkCount 

func (blame *Blame) HunkCount() int

type BlameHunk 

type BlameHunk struct {
	LinesInHunk          uint16
	FinalCommitId        *Oid
	FinalStartLineNumber uint16
	FinalSignature       *Signature
	OrigCommitId         *Oid
	OrigPath             string
	OrigStartLineNumber  uint16
	OrigSignature        *Signature
	Boundary             bool
}

type BlameOptions 

type BlameOptions struct {
	Flags              BlameOptionsFlag
	MinMatchCharacters uint16
	NewestCommit       *Oid
	OldestCommit       *Oid
	MinLine            uint32
	MaxLine            uint32
}

func DefaultBlameOptions 

func DefaultBlameOptions() (BlameOptions, error)

type BlameOptionsFlag 

type BlameOptionsFlag uint32
const (
	BlameNormal                      BlameOptionsFlag = C.GIT_BLAME_NORMAL
	BlameTrackCopiesSameFile         BlameOptionsFlag = C.GIT_BLAME_TRACK_COPIES_SAME_FILE
	BlameTrackCopiesSameCommitMoves  BlameOptionsFlag = C.GIT_BLAME_TRACK_COPIES_SAME_COMMIT_MOVES
	BlameTrackCopiesSameCommitCopies BlameOptionsFlag = C.GIT_BLAME_TRACK_COPIES_SAME_COMMIT_COPIES
	BlameTrackCopiesAnyCommitCopies  BlameOptionsFlag = C.GIT_BLAME_TRACK_COPIES_ANY_COMMIT_COPIES
	BlameFirstParent                 BlameOptionsFlag = C.GIT_BLAME_FIRST_PARENT
	BlameUseMailmap                  BlameOptionsFlag = C.GIT_BLAME_USE_MAILMAP
)

type Blob 

type Blob struct {
	Object
	// contains filtered or unexported fields
}

func (*Blob) AsObject 

func (b *Blob) AsObject() *Object

func (*Blob) Contents 

func (v *Blob) Contents() []byte

func (*Blob) IsBinary 

func (v *Blob) IsBinary() bool

func (*Blob) Size 

func (v *Blob) Size() int64

type BlobCallbackData deprecated 

type BlobCallbackData struct {
	Callback BlobChunkCallback
	Error    error
}

Deprecated: BlobCallbackData is not used.

type BlobChunkCallback deprecated 

type BlobChunkCallback func(maxLen int) ([]byte, error)

Deprecated: BlobChunkCallback is not used.

type BlobWriteStream 

type BlobWriteStream struct {
	// contains filtered or unexported fields
}

func (*BlobWriteStream) Commit 

func (stream *BlobWriteStream) Commit() (*Oid, error)

func (*BlobWriteStream) Free 

func (stream *BlobWriteStream) Free()

func (*BlobWriteStream) Write 

func (stream *BlobWriteStream) Write(p []byte) (int, error)

Implement io.Writer

type Branch 

type Branch struct {
	*Reference
	// contains filtered or unexported fields
}

func (*Branch) Delete 

func (b *Branch) Delete() error

func (*Branch) IsHead 

func (b *Branch) IsHead() (bool, error)

func (*Branch) Move 

func (b *Branch) Move(newBranchName string, force bool) (*Branch, error)

func (*Branch) Name 

func (b *Branch) Name() (string, error)

func (*Branch) SetUpstream 

func (b *Branch) SetUpstream(upstreamName string) error

func (*Branch) Upstream 

func (b *Branch) Upstream() (*Reference, error)

type BranchIterator 

type BranchIterator struct {
	// contains filtered or unexported fields
}

func (*BranchIterator) ForEach 

func (i *BranchIterator) ForEach(f BranchIteratorFunc) error

func (*BranchIterator) Free 

func (i *BranchIterator) Free()

func (*BranchIterator) Next 

func (i *BranchIterator) Next() (*Branch, BranchType, error)

type BranchIteratorFunc 

type BranchIteratorFunc func(*Branch, BranchType) error

type BranchType 

type BranchType uint
const (
	BranchAll    BranchType = C.GIT_BRANCH_ALL
	BranchLocal  BranchType = C.GIT_BRANCH_LOCAL
	BranchRemote BranchType = C.GIT_BRANCH_REMOTE
)

type Certificate 

type Certificate struct {
	Kind    CertificateKind
	X509    *x509.Certificate
	Hostkey HostkeyCertificate
}

Certificate represents the two possible certificates which libgit2 knows it might find. If Kind is CertficateX509 then the X509 field will be filled. If Kind is CertificateHostkey then the Hostkey field will be fille.d

type CertificateCheckCallback 

type CertificateCheckCallback func(cert *Certificate, valid bool, hostname string) ErrorCode

type CertificateKind 

type CertificateKind uint
const (
	CertificateX509    CertificateKind = C.GIT_CERT_X509
	CertificateHostkey CertificateKind = C.GIT_CERT_HOSTKEY_LIBSSH2
)

type CheckoutNotifyCallback 

type CheckoutNotifyCallback func(why CheckoutNotifyType, path string, baseline, target, workdir DiffFile) ErrorCode

type CheckoutNotifyType 

type CheckoutNotifyType uint

type CheckoutOptions 

type CheckoutOptions 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
	NotifyFlags      CheckoutNotifyType // Default will be none
	NotifyCallback   CheckoutNotifyCallback
	ProgressCallback CheckoutProgressCallback
	TargetDirectory  string // Alternative checkout path to workdir
	Paths            []string
	Baseline         *Tree
}

type CheckoutOpts deprecated 

type CheckoutOpts = CheckoutOptions

Deprecated: CheckoutOpts is a deprecated alias of CheckoutOptions.

type CheckoutProgressCallback 

type CheckoutProgressCallback func(path string, completed, total uint) ErrorCode

type CheckoutStrategy 

type CheckoutStrategy uint

type CherrypickOptions 

type CherrypickOptions struct {
	Version      uint
	Mainline     uint
	MergeOpts    MergeOptions
	CheckoutOpts CheckoutOptions
}

func DefaultCherrypickOptions 

func DefaultCherrypickOptions() (CherrypickOptions, error)

type CloneOptions 

type CloneOptions struct {
	*CheckoutOpts
	*FetchOptions
	Bare                 bool
	CheckoutBranch       string
	RemoteCreateCallback RemoteCreateCallback
}

type Commit 

type Commit struct {
	Object
	// contains filtered or unexported fields
}

Commit

func (*Commit) Amend 

func (c *Commit) Amend(refname string, author, committer *Signature, message string, tree *Tree) (*Oid, error)

func (*Commit) AsObject 

func (c *Commit) AsObject() *Object

func (*Commit) Author 

func (c *Commit) Author() *Signature

func (*Commit) Committer 

func (c *Commit) Committer() *Signature

func (*Commit) ContentToSign 

func (c *Commit) ContentToSign() string

ContentToSign returns the content that will be passed to a signing function for this commit

func (*Commit) Describe 

func (c *Commit) Describe(opts *DescribeOptions) (*DescribeResult, error)

Describe performs the describe operation on the commit.

func (*Commit) ExtractSignature 

func (c *Commit) ExtractSignature() (string, string, error)

func (*Commit) Message 

func (c *Commit) Message() string

func (*Commit) MessageEncoding 

func (c *Commit) MessageEncoding() string

func (*Commit) Parent 

func (c *Commit) Parent(n uint) *Commit

func (*Commit) ParentCount 

func (c *Commit) ParentCount() uint

func (*Commit) ParentId 

func (c *Commit) ParentId(n uint) *Oid

func (*Commit) RawHeader 

func (c *Commit) RawHeader() string

RawHeader gets the full raw text of the commit header.

func (*Commit) RawMessage 

func (c *Commit) RawMessage() string

func (*Commit) Summary 

func (c *Commit) Summary() string

func (*Commit) Tree 

func (c *Commit) Tree() (*Tree, error)

func (*Commit) TreeId 

func (c *Commit) TreeId() *Oid

func (*Commit) WithSignature 

func (c *Commit) WithSignature(signature string, signatureField string) (*Oid, error)

WithSignature creates a new signed commit from the given signature and signature field

func (*Commit) WithSignatureUsing 

func (c *Commit) WithSignatureUsing(f CommitSigningCallback) (*Oid, error)

WithSignatureUsing creates a new signed commit from this one using the given signing callback

type CommitSigningCallback 

type CommitSigningCallback func(string) (signature, signatureField string, err error)

CommitSigningCallback defines a function type that takes some data to sign and returns (signature, signature_field, error)

type CompletionCallback 

type CompletionCallback func(RemoteCompletion) ErrorCode

type Config 

type Config struct {
	// contains filtered or unexported fields
}

func NewConfig 

func NewConfig() (*Config, error)

NewConfig creates a new empty configuration object

func OpenDefault 

func OpenDefault() (*Config, error)

OpenDefault opens the default config according to git rules

func OpenOndisk 

func OpenOndisk(path string) (*Config, error)

OpenOndisk creates a new config instance containing a single on-disk file

func (*Config) AddFile 

func (c *Config) AddFile(path string, level ConfigLevel, force bool) error

AddFile adds a file-backed backend to the config object at the specified level.

func (*Config) Delete 

func (c *Config) Delete(name string) error

func (*Config) Free 

func (c *Config) Free()

func (*Config) LookupBool 

func (c *Config) LookupBool(name string) (bool, error)

func (*Config) LookupInt32 

func (c *Config) LookupInt32(name string) (int32, error)

func (*Config) LookupInt64 

func (c *Config) LookupInt64(name string) (int64, error)

func (*Config) LookupString 

func (c *Config) LookupString(name string) (string, error)

func (*Config) NewIterator 

func (c *Config) NewIterator() (*ConfigIterator, error)

NewIterator creates an iterator over each entry in the configuration

func (*Config) NewIteratorGlob 

func (c *Config) NewIteratorGlob(regexp string) (*ConfigIterator, error)

NewIteratorGlob creates an iterator over each entry in the configuration whose name matches the given regular expression

func (*Config) NewMultivarIterator 

func (c *Config) NewMultivarIterator(name, regexp string) (*ConfigIterator, error)

func (*Config) OpenLevel 

func (c *Config) OpenLevel(parent *Config, level ConfigLevel) (*Config, error)

OpenLevel creates a single-level focused config object from a multi-level one

func (*Config) SetBool 

func (c *Config) SetBool(name string, value bool) (err error)

func (*Config) SetInt32 

func (c *Config) SetInt32(name string, value int32) (err error)

func (*Config) SetInt64 

func (c *Config) SetInt64(name string, value int64) (err error)

func (*Config) SetMultivar 

func (c *Config) SetMultivar(name, regexp, value string) (err error)

func (*Config) SetString 

func (c *Config) SetString(name, value string) (err error)

type ConfigEntry 

type ConfigEntry struct {
	Name  string
	Value string
	Level ConfigLevel
}

type ConfigIterator 

type ConfigIterator struct {
	// contains filtered or unexported fields
}

func (*ConfigIterator) Free 

func (iter *ConfigIterator) Free()

func (*ConfigIterator) Next 

func (iter *ConfigIterator) Next() (*ConfigEntry, error)

Next returns the next entry for this iterator

type ConfigLevel 

type ConfigLevel int
const (
	// System-wide on Windows, for compatibility with portable git
	ConfigLevelProgramdata ConfigLevel = C.GIT_CONFIG_LEVEL_PROGRAMDATA

	// 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 ConnectDirection 

type ConnectDirection uint

type Cred deprecated 

type Cred = Credential

Deprecated: Cred is a deprecated alias of Credential

func NewCredDefault deprecated 

func NewCredDefault() (*Cred, error)

Deprecated: NewCredDefault is a deprecated alias fof NewCredentialDefault.

func NewCredSshKey deprecated 

func NewCredSshKey(username string, publicKeyPath string, privateKeyPath string, passphrase string) (*Cred, error)

Deprecated: NewCredSshKey is a deprecated alias of NewCredentialSshKey.

func NewCredSshKeyFromAgent deprecated 

func NewCredSshKeyFromAgent(username string) (*Cred, error)

Deprecated: NewCredSshKeyFromAgent is a deprecated alias of NewCredentialSSHFromAgent.

func NewCredSshKeyFromMemory deprecated 

func NewCredSshKeyFromMemory(username string, publicKey string, privateKey string, passphrase string) (*Cred, error)

Deprecated: NewCredSshKeyFromMemory is a deprecated alias of NewCredentialSSHKeyFromMemory.

func NewCredUsername deprecated 

func NewCredUsername(username string) (*Cred, error)

Deprecated: NewCredUsername is a deprecated alias of NewCredentialUsername.

func NewCredUserpassPlaintext deprecated 

func NewCredUserpassPlaintext(username string, password string) (*Cred, error)

Deprecated: NewCredUserpassPlaintext is a deprecated alias of NewCredentialUserpassPlaintext.

type CredType deprecated 

type CredType = CredentialType

Deprecated: CredType is a deprecated alias of CredentialType

type Credential 

type Credential struct {
	// contains filtered or unexported fields
}

func NewCredentialDefault 

func NewCredentialDefault() (*Credential, error)

func NewCredentialSSHKey 

func NewCredentialSSHKey(username string, publicKeyPath string, privateKeyPath string, passphrase string) (*Credential, error)

NewCredentialSSHKey creates new ssh credentials reading the public and private keys from the file system.

func NewCredentialSSHKeyFromAgent 

func NewCredentialSSHKeyFromAgent(username string) (*Credential, error)

func NewCredentialSSHKeyFromMemory 

func NewCredentialSSHKeyFromMemory(username string, publicKey string, privateKey string, passphrase string) (*Credential, error)

NewCredentialSSHKeyFromMemory creates new ssh credentials using the publicKey and privateKey arguments as the values for the public and private keys.

func NewCredentialSSHKeyFromSigner 

func NewCredentialSSHKeyFromSigner(username string, signer ssh.Signer) (*Credential, error)

NewCredentialSSHKeyFromSigner creates new SSH credentials using the provided signer.

func NewCredentialUsername 

func NewCredentialUsername(username string) (*Credential, error)

func NewCredentialUserpassPlaintext 

func NewCredentialUserpassPlaintext(username string, password string) (*Credential, error)

func (*Credential) Free 

func (o *Credential) Free()

func (*Credential) GetSSHKey 

func (o *Credential) GetSSHKey() (username, publickey, privatekey, passphrase string, err error)

GetSSHKey returns the SSH-specific key information from the Cred object.

func (*Credential) GetUserpassPlaintext 

func (o *Credential) GetUserpassPlaintext() (username, password string, err error)

GetUserpassPlaintext returns the plaintext username/password combination stored in the Cred.

func (*Credential) HasUsername 

func (o *Credential) HasUsername() bool

func (*Credential) Type 

func (o *Credential) Type() CredentialType

type CredentialType 

type CredentialType uint

CredentialType is a bitmask of supported credential types.

This represents the various types of authentication methods supported by the library. 

const (
	CredentialTypeUserpassPlaintext CredentialType = C.GIT_CREDENTIAL_USERPASS_PLAINTEXT
	CredentialTypeSSHKey            CredentialType = C.GIT_CREDENTIAL_SSH_KEY
	CredentialTypeSSHCustom         CredentialType = C.GIT_CREDENTIAL_SSH_CUSTOM
	CredentialTypeDefault           CredentialType = C.GIT_CREDENTIAL_DEFAULT
	CredentialTypeSSHInteractive    CredentialType = C.GIT_CREDENTIAL_SSH_INTERACTIVE
	CredentialTypeUsername          CredentialType = C.GIT_CREDENTIAL_USERNAME
	CredentialTypeSSHMemory         CredentialType = C.GIT_CREDENTIAL_SSH_MEMORY
)

func (CredentialType) String 

func (t CredentialType) String() string

type CredentialsCallback 

type CredentialsCallback func(url string, username_from_url string, allowed_types CredentialType) (*Credential, error)

type Delta 

type Delta int
const (
	DeltaUnmodified Delta = C.GIT_DELTA_UNMODIFIED
	DeltaAdded      Delta = C.GIT_DELTA_ADDED
	DeltaDeleted    Delta = C.GIT_DELTA_DELETED
	DeltaModified   Delta = C.GIT_DELTA_MODIFIED
	DeltaRenamed    Delta = C.GIT_DELTA_RENAMED
	DeltaCopied     Delta = C.GIT_DELTA_COPIED
	DeltaIgnored    Delta = C.GIT_DELTA_IGNORED
	DeltaUntracked  Delta = C.GIT_DELTA_UNTRACKED
	DeltaTypeChange Delta = C.GIT_DELTA_TYPECHANGE
	DeltaUnreadable Delta = C.GIT_DELTA_UNREADABLE
	DeltaConflicted Delta = C.GIT_DELTA_CONFLICTED
)

func (Delta) String 

func (i Delta) String() string

type DescribeFormatOptions 

type DescribeFormatOptions struct {
	// Size of the abbreviated commit id to use. This value is the
	// lower bound for the length of the abbreviated string.
	AbbreviatedSize uint // default: 7

	// Set to use the long format even when a shorter name could be used.
	AlwaysUseLongFormat bool

	// If the workdir is dirty and this is set, this string will be
	// appended to the description string.
	DirtySuffix string
}

DescribeFormatOptions can be used for formatting the describe string.

You can use DefaultDescribeFormatOptions() to get default options.

func DefaultDescribeFormatOptions 

func DefaultDescribeFormatOptions() (DescribeFormatOptions, error)

DefaultDescribeFormatOptions returns default options for formatting the output.

type DescribeOptions 

type DescribeOptions struct {
	// How many tags as candidates to consider to describe the input commit-ish.
	// Increasing it above 10 will take slightly longer but may produce a more
	// accurate result. 0 will cause only exact matches to be output.
	MaxCandidatesTags uint // default: 10

	// By default describe only shows annotated tags. Change this in order
	// to show all refs from refs/tags or refs/.
	Strategy DescribeOptionsStrategy // default: DescribeDefault

	// Only consider tags matching the given glob(7) pattern, excluding
	// the "refs/tags/" prefix. Can be used to avoid leaking private
	// tags from the repo.
	Pattern string

	// When calculating the distance from the matching tag or
	// reference, only walk down the first-parent ancestry.
	OnlyFollowFirstParent bool

	// If no matching tag or reference is found, the describe
	// operation would normally fail. If this option is set, it
	// will instead fall back to showing the full id of the commit.
	ShowCommitOidAsFallback bool
}

DescribeOptions represents the describe operation configuration.

You can use DefaultDescribeOptions() to get default options.

func DefaultDescribeOptions 

func DefaultDescribeOptions() (DescribeOptions, error)

DefaultDescribeOptions returns default options for the describe operation.

type DescribeOptionsStrategy 

type DescribeOptionsStrategy uint

DescribeOptionsStrategy behaves like the --tags and --all options to git-describe, namely they say to look for any reference in either refs/tags/ or refs/ respectively.

By default it only shows annotated tags. 

const (
	DescribeDefault DescribeOptionsStrategy = C.GIT_DESCRIBE_DEFAULT
	DescribeTags    DescribeOptionsStrategy = C.GIT_DESCRIBE_TAGS
	DescribeAll     DescribeOptionsStrategy = C.GIT_DESCRIBE_ALL
)

Describe strategy options.

type DescribeResult 

type DescribeResult struct {
	// contains filtered or unexported fields
}

DescribeResult represents the output from the 'git_describe_commit' and 'git_describe_workdir' functions in libgit2.

Use Format() to get a string out of it.

func (*DescribeResult) Format 

func (result *DescribeResult) Format(opts *DescribeFormatOptions) (string, error)

Format prints the DescribeResult as a string.

func (*DescribeResult) Free 

func (result *DescribeResult) Free()

Free cleans up the C reference.

type Diff 

type Diff struct {
	// contains filtered or unexported fields
}

func DiffFromBuffer 

func DiffFromBuffer(buffer []byte, repo *Repository) (*Diff, error)

DiffFromBuffer reads the contents of a git patch file into a Diff object.

The diff object produced is similar to the one that would be produced if you actually produced it computationally by comparing two trees, however there may be subtle differences. For example, a patch file likely contains abbreviated object IDs, so the object IDs in a git_diff_delta produced by this function will also be abbreviated.

This function will only read patch files created by a git implementation, it will not read unified diffs produced by the diff program, nor any other types of patch files.

func (*Diff) Delta 

func (diff *Diff) Delta(index int) (DiffDelta, error)

func (*Diff) FindSimilar 

func (diff *Diff) FindSimilar(opts *DiffFindOptions) error

func (*Diff) ForEach 

func (diff *Diff) ForEach(cbFile DiffForEachFileCallback, detail DiffDetail) error

func (*Diff) Free 

func (diff *Diff) Free() error

func (*Diff) GetDelta 

func (diff *Diff) GetDelta(index int) (DiffDelta, error)

deprecated: You should use `Diff.Delta()` instead.

func (*Diff) NumDeltas 

func (diff *Diff) NumDeltas() (int, error)

func (*Diff) Patch 

func (diff *Diff) Patch(deltaIndex int) (*Patch, error)

func (*Diff) Stats 

func (diff *Diff) Stats() (*DiffStats, error)

func (*Diff) ToBuf 

func (diff *Diff) ToBuf(format DiffFormat) ([]byte, error)

type DiffDelta 

type DiffDelta struct {
	Status     Delta
	Flags      DiffFlag
	Similarity uint16
	OldFile    DiffFile
	NewFile    DiffFile
}

type DiffDetail 

type DiffDetail int
const (
	DiffDetailFiles DiffDetail = iota
	DiffDetailHunks
	DiffDetailLines
)

type DiffFile 

type DiffFile struct {
	Path  string
	Oid   *Oid
	Size  int
	Flags DiffFlag
	Mode  uint16
}

type DiffFindOptions 

type DiffFindOptions struct {
	Flags                      DiffFindOptionsFlag
	RenameThreshold            uint16
	CopyThreshold              uint16
	RenameFromRewriteThreshold uint16
	BreakRewriteThreshold      uint16
	RenameLimit                uint
}

TODO implement git_diff_similarity_metric

func DefaultDiffFindOptions 

func DefaultDiffFindOptions() (DiffFindOptions, error)

type DiffFindOptionsFlag 

type DiffFindOptionsFlag int
const (
	DiffFindByConfig                    DiffFindOptionsFlag = C.GIT_DIFF_FIND_BY_CONFIG
	DiffFindRenames                     DiffFindOptionsFlag = C.GIT_DIFF_FIND_RENAMES
	DiffFindRenamesFromRewrites         DiffFindOptionsFlag = C.GIT_DIFF_FIND_RENAMES_FROM_REWRITES
	DiffFindCopies                      DiffFindOptionsFlag = C.GIT_DIFF_FIND_COPIES
	DiffFindCopiesFromUnmodified        DiffFindOptionsFlag = C.GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED
	DiffFindRewrites                    DiffFindOptionsFlag = C.GIT_DIFF_FIND_REWRITES
	DiffFindBreakRewrites               DiffFindOptionsFlag = C.GIT_DIFF_BREAK_REWRITES
	DiffFindAndBreakRewrites            DiffFindOptionsFlag = C.GIT_DIFF_FIND_AND_BREAK_REWRITES
	DiffFindForUntracked                DiffFindOptionsFlag = C.GIT_DIFF_FIND_FOR_UNTRACKED
	DiffFindAll                         DiffFindOptionsFlag = C.GIT_DIFF_FIND_ALL
	DiffFindIgnoreLeadingWhitespace     DiffFindOptionsFlag = C.GIT_DIFF_FIND_IGNORE_LEADING_WHITESPACE
	DiffFindIgnoreWhitespace            DiffFindOptionsFlag = C.GIT_DIFF_FIND_IGNORE_WHITESPACE
	DiffFindDontIgnoreWhitespace        DiffFindOptionsFlag = C.GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE
	DiffFindExactMatchOnly              DiffFindOptionsFlag = C.GIT_DIFF_FIND_EXACT_MATCH_ONLY
	DiffFindBreakRewritesForRenamesOnly DiffFindOptionsFlag = C.GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY
	DiffFindRemoveUnmodified            DiffFindOptionsFlag = C.GIT_DIFF_FIND_REMOVE_UNMODIFIED
)

type DiffFlag 

type DiffFlag uint32
const (
	DiffFlagBinary    DiffFlag = C.GIT_DIFF_FLAG_BINARY
	DiffFlagNotBinary DiffFlag = C.GIT_DIFF_FLAG_NOT_BINARY
	DiffFlagValidOid  DiffFlag = C.GIT_DIFF_FLAG_VALID_ID
	DiffFlagExists    DiffFlag = C.GIT_DIFF_FLAG_EXISTS
)

type DiffForEachFileCallback 

type DiffForEachFileCallback func(delta DiffDelta, progress float64) (DiffForEachHunkCallback, error)

type DiffForEachHunkCallback 

type DiffForEachHunkCallback func(DiffHunk) (DiffForEachLineCallback, error)

type DiffForEachLineCallback 

type DiffForEachLineCallback func(DiffLine) error

type DiffFormat 

type DiffFormat int
const (
	DiffFormatPatch       DiffFormat = C.GIT_DIFF_FORMAT_PATCH
	DiffFormatPatchHeader DiffFormat = C.GIT_DIFF_FORMAT_PATCH_HEADER
	DiffFormatRaw         DiffFormat = C.GIT_DIFF_FORMAT_RAW
	DiffFormatNameOnly    DiffFormat = C.GIT_DIFF_FORMAT_NAME_ONLY
	DiffFormatNameStatus  DiffFormat = C.GIT_DIFF_FORMAT_NAME_STATUS
)

type DiffHunk 

type DiffHunk struct {
	OldStart int
	OldLines int
	NewStart int
	NewLines int
	Header   string
}

type DiffLine 

type DiffLine struct {
	Origin    DiffLineType
	OldLineno int
	NewLineno int
	NumLines  int
	Content   string
}

type DiffLineType 

type DiffLineType int
const (
	DiffLineContext      DiffLineType = C.GIT_DIFF_LINE_CONTEXT
	DiffLineAddition     DiffLineType = C.GIT_DIFF_LINE_ADDITION
	DiffLineDeletion     DiffLineType = C.GIT_DIFF_LINE_DELETION
	DiffLineContextEOFNL DiffLineType = C.GIT_DIFF_LINE_CONTEXT_EOFNL
	DiffLineAddEOFNL     DiffLineType = C.GIT_DIFF_LINE_ADD_EOFNL
	DiffLineDelEOFNL     DiffLineType = C.GIT_DIFF_LINE_DEL_EOFNL

	DiffLineFileHdr DiffLineType = C.GIT_DIFF_LINE_FILE_HDR
	DiffLineHunkHdr DiffLineType = C.GIT_DIFF_LINE_HUNK_HDR
	DiffLineBinary  DiffLineType = C.GIT_DIFF_LINE_BINARY
)

func (DiffLineType) String 

func (i DiffLineType) String() string

type DiffNotifyCallback 

type DiffNotifyCallback func(diffSoFar *Diff, deltaToAdd DiffDelta, matchedPathspec string) error

type DiffOptions 

type DiffOptions struct {
	Flags            DiffOptionsFlag
	IgnoreSubmodules SubmoduleIgnore
	Pathspec         []string
	NotifyCallback   DiffNotifyCallback

	ContextLines   uint32
	InterhunkLines uint32
	IdAbbrev       uint16

	MaxSize int

	OldPrefix string
	NewPrefix string
}

func DefaultDiffOptions 

func DefaultDiffOptions() (DiffOptions, error)

type DiffOptionsFlag 

type DiffOptionsFlag int
const (
	DiffNormal                 DiffOptionsFlag = C.GIT_DIFF_NORMAL
	DiffReverse                DiffOptionsFlag = C.GIT_DIFF_REVERSE
	DiffIncludeIgnored         DiffOptionsFlag = C.GIT_DIFF_INCLUDE_IGNORED
	DiffRecurseIgnoredDirs     DiffOptionsFlag = C.GIT_DIFF_RECURSE_IGNORED_DIRS
	DiffIncludeUntracked       DiffOptionsFlag = C.GIT_DIFF_INCLUDE_UNTRACKED
	DiffRecurseUntracked       DiffOptionsFlag = C.GIT_DIFF_RECURSE_UNTRACKED_DIRS
	DiffIncludeUnmodified      DiffOptionsFlag = C.GIT_DIFF_INCLUDE_UNMODIFIED
	DiffIncludeTypeChange      DiffOptionsFlag = C.GIT_DIFF_INCLUDE_TYPECHANGE
	DiffIncludeTypeChangeTrees DiffOptionsFlag = C.GIT_DIFF_INCLUDE_TYPECHANGE_TREES
	DiffIgnoreFilemode         DiffOptionsFlag = C.GIT_DIFF_IGNORE_FILEMODE
	DiffIgnoreSubmodules       DiffOptionsFlag = C.GIT_DIFF_IGNORE_SUBMODULES
	DiffIgnoreCase             DiffOptionsFlag = C.GIT_DIFF_IGNORE_CASE
	DiffIncludeCaseChange      DiffOptionsFlag = C.GIT_DIFF_INCLUDE_CASECHANGE

	DiffDisablePathspecMatch    DiffOptionsFlag = C.GIT_DIFF_DISABLE_PATHSPEC_MATCH
	DiffSkipBinaryCheck         DiffOptionsFlag = C.GIT_DIFF_SKIP_BINARY_CHECK
	DiffEnableFastUntrackedDirs DiffOptionsFlag = C.GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS

	DiffForceText   DiffOptionsFlag = C.GIT_DIFF_FORCE_TEXT
	DiffForceBinary DiffOptionsFlag = C.GIT_DIFF_FORCE_BINARY

	DiffIgnoreWhitespace       DiffOptionsFlag = C.GIT_DIFF_IGNORE_WHITESPACE
	DiffIgnoreWhitespaceChange DiffOptionsFlag = C.GIT_DIFF_IGNORE_WHITESPACE_CHANGE
	DiffIgnoreWhitespaceEOL    DiffOptionsFlag = C.GIT_DIFF_IGNORE_WHITESPACE_EOL

	DiffShowUntrackedContent DiffOptionsFlag = C.GIT_DIFF_SHOW_UNTRACKED_CONTENT
	DiffShowUnmodified       DiffOptionsFlag = C.GIT_DIFF_SHOW_UNMODIFIED
	DiffPatience             DiffOptionsFlag = C.GIT_DIFF_PATIENCE
	DiffMinimal              DiffOptionsFlag = C.GIT_DIFF_MINIMAL
	DiffShowBinary           DiffOptionsFlag = C.GIT_DIFF_SHOW_BINARY
	DiffIndentHeuristic      DiffOptionsFlag = C.GIT_DIFF_INDENT_HEURISTIC
)

type DiffStats 

type DiffStats struct {
	// contains filtered or unexported fields
}

func (*DiffStats) Deletions 

func (stats *DiffStats) Deletions() int

func (*DiffStats) FilesChanged 

func (stats *DiffStats) FilesChanged() int

func (*DiffStats) Free 

func (stats *DiffStats) Free() error

func (*DiffStats) Insertions 

func (stats *DiffStats) Insertions() int

func (*DiffStats) String 

func (stats *DiffStats) String(format DiffStatsFormat,
	width uint) (string, error)

type DiffStatsFormat 

type DiffStatsFormat int
const (
	DiffStatsNone           DiffStatsFormat = C.GIT_DIFF_STATS_NONE
	DiffStatsFull           DiffStatsFormat = C.GIT_DIFF_STATS_FULL
	DiffStatsShort          DiffStatsFormat = C.GIT_DIFF_STATS_SHORT
	DiffStatsNumber         DiffStatsFormat = C.GIT_DIFF_STATS_NUMBER
	DiffStatsIncludeSummary DiffStatsFormat = C.GIT_DIFF_STATS_INCLUDE_SUMMARY
)

type DownloadTags 

type DownloadTags uint
const (
	// Use the setting from the configuration.
	DownloadTagsUnspecified DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED
	// Ask the server for tags pointing to objects we're already
	// downloading.
	DownloadTagsAuto DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_AUTO

	// Don't ask for any tags beyond the refspecs.
	DownloadTagsNone DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_NONE

	// Ask for the all the tags.
	DownloadTagsAll DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_ALL
)

type ErrorClass 

type ErrorClass int
const (
	ErrorClassNone       ErrorClass = C.GIT_ERROR_NONE
	ErrorClassNoMemory   ErrorClass = C.GIT_ERROR_NOMEMORY
	ErrorClassOS         ErrorClass = C.GIT_ERROR_OS
	ErrorClassInvalid    ErrorClass = C.GIT_ERROR_INVALID
	ErrorClassReference  ErrorClass = C.GIT_ERROR_REFERENCE
	ErrorClassZlib       ErrorClass = C.GIT_ERROR_ZLIB
	ErrorClassRepository ErrorClass = C.GIT_ERROR_REPOSITORY
	ErrorClassConfig     ErrorClass = C.GIT_ERROR_CONFIG
	ErrorClassRegex      ErrorClass = C.GIT_ERROR_REGEX
	ErrorClassOdb        ErrorClass = C.GIT_ERROR_ODB
	ErrorClassIndex      ErrorClass = C.GIT_ERROR_INDEX
	ErrorClassObject     ErrorClass = C.GIT_ERROR_OBJECT
	ErrorClassNet        ErrorClass = C.GIT_ERROR_NET
	ErrorClassTag        ErrorClass = C.GIT_ERROR_TAG
	ErrorClassTree       ErrorClass = C.GIT_ERROR_TREE
	ErrorClassIndexer    ErrorClass = C.GIT_ERROR_INDEXER
	ErrorClassSSL        ErrorClass = C.GIT_ERROR_SSL
	ErrorClassSubmodule  ErrorClass = C.GIT_ERROR_SUBMODULE
	ErrorClassThread     ErrorClass = C.GIT_ERROR_THREAD
	ErrorClassStash      ErrorClass = C.GIT_ERROR_STASH
	ErrorClassCheckout   ErrorClass = C.GIT_ERROR_CHECKOUT
	ErrorClassFetchHead  ErrorClass = C.GIT_ERROR_FETCHHEAD
	ErrorClassMerge      ErrorClass = C.GIT_ERROR_MERGE
	ErrorClassSSH        ErrorClass = C.GIT_ERROR_SSH
	ErrorClassFilter     ErrorClass = C.GIT_ERROR_FILTER
	ErrorClassRevert     ErrorClass = C.GIT_ERROR_REVERT
	ErrorClassCallback   ErrorClass = C.GIT_ERROR_CALLBACK
	ErrorClassRebase     ErrorClass = C.GIT_ERROR_REBASE
	ErrorClassPatch      ErrorClass = C.GIT_ERROR_PATCH
)

func (ErrorClass) String 

func (i ErrorClass) String() string

type ErrorCode 

type ErrorCode int
const (
	// ErrorCodeOK indicates that the operation completed successfully.
	ErrorCodeOK ErrorCode = C.GIT_OK

	// ErrorCodeGeneric represents a generic error.
	ErrorCodeGeneric ErrorCode = C.GIT_ERROR
	// ErrorCodeNotFound represents that the requested object could not be found
	ErrorCodeNotFound ErrorCode = C.GIT_ENOTFOUND
	// ErrorCodeExists represents that the object exists preventing operation.
	ErrorCodeExists ErrorCode = C.GIT_EEXISTS
	// ErrorCodeAmbiguous represents that more than one object matches.
	ErrorCodeAmbiguous ErrorCode = C.GIT_EAMBIGUOUS
	// ErrorCodeBuffs represents that the output buffer is too short to hold data.
	ErrorCodeBuffs ErrorCode = 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.
	ErrorCodeUser ErrorCode = C.GIT_EUSER

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

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

func (ErrorCode) String 

func (i ErrorCode) String() string

type Feature 

type Feature int
const (
	// libgit2 was built with threading support
	FeatureThreads Feature = C.GIT_FEATURE_THREADS

	// libgit2 was built with HTTPS support built-in
	FeatureHTTPS Feature = C.GIT_FEATURE_HTTPS

	// libgit2 was build with SSH support built-in
	FeatureSSH Feature = C.GIT_FEATURE_SSH

	// libgit2 was built with nanosecond support for files
	FeatureNSec Feature = C.GIT_FEATURE_NSEC
)

func Features 

func Features() Feature

Features returns a bit-flag of Feature values indicating which features the loaded libgit2 library has.

type FetchOptions 

type FetchOptions struct {
	// Callbacks to use for this fetch operation
	RemoteCallbacks RemoteCallbacks
	// Whether to perform a prune after the fetch
	Prune FetchPrune
	// Whether to write the results to FETCH_HEAD. Defaults to
	// on. Leave this default in order to behave like git.
	UpdateFetchhead bool

	// Determines how to behave regarding tags on the remote, such
	// as auto-downloading tags for objects we're downloading or
	// downloading all of them.
	//
	// The default is to auto-follow tags.
	DownloadTags DownloadTags

	// Headers are extra headers for the fetch operation.
	Headers []string

	// Proxy options to use for this fetch operation
	ProxyOptions ProxyOptions
}

type FetchPrune 

type FetchPrune uint
const (
	// Use the setting from the configuration
	FetchPruneUnspecified FetchPrune = C.GIT_FETCH_PRUNE_UNSPECIFIED
	// Force pruning on
	FetchPruneOn FetchPrune = C.GIT_FETCH_PRUNE
	// Force pruning off
	FetchNoPrune FetchPrune = C.GIT_FETCH_NO_PRUNE
)

type Filemode 

type Filemode int
const (
	FilemodeTree           Filemode = C.GIT_FILEMODE_TREE
	FilemodeBlob           Filemode = C.GIT_FILEMODE_BLOB
	FilemodeBlobExecutable Filemode = C.GIT_FILEMODE_BLOB_EXECUTABLE
	FilemodeLink           Filemode = C.GIT_FILEMODE_LINK
	FilemodeCommit         Filemode = C.GIT_FILEMODE_COMMIT
)

type GitError 

type GitError struct {
	Message string
	Class   ErrorClass
	Code    ErrorCode
}

func (GitError) Error 

func (e GitError) Error() string

type HandleList 

type HandleList struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewHandleList 

func NewHandleList() *HandleList

func (*HandleList) Clear 

func (v *HandleList) Clear()

Clear stops tracking all the managed pointers.

func (*HandleList) Get 

func (v *HandleList) Get(handle unsafe.Pointer) interface{}

Get retrieves the pointer from the given handle

func (*HandleList) Track 

func (v *HandleList) Track(pointer interface{}) unsafe.Pointer

Track adds the given pointer to the list of pointers to track and returns a pointer value which can be passed to C as an opaque pointer.

func (*HandleList) Untrack 

func (v *HandleList) Untrack(handle unsafe.Pointer)

Untrack stops tracking the pointer given by the handle

type HostkeyCertificate 

type HostkeyCertificate struct {
	Kind         HostkeyKind
	HashMD5      [16]byte
	HashSHA1     [20]byte
	HashSHA256   [32]byte
	Hostkey      []byte
	SSHPublicKey ssh.PublicKey
}

Server host key information. A bitmask containing the available fields. Check for combinations of: HostkeyMD5, HostkeySHA1, HostkeySHA256, HostkeyRaw.

type HostkeyKind 

type HostkeyKind uint

HostkeyKind is a bitmask of the available hashes in HostkeyCertificate. 

const (
	HostkeyMD5    HostkeyKind = C.GIT_CERT_SSH_MD5
	HostkeySHA1   HostkeyKind = C.GIT_CERT_SSH_SHA1
	HostkeySHA256 HostkeyKind = C.GIT_CERT_SSH_SHA256
	HostkeyRaw    HostkeyKind = 1 << 3
)

type Index 

type Index struct {
	// contains filtered or unexported fields
}

func NewIndex 

func NewIndex() (*Index, error)

NewIndex allocates a new index. It won't be associated with any file on the filesystem or repository

func OpenIndex 

func OpenIndex(path string) (*Index, error)

OpenIndex creates a new index at the given path. If the file does not exist it will be created when Write() is called.

func (*Index) Add 

func (v *Index) Add(entry *IndexEntry) error

Add adds or replaces the given entry to the index, making a copy of the data

func (*Index) AddAll 

func (v *Index) AddAll(pathspecs []string, flags IndexAddOption, callback IndexMatchedPathCallback) error

func (*Index) AddByPath 

func (v *Index) AddByPath(path string) error

func (*Index) AddConflict 

func (v *Index) AddConflict(ancestor *IndexEntry, our *IndexEntry, their *IndexEntry) error

func (*Index) AddFromBuffer 

func (v *Index) AddFromBuffer(entry *IndexEntry, buffer []byte) error

AddFromBuffer adds or replaces an index entry from a buffer in memory

func (*Index) CleanupConflicts 

func (v *Index) CleanupConflicts()

FIXME: this might return an error

func (*Index) Clear 

func (v *Index) Clear() error

Clear clears the index object in memory; changes must be explicitly written to disk for them to take effect persistently

func (*Index) Conflict 

func (v *Index) Conflict(path string) (IndexConflict, error)

func (*Index) ConflictIterator 

func (v *Index) ConflictIterator() (*IndexConflictIterator, error)

func (*Index) EntryByIndex 

func (v *Index) EntryByIndex(index uint) (*IndexEntry, error)

func (*Index) EntryByPath 

func (v *Index) EntryByPath(path string, stage int) (*IndexEntry, error)

func (*Index) EntryCount 

func (v *Index) EntryCount() uint

func (*Index) Find 

func (v *Index) Find(path string) (uint, error)

func (*Index) FindPrefix 

func (v *Index) FindPrefix(prefix string) (uint, error)

func (*Index) Free 

func (v *Index) Free()

func (*Index) GetConflict 

func (v *Index) GetConflict(path string) (IndexConflict, error)

deprecated: You should use `Index.Conflict()` instead.

func (*Index) HasConflicts 

func (v *Index) HasConflicts() bool

func (*Index) Path 

func (v *Index) Path() string

Path returns the index' path on disk or an empty string if it exists only in memory.

func (*Index) ReadTree 

func (v *Index) ReadTree(tree *Tree) error

ReadTree replaces the contents of the index with those of the given tree

func (*Index) RemoveAll 

func (v *Index) RemoveAll(pathspecs []string, callback IndexMatchedPathCallback) error

func (*Index) RemoveByPath 

func (v *Index) RemoveByPath(path string) error

func (*Index) RemoveConflict 

func (v *Index) RemoveConflict(path string) error

func (*Index) RemoveDirectory 

func (v *Index) RemoveDirectory(dir string, stage int) error

RemoveDirectory removes all entries from the index under a given directory.

func (*Index) UpdateAll 

func (v *Index) UpdateAll(pathspecs []string, callback IndexMatchedPathCallback) error

func (*Index) Write 

func (v *Index) Write() error

func (*Index) WriteTree 

func (v *Index) WriteTree() (*Oid, error)

func (*Index) WriteTreeTo 

func (v *Index) WriteTreeTo(repo *Repository) (*Oid, error)

type IndexAddOption 

type IndexAddOption uint

IndexAddOption is a set of flags for APIs that add files matching pathspec. 

const (
	IndexAddDefault              IndexAddOption = C.GIT_INDEX_ADD_DEFAULT
	IndexAddForce                IndexAddOption = C.GIT_INDEX_ADD_FORCE
	IndexAddDisablePathspecMatch IndexAddOption = C.GIT_INDEX_ADD_DISABLE_PATHSPEC_MATCH
	IndexAddCheckPathspec        IndexAddOption = C.GIT_INDEX_ADD_CHECK_PATHSPEC
)

type IndexAddOpts deprecated 

type IndexAddOpts = IndexAddOption

Deprecated: IndexAddOpts is a deprecated alias of IndexAddOption.

type IndexConflict 

type IndexConflict struct {
	Ancestor *IndexEntry
	Our      *IndexEntry
	Their    *IndexEntry
}

type IndexConflictIterator 

type IndexConflictIterator struct {
	// contains filtered or unexported fields
}

func (*IndexConflictIterator) Free 

func (v *IndexConflictIterator) Free()

func (*IndexConflictIterator) Index 

func (v *IndexConflictIterator) Index() *Index

func (*IndexConflictIterator) Next 

func (v *IndexConflictIterator) Next() (IndexConflict, error)

type IndexEntry 

type IndexEntry struct {
	Ctime IndexTime
	Mtime IndexTime
	Mode  Filemode
	Uid   uint32
	Gid   uint32
	Size  uint32
	Id    *Oid
	Path  string
}

type IndexMatchedPathCallback 

type IndexMatchedPathCallback func(string, string) int

type IndexStageOpts deprecated 

type IndexStageOpts = IndexStageState

Deprecated: IndexStageOpts is a deprecated alias of IndexStageState.

type IndexStageState 

type IndexStageState int

IndexStageState indicates the state of the git index. 

const (
	// IndexStageAny matches any index stage.
	//
	// Some index APIs take a stage to match; pass this value to match
	// any entry matching the path regardless of stage.
	IndexStageAny IndexStageState = C.GIT_INDEX_STAGE_ANY
	// IndexStageNormal is a normal staged file in the index.
	IndexStageNormal IndexStageState = C.GIT_INDEX_STAGE_NORMAL
	// IndexStageAncestor is the ancestor side of a conflict.
	IndexStageAncestor IndexStageState = C.GIT_INDEX_STAGE_ANCESTOR
	// IndexStageOurs is the "ours" side of a conflict.
	IndexStageOurs IndexStageState = C.GIT_INDEX_STAGE_OURS
	// IndexStageTheirs is the "theirs" side of a conflict.
	IndexStageTheirs IndexStageState = C.GIT_INDEX_STAGE_THEIRS
)

type IndexTime 

type IndexTime struct {
	Seconds     int32
	Nanoseconds uint32
}

type Indexer 

type Indexer struct {
	// contains filtered or unexported fields
}

Indexer can post-process packfiles and create an .idx file for efficient lookup.

func NewIndexer 

func NewIndexer(packfilePath string, odb *Odb, callback TransferProgressCallback) (indexer *Indexer, err error)

NewIndexer creates a new indexer instance.

func (*Indexer) Commit 

func (indexer *Indexer) Commit() (*Oid, error)

Commit finalizes the pack and index. It resolves any pending deltas and writes out the index file.

It also returns the packfile's hash. A packfile's name is derived from the sorted hashing of all object names.

func (*Indexer) Free 

func (indexer *Indexer) Free()

Free frees the indexer and its resources.

func (*Indexer) Write 

func (indexer *Indexer) Write(data []byte) (int, error)

Write adds data to the indexer.

type Mempack 

type Mempack struct {
	// contains filtered or unexported fields
}

Mempack is a custom ODB backend that permits packing object in-memory.

func NewMempack 

func NewMempack(odb *Odb) (mempack *Mempack, err error)

NewMempack creates a new mempack instance and registers it to the ODB.

func (*Mempack) Dump 

func (mempack *Mempack) Dump(repository *Repository) ([]byte, error)

Dump dumps all the queued in-memory writes to a packfile.

It is the caller's responsibility to ensure that the generated packfile is available to the repository (e.g. by writing it to disk, or doing something crazy like distributing it across several copies of the repository over a network).

Once the generated packfile is available to the repository, call Mempack.Reset to cleanup the memory store.

Calling Mempack.Reset before the packfile has been written to disk will result in an inconsistent repository (the objects in the memory store won't be accessible).

func (*Mempack) Reset 

func (mempack *Mempack) Reset() error

Reset resets the memory packer by clearing all the queued objects.

This assumes that Mempack.Dump has been called before to store all the queued objects into a single packfile.

type MergeAnalysis 

type MergeAnalysis int
const (
	MergeAnalysisNone        MergeAnalysis = C.GIT_MERGE_ANALYSIS_NONE
	MergeAnalysisNormal      MergeAnalysis = C.GIT_MERGE_ANALYSIS_NORMAL
	MergeAnalysisUpToDate    MergeAnalysis = C.GIT_MERGE_ANALYSIS_UP_TO_DATE
	MergeAnalysisFastForward MergeAnalysis = C.GIT_MERGE_ANALYSIS_FASTFORWARD
	MergeAnalysisUnborn      MergeAnalysis = C.GIT_MERGE_ANALYSIS_UNBORN
)

type MergeFileFavor 

type MergeFileFavor int
const (
	MergeFileFavorNormal MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_NORMAL
	MergeFileFavorOurs   MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_OURS
	MergeFileFavorTheirs MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_THEIRS
	MergeFileFavorUnion  MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_UNION
)

type MergeFileFlags 

type MergeFileFlags int
const (
	MergeFileDefault MergeFileFlags = C.GIT_MERGE_FILE_DEFAULT

	// Create standard conflicted merge files
	MergeFileStyleMerge MergeFileFlags = C.GIT_MERGE_FILE_STYLE_MERGE

	// Create diff3-style files
	MergeFileStyleDiff MergeFileFlags = C.GIT_MERGE_FILE_STYLE_DIFF3

	// Condense non-alphanumeric regions for simplified diff file
	MergeFileStyleSimplifyAlnum MergeFileFlags = C.GIT_MERGE_FILE_SIMPLIFY_ALNUM

	// Ignore all whitespace
	MergeFileIgnoreWhitespace MergeFileFlags = C.GIT_MERGE_FILE_IGNORE_WHITESPACE

	// Ignore changes in amount of whitespace
	MergeFileIgnoreWhitespaceChange MergeFileFlags = C.GIT_MERGE_FILE_IGNORE_WHITESPACE_CHANGE

	// Ignore whitespace at end of line
	MergeFileIgnoreWhitespaceEOL MergeFileFlags = C.GIT_MERGE_FILE_IGNORE_WHITESPACE_EOL

	// Use the "patience diff" algorithm
	MergeFileDiffPatience MergeFileFlags = C.GIT_MERGE_FILE_DIFF_PATIENCE

	// Take extra time to find minimal diff
	MergeFileDiffMinimal MergeFileFlags = C.GIT_MERGE_FILE_DIFF_MINIMAL
)

type MergeFileInput 

type MergeFileInput struct {
	Path     string
	Mode     uint
	Contents []byte
}

type MergeFileOptions 

type MergeFileOptions struct {
	AncestorLabel string
	OurLabel      string
	TheirLabel    string
	Favor         MergeFileFavor
	Flags         MergeFileFlags
	MarkerSize    uint16
}

type MergeFileResult 

type MergeFileResult struct {
	Automergeable bool
	Path          string
	Mode          uint
	Contents      []byte
	// contains filtered or unexported fields
}

func MergeFile 

func MergeFile(ancestor MergeFileInput, ours MergeFileInput, theirs MergeFileInput, options *MergeFileOptions) (*MergeFileResult, error)

func (*MergeFileResult) Free 

func (r *MergeFileResult) Free()

type MergeOptions 

type MergeOptions struct {
	Version   uint
	TreeFlags MergeTreeFlag

	RenameThreshold uint
	TargetLimit     uint
	RecursionLimit  uint
	FileFavor       MergeFileFavor
}

func DefaultMergeOptions 

func DefaultMergeOptions() (MergeOptions, error)

type MergePreference 

type MergePreference int
const (
	MergePreferenceNone            MergePreference = C.GIT_MERGE_PREFERENCE_NONE
	MergePreferenceNoFastForward   MergePreference = C.GIT_MERGE_PREFERENCE_NO_FASTFORWARD
	MergePreferenceFastForwardOnly MergePreference = C.GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY
)

type MergeTreeFlag 

type MergeTreeFlag int
const (
	// Detect renames that occur between the common ancestor and the "ours"
	// side or the common ancestor and the "theirs" side.  This will enable
	// the ability to merge between a modified and renamed file.
	MergeTreeFindRenames MergeTreeFlag = C.GIT_MERGE_FIND_RENAMES
	// If a conflict occurs, exit immediately instead of attempting to
	// continue resolving conflicts.  The merge operation will fail with
	// GIT_EMERGECONFLICT and no index will be returned.
	MergeTreeFailOnConflict MergeTreeFlag = C.GIT_MERGE_FAIL_ON_CONFLICT
	// MergeTreeSkipREUC specifies not to write the REUC extension on the
	// generated index.
	MergeTreeSkipREUC MergeTreeFlag = C.GIT_MERGE_SKIP_REUC
	// MergeTreeNoRecursive specifies not to build a recursive merge base (by
	// merging the multiple merge bases) if the commits being merged have
	// multiple merge bases. Instead, the first base is used.
	// This flag provides a similar merge base to `git-merge-resolve`.
	MergeTreeNoRecursive MergeTreeFlag = C.GIT_MERGE_NO_RECURSIVE
)

type MessageEncoding 

type MessageEncoding string

MessageEncoding is the encoding of commit messages. 

const (
	// MessageEncodingUTF8 is the default message encoding.
	MessageEncodingUTF8 MessageEncoding = "UTF-8"
)

type Note 

type Note struct {
	// contains filtered or unexported fields
}

Note

func (*Note) Author 

func (n *Note) Author() *Signature

Author returns the signature of the note author

func (*Note) Committer 

func (n *Note) Committer() *Signature

Committer returns the signature of the note committer

func (*Note) Free 

func (n *Note) Free() error

Free frees a git_note object

func (*Note) Id 

func (n *Note) Id() *Oid

Id returns the note object's id

func (*Note) Message 

func (n *Note) Message() string

Message returns the note message

type NoteCollection 

type NoteCollection struct {
	// contains filtered or unexported fields
}

This object represents the possible operations which can be performed on the collection of notes for a repository.

func (*NoteCollection) Create 

func (c *NoteCollection) Create(
	ref string, author, committer *Signature, id *Oid,
	note string, force bool) (*Oid, error)

Create adds a note for an object

func (*NoteCollection) DefaultRef 

func (c *NoteCollection) DefaultRef() (string, error)

DefaultRef returns the default notes reference for a repository

func (*NoteCollection) Read 

func (c *NoteCollection) Read(ref string, id *Oid) (*Note, error)

Read reads the note for an object

func (*NoteCollection) Remove 

func (c *NoteCollection) Remove(ref string, author, committer *Signature, id *Oid) error

Remove removes the note for an object

type NoteIterator 

type NoteIterator struct {
	// contains filtered or unexported fields
}

NoteIterator

func (*NoteIterator) Free 

func (v *NoteIterator) Free()

Free frees the note interator

func (*NoteIterator) Next 

func (it *NoteIterator) Next() (noteId, annotatedId *Oid, err error)

Next returns the current item (note id & annotated id) and advances the iterator internally to the next item

type Object 

type Object struct {
	// contains filtered or unexported fields
}

func (*Object) AsBlob 

func (o *Object) AsBlob() (*Blob, error)

func (*Object) AsCommit 

func (o *Object) AsCommit() (*Commit, error)

func (*Object) AsTag 

func (o *Object) AsTag() (*Tag, error)

func (*Object) AsTree 

func (o *Object) AsTree() (*Tree, error)

func (*Object) Free 

func (o *Object) Free()

func (*Object) Id 

func (o *Object) Id() *Oid

func (*Object) Owner 

func (o *Object) Owner() *Repository

Owner returns a weak reference to the repository which owns this object. This won't keep the underlying repository alive, but it should still be Freed.

func (*Object) Peel 

func (o *Object) Peel(t ObjectType) (*Object, error)

Peel recursively peels an object until an object of the specified type is met.

If the query cannot be satisfied due to the object model, ErrorCodeInvalidSpec will be returned (e.g. trying to peel a blob to a tree).

If you pass ObjectAny as the target type, then the object will be peeled until the type changes. A tag will be peeled until the referenced object is no longer a tag, and a commit will be peeled to a tree. Any other object type will return ErrorCodeInvalidSpec.

If peeling a tag we discover an object which cannot be peeled to the target type due to the object model, an error will be returned.

func (*Object) ShortId 

func (o *Object) ShortId() (string, error)

func (*Object) Type 

func (o *Object) Type() ObjectType

type ObjectType 

type ObjectType int
const (
	ObjectAny     ObjectType = C.GIT_OBJECT_ANY
	ObjectInvalid ObjectType = C.GIT_OBJECT_INVALID
	ObjectCommit  ObjectType = C.GIT_OBJECT_COMMIT
	ObjectTree    ObjectType = C.GIT_OBJECT_TREE
	ObjectBlob    ObjectType = C.GIT_OBJECT_BLOB
	ObjectTag     ObjectType = C.GIT_OBJECT_TAG
)

func (ObjectType) String 

func (t ObjectType) String() string

type Objecter 

type Objecter interface {
	AsObject() *Object
}

Objecter lets us accept any kind of Git object in functions.

type Odb 

type Odb struct {
	// contains filtered or unexported fields
}

func NewOdb 

func NewOdb() (odb *Odb, err error)

func (*Odb) AddAlternate 

func (v *Odb) AddAlternate(backend *OdbBackend, priority int) (err error)

func (*Odb) AddBackend 

func (v *Odb) AddBackend(backend *OdbBackend, priority int) (err error)

func (*Odb) Exists 

func (v *Odb) Exists(oid *Oid) bool

func (*Odb) ForEach 

func (v *Odb) ForEach(callback OdbForEachCallback) error

func (*Odb) Free 

func (v *Odb) Free()

func (*Odb) Hash 

func (v *Odb) Hash(data []byte, otype ObjectType) (oid *Oid, err error)

Hash determines the object-ID (sha1) of a data buffer.

func (*Odb) NewReadStream 

func (v *Odb) NewReadStream(id *Oid) (*OdbReadStream, error)

NewReadStream opens a read stream from the ODB. Reading from it will give you the contents of the object.

func (*Odb) NewWritePack 

func (v *Odb) NewWritePack(callback TransferProgressCallback) (*OdbWritepack, error)

NewWritePack opens a stream for writing a pack file to the ODB. If the ODB layer understands pack files, then the given packfile will likely be streamed directly to disk (and a corresponding index created). If the ODB layer does not understand pack files, the objects will be stored in whatever format the ODB layer uses.

func (*Odb) NewWriteStream 

func (v *Odb) NewWriteStream(size int64, otype ObjectType) (*OdbWriteStream, error)

NewWriteStream opens a write stream to the ODB, which allows you to create a new object in the database. The size and type must be known in advance

func (*Odb) Read 

func (v *Odb) Read(oid *Oid) (obj *OdbObject, err error)

func (*Odb) ReadHeader 

func (v *Odb) ReadHeader(oid *Oid) (uint64, ObjectType, error)

func (*Odb) Write 

func (v *Odb) Write(data []byte, otype ObjectType) (oid *Oid, err error)

type OdbBackend 

type OdbBackend struct {
	// contains filtered or unexported fields
}

func NewOdbBackendFromC 

func NewOdbBackendFromC(ptr unsafe.Pointer) (backend *OdbBackend)

func NewOdbBackendLoose 

func NewOdbBackendLoose(objectsDir string, compressionLevel int, doFsync bool, dirMode os.FileMode, fileMode os.FileMode) (backend *OdbBackend, err error)

NewOdbBackendLoose creates a backend for loose objects.

func NewOdbBackendOnePack 

func NewOdbBackendOnePack(packfileIndexPath string) (backend *OdbBackend, err error)

func (*OdbBackend) Free 

func (v *OdbBackend) Free()

type OdbForEachCallback 

type OdbForEachCallback func(id *Oid) error

type OdbObject 

type OdbObject struct {
	// contains filtered or unexported fields
}

func (*OdbObject) Data 

func (object *OdbObject) Data() (data []byte)

Data returns a slice pointing to the unmanaged object memory. You must make sure the object is referenced for at least as long as the slice is used.

func (*OdbObject) Free 

func (v *OdbObject) Free()

func (*OdbObject) Id 

func (object *OdbObject) Id() (oid *Oid)

func (*OdbObject) Len 

func (object *OdbObject) Len() (len uint64)

func (*OdbObject) Type 

func (object *OdbObject) Type() ObjectType

type OdbReadStream 

type OdbReadStream struct {
	Size uint64
	Type ObjectType
	// contains filtered or unexported fields
}

func (*OdbReadStream) Close 

func (stream *OdbReadStream) Close() error

Close is a dummy function in order to implement the Closer and ReadCloser interfaces

func (*OdbReadStream) Free 

func (stream *OdbReadStream) Free()

func (*OdbReadStream) Read 

func (stream *OdbReadStream) Read(data []byte) (int, error)

Read reads from the stream

type OdbWriteStream 

type OdbWriteStream struct {
	Id Oid
	// contains filtered or unexported fields
}

func (*OdbWriteStream) Close 

func (stream *OdbWriteStream) Close() error

Close signals that all the data has been written and stores the resulting object id in the stream's Id field.

func (*OdbWriteStream) Free 

func (stream *OdbWriteStream) Free()

func (*OdbWriteStream) Write 

func (stream *OdbWriteStream) Write(data []byte) (int, error)

Write writes to the stream

type OdbWritepack 

type OdbWritepack struct {
	// contains filtered or unexported fields
}

OdbWritepack is a stream to write a packfile to the ODB.

func (*OdbWritepack) Commit 

func (writepack *OdbWritepack) Commit() error

func (*OdbWritepack) Free 

func (writepack *OdbWritepack) Free()

func (*OdbWritepack) Write 

func (writepack *OdbWritepack) Write(data []byte) (int, error)

type Oid 

type Oid [20]byte

Oid represents the id for a Git object.

func NewOid 

func NewOid(s string) (*Oid, error)

func NewOidFromBytes 

func NewOidFromBytes(b []byte) *Oid

func (*Oid) Cmp 

func (oid *Oid) Cmp(oid2 *Oid) int

func (*Oid) Copy 

func (oid *Oid) Copy() *Oid

func (*Oid) Equal 

func (oid *Oid) Equal(oid2 *Oid) bool

func (*Oid) IsZero 

func (oid *Oid) IsZero() bool

func (*Oid) NCmp 

func (oid *Oid) NCmp(oid2 *Oid, n uint) int

func (*Oid) String 

func (oid *Oid) String() string

type Packbuilder 

type Packbuilder struct {
	// contains filtered or unexported fields
}

func (*Packbuilder) ForEach 

func (pb *Packbuilder) ForEach(callback PackbuilderForeachCallback) error

ForEach repeatedly calls the callback with new packfile data until there is no more data or the callback returns an error

func (*Packbuilder) Free 

func (pb *Packbuilder) Free()

func (*Packbuilder) Insert 

func (pb *Packbuilder) Insert(id *Oid, name string) error

func (*Packbuilder) InsertCommit 

func (pb *Packbuilder) InsertCommit(id *Oid) error

func (*Packbuilder) InsertTree 

func (pb *Packbuilder) InsertTree(id *Oid) error

func (*Packbuilder) InsertWalk 

func (pb *Packbuilder) InsertWalk(walk *RevWalk) error

func (*Packbuilder) ObjectCount 

func (pb *Packbuilder) ObjectCount() uint32

func (*Packbuilder) Write 

func (pb *Packbuilder) Write(w io.Writer) error

func (*Packbuilder) WriteToFile 

func (pb *Packbuilder) WriteToFile(name string, mode os.FileMode) error

func (*Packbuilder) Written 

func (pb *Packbuilder) Written() uint32

type PackbuilderForeachCallback 

type PackbuilderForeachCallback func([]byte) error

type PackbuilderProgressCallback 

type PackbuilderProgressCallback func(stage int32, current, total uint32) ErrorCode

type Patch 

type Patch struct {
	// contains filtered or unexported fields
}

func (*Patch) Free 

func (patch *Patch) Free() error

func (*Patch) String 

func (patch *Patch) String() (string, error)

type ProxyOptions 

type ProxyOptions struct {
	// The type of proxy to use (or none)
	Type ProxyType

	// The proxy's URL
	Url string
}

type ProxyType 

type ProxyType uint
const (
	// Do not attempt to connect through a proxy
	//
	// If built against lbicurl, it itself may attempt to connect
	// to a proxy if the environment variables specify it.
	ProxyTypeNone ProxyType = C.GIT_PROXY_NONE

	// Try to auto-detect the proxy from the git configuration.
	ProxyTypeAuto ProxyType = C.GIT_PROXY_AUTO

	// Connect via the URL given in the options
	ProxyTypeSpecified ProxyType = C.GIT_PROXY_SPECIFIED
)

type PushOptions 

type PushOptions struct {
	// Callbacks to use for this push operation
	RemoteCallbacks RemoteCallbacks

	PbParallelism uint

	// Headers are extra headers for the push operation.
	Headers []string

	// Proxy options to use for this push operation
	ProxyOptions ProxyOptions
}

type PushTransferProgressCallback 

type PushTransferProgressCallback func(current, total uint32, bytes uint) ErrorCode

type PushUpdateReferenceCallback 

type PushUpdateReferenceCallback func(refname, status string) ErrorCode

type Rebase 

type Rebase struct {
	// contains filtered or unexported fields
}

Rebase is the struct representing a Rebase object.

func (*Rebase) Abort 

func (rebase *Rebase) Abort() error

Abort aborts a rebase that is currently in progress, resetting the repository and working directory to their state before rebase began.

func (*Rebase) Commit 

func (rebase *Rebase) Commit(ID *Oid, author, committer *Signature, message string) error

Commit commits the current patch. You must have resolved any conflicts that were introduced during the patch application from the Next() invocation.

func (*Rebase) CurrentOperationIndex 

func (rebase *Rebase) CurrentOperationIndex() (uint, error)

CurrentOperationIndex gets the index of the rebase operation that is currently being applied. There is also an error returned for API compatibility.

func (*Rebase) Finish 

func (rebase *Rebase) Finish() error

Finish finishes a rebase that is currently in progress once all patches have been applied.

func (*Rebase) Free 

func (r *Rebase) Free()

Free frees the Rebase object.

func (*Rebase) InmemoryIndex 

func (rebase *Rebase) InmemoryIndex() (*Index, error)

InmemoryIndex gets the index produced by the last operation, which is the result of `Next()` and which will be committed by the next invocation of `Commit()`. This is useful for resolving conflicts in an in-memory rebase before committing them.

This is only applicable for in-memory rebases; for rebases within a working directory, the changes were applied to the repository's index.

func (*Rebase) Next 

func (rebase *Rebase) Next() (*RebaseOperation, error)

Next performs the next rebase operation and returns the information about it. If the operation is one that applies a patch (which is any operation except RebaseOperationExec) then the patch will be applied and the index and working directory will be updated with the changes. If there are conflicts, you will need to address those before committing the changes.

func (*Rebase) OperationAt 

func (rebase *Rebase) OperationAt(index uint) *RebaseOperation

OperationAt gets the rebase operation specified by the given index.

func (*Rebase) OperationCount 

func (rebase *Rebase) OperationCount() uint

OperationCount gets the count of rebase operations that are to be applied.

type RebaseOperation 

type RebaseOperation struct {
	Type RebaseOperationType
	Id   *Oid
	Exec string
}

RebaseOperation describes a single instruction/operation to be performed during the rebase.

type RebaseOperationType 

type RebaseOperationType uint

RebaseOperationType is the type of rebase operation 

const (
	// RebaseOperationPick The given commit is to be cherry-picked.  The client should commit the changes and continue if there are no conflicts.
	RebaseOperationPick RebaseOperationType = C.GIT_REBASE_OPERATION_PICK
	// RebaseOperationReword The given commit is to be cherry-picked, but the client should prompt the user to provide an updated commit message.
	RebaseOperationReword RebaseOperationType = C.GIT_REBASE_OPERATION_REWORD
	// RebaseOperationEdit The given commit is to be cherry-picked, but the client should stop to allow the user to edit the changes before committing them.
	RebaseOperationEdit RebaseOperationType = C.GIT_REBASE_OPERATION_EDIT
	// RebaseOperationSquash The given commit is to be squashed into the previous commit.  The commit message will be merged with the previous message.
	RebaseOperationSquash RebaseOperationType = C.GIT_REBASE_OPERATION_SQUASH
	// RebaseOperationFixup No commit will be cherry-picked.  The client should run the given command and (if successful) continue.
	RebaseOperationFixup RebaseOperationType = C.GIT_REBASE_OPERATION_FIXUP
	// RebaseOperationExec No commit will be cherry-picked.  The client should run the given command and (if successful) continue.
	RebaseOperationExec RebaseOperationType = C.GIT_REBASE_OPERATION_EXEC
)

func (RebaseOperationType) String 

func (t RebaseOperationType) String() string

type RebaseOptions 

type RebaseOptions struct {
	Version               uint
	Quiet                 int
	InMemory              int
	RewriteNotesRef       string
	MergeOptions          MergeOptions
	CheckoutOptions       CheckoutOptions
	CommitSigningCallback CommitSigningCallback
}

RebaseOptions are used to tell the rebase machinery how to operate

func DefaultRebaseOptions 

func DefaultRebaseOptions() (RebaseOptions, error)

DefaultRebaseOptions returns a RebaseOptions with default values.

type Refdb 

type Refdb struct {
	// contains filtered or unexported fields
}

func (*Refdb) Free 

func (v *Refdb) Free()

func (*Refdb) SetBackend 

func (v *Refdb) SetBackend(backend *RefdbBackend) (err error)

type RefdbBackend 

type RefdbBackend struct {
	// contains filtered or unexported fields
}

func NewRefdbBackendFromC 

func NewRefdbBackendFromC(ptr unsafe.Pointer) (backend *RefdbBackend)

func (*RefdbBackend) Free 

func (v *RefdbBackend) Free()

type Reference 

type Reference struct {
	// contains filtered or unexported fields
}

func (*Reference) Branch 

func (r *Reference) Branch() *Branch

func (*Reference) Cmp 

func (v *Reference) Cmp(ref2 *Reference) int

Cmp compares v to ref2. It returns 0 on equality, otherwise a stable sorting.

func (*Reference) Delete 

func (v *Reference) Delete() error

func (*Reference) Free 

func (v *Reference) Free()

func (*Reference) IsBranch 

func (v *Reference) IsBranch() bool

func (*Reference) IsNote 

func (v *Reference) IsNote() bool

IsNote checks if the reference is a note.

func (*Reference) IsRemote 

func (v *Reference) IsRemote() bool

func (*Reference) IsTag 

func (v *Reference) IsTag() bool

func (*Reference) Name 

func (v *Reference) Name() string

Name returns the full name of v.

func (*Reference) Owner 

func (v *Reference) Owner() *Repository

Owner returns a weak reference to the repository which owns this reference. This won't keep the underlying repository alive, but it should still be Freed.

func (*Reference) Peel 

func (v *Reference) Peel(t ObjectType) (*Object, error)

func (*Reference) Rename 

func (v *Reference) Rename(name string, force bool, msg string) (*Reference, error)

func (*Reference) Resolve 

func (v *Reference) Resolve() (*Reference, error)

func (*Reference) SetSymbolicTarget 

func (v *Reference) SetSymbolicTarget(target string, msg string) (*Reference, error)

func (*Reference) SetTarget 

func (v *Reference) SetTarget(target *Oid, msg string) (*Reference, error)

func (*Reference) Shorthand 

func (v *Reference) Shorthand() string

Shorthand returns a "human-readable" short reference name.

func (*Reference) SymbolicTarget 

func (v *Reference) SymbolicTarget() string

func (*Reference) Target 

func (v *Reference) Target() *Oid

func (*Reference) Type 

func (v *Reference) Type() ReferenceType

type ReferenceCollection 

type ReferenceCollection struct {
	// contains filtered or unexported fields
}

func (*ReferenceCollection) Create 

func (c *ReferenceCollection) Create(name string, id *Oid, force bool, msg string) (*Reference, error)

func (*ReferenceCollection) CreateSymbolic 

func (c *ReferenceCollection) CreateSymbolic(name, target string, force bool, msg string) (*Reference, error)

func (*ReferenceCollection) Dwim 

func (c *ReferenceCollection) Dwim(name string) (*Reference, error)

Dwim looks up a reference by DWIMing its short name

func (*ReferenceCollection) EnsureLog 

func (c *ReferenceCollection) EnsureLog(name string) error

EnsureLog ensures that there is a reflog for the given reference name and creates an empty one if necessary.

func (*ReferenceCollection) HasLog 

func (c *ReferenceCollection) HasLog(name string) (bool, error)

HasLog returns whether there is a reflog for the given reference name

func (*ReferenceCollection) Lookup 

func (c *ReferenceCollection) Lookup(name string) (*Reference, error)

type ReferenceFormat 

type ReferenceFormat uint
const (
	ReferenceFormatNormal           ReferenceFormat = C.GIT_REFERENCE_FORMAT_NORMAL
	ReferenceFormatAllowOnelevel    ReferenceFormat = C.GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL
	ReferenceFormatRefspecPattern   ReferenceFormat = C.GIT_REFERENCE_FORMAT_REFSPEC_PATTERN
	ReferenceFormatRefspecShorthand ReferenceFormat = C.GIT_REFERENCE_FORMAT_REFSPEC_SHORTHAND
)

type ReferenceIterator 

type ReferenceIterator struct {
	// contains filtered or unexported fields
}

func (*ReferenceIterator) Free 

func (v *ReferenceIterator) Free()

Free the reference iterator

func (*ReferenceIterator) Names 

func (i *ReferenceIterator) Names() *ReferenceNameIterator

func (*ReferenceIterator) Next 

func (v *ReferenceIterator) Next() (*Reference, error)

Next retrieves the next reference. If the iterationis over, the returned error code is git.ErrorCodeIterOver

type ReferenceNameIterator 

type ReferenceNameIterator struct {
	*ReferenceIterator
	// contains filtered or unexported fields
}

func (*ReferenceNameIterator) Next 

func (v *ReferenceNameIterator) Next() (string, error)

NextName retrieves the next reference name. If the iteration is over, the returned error code is git.ErrorCodeIterOver

type ReferenceType 

type ReferenceType int
const (
	ReferenceSymbolic ReferenceType = C.GIT_REF_SYMBOLIC
	ReferenceOid      ReferenceType = C.GIT_REF_OID
)

type Refspec 

type Refspec struct {
	// contains filtered or unexported fields
}

func ParseRefspec 

func ParseRefspec(input string, isFetch bool) (*Refspec, error)

ParseRefspec parses a given refspec string

func (*Refspec) Direction 

func (s *Refspec) Direction() ConnectDirection

Direction returns the refspec's direction

func (*Refspec) Dst 

func (s *Refspec) Dst() string

Dst returns the refspec's destination specifier

func (*Refspec) DstMatches 

func (s *Refspec) DstMatches(refname string) bool

SrcMatches checks if a refspec's destination descriptor matches a reference

func (*Refspec) Force 

func (s *Refspec) Force() bool

Force returns the refspec's force-update setting

func (*Refspec) Free 

func (s *Refspec) Free()

Free releases a refspec object which has been created by ParseRefspec

func (*Refspec) Rtransform 

func (s *Refspec) Rtransform(refname string) (string, error)

Rtransform converts a target reference to its source reference following the refspec's rules

func (*Refspec) Src 

func (s *Refspec) Src() string

Src returns the refspec's source specifier

func (*Refspec) SrcMatches 

func (s *Refspec) SrcMatches(refname string) bool

SrcMatches checks if a refspec's source descriptor matches a reference

func (*Refspec) String 

func (s *Refspec) String() string

String returns the refspec's string representation

func (*Refspec) Transform 

func (s *Refspec) Transform(refname string) (string, error)

Transform a reference to its target following the refspec's rules

type RegisteredSmartTransport 

type RegisteredSmartTransport struct {
	// contains filtered or unexported fields
}

RegisteredSmartTransport represents a transport that has been registered.

func NewRegisteredSmartTransport 

func NewRegisteredSmartTransport(
	name string,
	stateless bool,
	callback SmartSubtransportCallback,
) (*RegisteredSmartTransport, error)

NewRegisteredSmartTransport adds a custom transport definition, to be used in addition to the built-in set of transports that come with libgit2.

func RegisterManagedHTTPTransport 

func RegisterManagedHTTPTransport(protocol string) (*RegisteredSmartTransport, error)

RegisterManagedHTTPTransport registers a Go-native implementation of an HTTP/S transport that doesn't rely on any system libraries (e.g. libopenssl/libmbedtls).

If Shutdown or ReInit are called, make sure that the smart transports are freed before it.

func RegisterManagedSSHTransport 

func RegisterManagedSSHTransport(protocol string) (*RegisteredSmartTransport, error)

RegisterManagedSSHTransport registers a Go-native implementation of an SSH transport that doesn't rely on any system libraries (e.g. libssh2).

If Shutdown or ReInit are called, make sure that the smart transports are freed before it.

func (*RegisteredSmartTransport) Free 

func (t *RegisteredSmartTransport) Free() error

Free releases all resources used by the RegisteredSmartTransport and unregisters the custom transport definition referenced by it.

type Remote 

type Remote struct {
	// contains filtered or unexported fields
}

func (*Remote) Connect 

func (o *Remote) Connect(direction ConnectDirection, callbacks *RemoteCallbacks, proxyOpts *ProxyOptions, headers []string) error

Connect opens a connection to a remote.

The transport is selected based on the URL. The direction argument is due to a limitation of the git protocol (over TCP or SSH) which starts up a specific binary which can only do the one or the other.

'headers' are extra HTTP headers to use in this connection.

func (*Remote) ConnectFetch 

func (o *Remote) ConnectFetch(callbacks *RemoteCallbacks, proxyOpts *ProxyOptions, headers []string) error

func (*Remote) ConnectPush 

func (o *Remote) ConnectPush(callbacks *RemoteCallbacks, proxyOpts *ProxyOptions, headers []string) error

func (*Remote) Disconnect 

func (o *Remote) Disconnect()

func (*Remote) Fetch 

func (o *Remote) Fetch(refspecs []string, opts *FetchOptions, msg string) error

Fetch performs a fetch operation. refspecs specifies which refspecs to use for this fetch, use an empty list to use the refspecs from the configuration; msg specifies what to use for the reflog entries. Leave "" to use defaults.

func (*Remote) FetchRefspecs 

func (o *Remote) FetchRefspecs() ([]string, error)

func (*Remote) Free 

func (r *Remote) Free()

Free releases the resources of the Remote.

func (*Remote) Ls 

func (o *Remote) Ls(filterRefs ...string) ([]RemoteHead, error)

func (*Remote) Name 

func (o *Remote) Name() string

func (*Remote) Prune 

func (o *Remote) Prune(callbacks *RemoteCallbacks) error

func (*Remote) PruneRefs 

func (o *Remote) PruneRefs() bool

func (*Remote) Push 

func (o *Remote) Push(refspecs []string, opts *PushOptions) error

func (*Remote) PushRefspecs 

func (o *Remote) PushRefspecs() ([]string, error)

func (*Remote) PushUrl 

func (o *Remote) PushUrl() string

func (*Remote) RefspecCount 

func (o *Remote) RefspecCount() uint

func (*Remote) Url 

func (o *Remote) Url() string

type RemoteCallbacks 

type RemoteCallbacks struct {
	SidebandProgressCallback TransportMessageCallback
	CompletionCallback
	CredentialsCallback
	TransferProgressCallback
	UpdateTipsCallback
	CertificateCheckCallback
	PackProgressCallback PackbuilderProgressCallback
	PushTransferProgressCallback
	PushUpdateReferenceCallback
}

type RemoteCollection 

type RemoteCollection struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func (*RemoteCollection) AddFetch 

func (c *RemoteCollection) AddFetch(remote, refspec string) error

func (*RemoteCollection) AddPush 

func (c *RemoteCollection) AddPush(remote, refspec string) error

func (*RemoteCollection) Create 

func (c *RemoteCollection) Create(name string, url string) (*Remote, error)

func (*RemoteCollection) CreateAnonymous 

func (c *RemoteCollection) CreateAnonymous(url string) (*Remote, error)

func (*RemoteCollection) CreateWithFetchspec 

func (c *RemoteCollection) CreateWithFetchspec(name string, url string, fetch string) (*Remote, error)

func (*RemoteCollection) CreateWithOptions 

func (c *RemoteCollection) CreateWithOptions(url string, option *RemoteCreateOptions) (*Remote, error)

CreateWithOptions Creates a repository object with extended options.

func (*RemoteCollection) Delete 

func (c *RemoteCollection) Delete(name string) error

func (*RemoteCollection) Free 

func (c *RemoteCollection) Free()

func (*RemoteCollection) List 

func (c *RemoteCollection) List() ([]string, error)

func (*RemoteCollection) Lookup 

func (c *RemoteCollection) Lookup(name string) (*Remote, error)

func (*RemoteCollection) Rename 

func (c *RemoteCollection) Rename(remote, newname string) ([]string, error)

func (*RemoteCollection) SetPushUrl 

func (c *RemoteCollection) SetPushUrl(remote, url string) error

func (*RemoteCollection) SetUrl 

func (c *RemoteCollection) SetUrl(remote, url string) error

type RemoteCompletion 

type RemoteCompletion uint

type RemoteCreateCallback 

type RemoteCreateCallback func(repo *Repository, name, url string) (*Remote, ErrorCode)

type RemoteCreateOptions 

type RemoteCreateOptions struct {
	Name      string
	FetchSpec string
	Flags     RemoteCreateOptionsFlag
}

RemoteCreateOptions contains options for creating a remote

func DefaultRemoteCreateOptions 

func DefaultRemoteCreateOptions() (*RemoteCreateOptions, error)

DefaultApplyOptions returns default options for remote create

type RemoteCreateOptionsFlag 

type RemoteCreateOptionsFlag uint

RemoteCreateOptionsFlag is Remote creation options flags 

const (
	// Ignore the repository apply.insteadOf configuration
	RemoteCreateSkipInsteadof RemoteCreateOptionsFlag = C.GIT_REMOTE_CREATE_SKIP_INSTEADOF
	// Don't build a fetchspec from the name if none is set
	RemoteCreateSkipDefaultFetchspec RemoteCreateOptionsFlag = C.GIT_REMOTE_CREATE_SKIP_DEFAULT_FETCHSPEC
)

type RemoteHead 

type RemoteHead struct {
	Id   *Oid
	Name string
}

type Repository 

type Repository struct {

	// Remotes represents the collection of remotes and can be
	// used to add, remove and configure remotes for this
	// repository.
	Remotes RemoteCollection
	// Submodules represents the collection of submodules and can
	// be used to add, remove and configure submodules in this
	// repository.
	Submodules SubmoduleCollection
	// References represents the collection of references and can
	// be used to create, remove or update references for this repository.
	References ReferenceCollection
	// Notes represents the collection of notes and can be used to
	// read, write and delete notes from this repository.
	Notes NoteCollection
	// Tags represents the collection of tags and can be used to create,
	// list, iterate and remove tags in this repository.
	Tags TagsCollection
	// Stashes represents the collection of stashes and can be used to
	// save, apply and iterate over stash states in this repository.
	Stashes StashCollection
	// contains filtered or unexported fields
}

Repository

func Clone 

func Clone(url string, path string, options *CloneOptions) (*Repository, error)

func InitRepository 

func InitRepository(path string, isbare bool) (*Repository, error)

func NewRepositoryWrapOdb 

func NewRepositoryWrapOdb(odb *Odb) (repo *Repository, err error)

func OpenRepository 

func OpenRepository(path string) (*Repository, error)

func OpenRepositoryExtended 

func OpenRepositoryExtended(path string, flags RepositoryOpenFlag, ceiling string) (*Repository, error)

func (*Repository) AddGitIgnoreRules 

func (r *Repository) AddGitIgnoreRules(rules string) error

func (*Repository) AddIgnoreRule 

func (v *Repository) AddIgnoreRule(rules string) error

func (*Repository) AheadBehind 

func (repo *Repository) AheadBehind(local, upstream *Oid) (ahead, behind int, err error)

func (*Repository) AnnotatedCommitFromFetchHead 

func (r *Repository) AnnotatedCommitFromFetchHead(branchName string, remoteURL string, oid *Oid) (*AnnotatedCommit, error)

func (*Repository) AnnotatedCommitFromRef 

func (r *Repository) AnnotatedCommitFromRef(ref *Reference) (*AnnotatedCommit, error)

func (*Repository) AnnotatedCommitFromRevspec 

func (r *Repository) AnnotatedCommitFromRevspec(spec string) (*AnnotatedCommit, error)

func (*Repository) ApplyDiff 

func (v *Repository) ApplyDiff(diff *Diff, location ApplyLocation, opts *ApplyOptions) error

ApplyDiff appllies a Diff to the given repository, making changes directly in the working directory, the index, or both.

func (*Repository) ApplyToTree 

func (v *Repository) ApplyToTree(diff *Diff, tree *Tree, opts *ApplyOptions) (*Index, error)

ApplyToTree applies a Diff to a Tree and returns the resulting image as an Index.

func (*Repository) BlameFile 

func (v *Repository) BlameFile(path string, opts *BlameOptions) (*Blame, error)

func (*Repository) CheckoutHead 

func (v *Repository) CheckoutHead(opts *CheckoutOptions) error

Updates files in the index and the working tree to match the content of the commit pointed at by HEAD. opts may be nil.

func (*Repository) CheckoutIndex 

func (v *Repository) CheckoutIndex(index *Index, opts *CheckoutOptions) error

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 (*Repository) CheckoutTree 

func (v *Repository) CheckoutTree(tree *Tree, opts *CheckoutOptions) error

func (*Repository) Cherrypick 

func (v *Repository) Cherrypick(commit *Commit, opts CherrypickOptions) error

func (*Repository) CherrypickCommit 

func (r *Repository) CherrypickCommit(pick, our *Commit, opts CherrypickOptions) (*Index, error)

func (*Repository) ClearGitIgnoreRules 

func (r *Repository) ClearGitIgnoreRules() error

func (*Repository) ClearInternalIgnoreRules 

func (v *Repository) ClearInternalIgnoreRules() error

func (*Repository) Config 

func (v *Repository) Config() (*Config, error)

func (*Repository) CreateBlobFromBuffer 

func (repo *Repository) CreateBlobFromBuffer(data []byte) (*Oid, error)

func (*Repository) CreateBranch 

func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool) (*Branch, error)

func (*Repository) CreateCommit 

func (v *Repository) CreateCommit(
	refname string, author, committer *Signature,
	message string, tree *Tree, parents ...*Commit) (*Oid, error)

func (*Repository) CreateCommitBuffer 

func (v *Repository) CreateCommitBuffer(
	author, committer *Signature,
	messageEncoding MessageEncoding,
	message string,
	tree *Tree,
	parents ...*Commit,
) ([]byte, error)

CreateCommitBuffer creates a commit and write it into a buffer.

func (*Repository) CreateCommitFromIds 

func (v *Repository) CreateCommitFromIds(
	refname string, author, committer *Signature,
	message string, tree *Oid, parents ...*Oid) (*Oid, error)

func (*Repository) CreateCommitWithSignature 

func (v *Repository) CreateCommitWithSignature(
	commitContent, signature, signatureField string,
) (*Oid, error)

CreateCommitWithSignature creates a commit object from the given contents and signature.

func (*Repository) CreateFromStream 

func (repo *Repository) CreateFromStream(hintPath string) (*BlobWriteStream, error)

func (*Repository) DefaultSignature 

func (repo *Repository) DefaultSignature() (*Signature, error)

func (*Repository) DescendantOf 

func (repo *Repository) DescendantOf(commit, ancestor *Oid) (bool, error)

func (*Repository) DescribeWorkdir 

func (repo *Repository) DescribeWorkdir(opts *DescribeOptions) (*DescribeResult, error)

DescribeWorkdir describes the working tree. It means describe HEAD and appends <mark> (-dirty by default) if the working tree is dirty.

func (*Repository) DiffIndexToWorkdir 

func (v *Repository) DiffIndexToWorkdir(index *Index, opts *DiffOptions) (*Diff, error)

func (*Repository) DiffTreeToIndex 

func (v *Repository) DiffTreeToIndex(oldTree *Tree, index *Index, opts *DiffOptions) (*Diff, error)

func (*Repository) DiffTreeToTree 

func (v *Repository) DiffTreeToTree(oldTree, newTree *Tree, opts *DiffOptions) (*Diff, error)

func (*Repository) DiffTreeToWorkdir 

func (v *Repository) DiffTreeToWorkdir(oldTree *Tree, opts *DiffOptions) (*Diff, error)

func (*Repository) DiffTreeToWorkdirWithIndex 

func (v *Repository) DiffTreeToWorkdirWithIndex(oldTree *Tree, opts *DiffOptions) (*Diff, error)

func (*Repository) Free 

func (v *Repository) Free()

func (*Repository) Head 

func (v *Repository) Head() (*Reference, error)

func (*Repository) Index 

func (v *Repository) Index() (*Index, error)

func (*Repository) InitRebase 

func (r *Repository) InitRebase(branch *AnnotatedCommit, upstream *AnnotatedCommit, onto *AnnotatedCommit, opts *RebaseOptions) (*Rebase, error)

InitRebase initializes a rebase operation to rebase the changes in branch relative to upstream onto another branch.

func (*Repository) IsBare 

func (repo *Repository) IsBare() bool

func (*Repository) IsEmpty 

func (v *Repository) IsEmpty() (bool, error)

func (*Repository) IsHeadDetached 

func (v *Repository) IsHeadDetached() (bool, error)

func (*Repository) IsHeadUnborn 

func (v *Repository) IsHeadUnborn() (bool, error)

func (*Repository) IsPathIgnored 

func (v *Repository) IsPathIgnored(path string) (bool, error)

func (*Repository) IsShallow 

func (v *Repository) IsShallow() (bool, error)

func (*Repository) ItemPath 

func (r *Repository) ItemPath(item RepositoryItem) (string, error)

func (*Repository) Lookup 

func (v *Repository) Lookup(id *Oid) (*Object, error)

func (*Repository) LookupAnnotatedCommit 

func (r *Repository) LookupAnnotatedCommit(oid *Oid) (*AnnotatedCommit, error)

func (*Repository) LookupBlob 

func (v *Repository) LookupBlob(id *Oid) (*Blob, error)

func (*Repository) LookupBranch 

func (repo *Repository) LookupBranch(branchName string, bt BranchType) (*Branch, error)

func (*Repository) LookupCommit 

func (v *Repository) LookupCommit(id *Oid) (*Commit, error)

func (*Repository) LookupPrefix 

func (v *Repository) LookupPrefix(id *Oid, prefix uint) (*Object, error)

LookupPrefix looks up an object by its OID given a prefix of its identifier.

func (*Repository) LookupPrefixBlob 

func (v *Repository) LookupPrefixBlob(id *Oid, prefix uint) (*Blob, error)

LookupPrefixBlob looks up a blob by its OID given a prefix of its identifier.

func (*Repository) LookupPrefixCommit 

func (v *Repository) LookupPrefixCommit(id *Oid, prefix uint) (*Commit, error)

LookupPrefixCommit looks up a commit by its OID given a prefix of its identifier.

func (*Repository) LookupPrefixTag 

func (v *Repository) LookupPrefixTag(id *Oid, prefix uint) (*Tag, error)

LookupPrefixTag looks up a tag by its OID given a prefix of its identifier.

func (*Repository) LookupPrefixTree 

func (v *Repository) LookupPrefixTree(id *Oid, prefix uint) (*Tree, error)

LookupPrefixTree looks up a tree by its OID given a prefix of its identifier.

func (*Repository) LookupTag 

func (v *Repository) LookupTag(id *Oid) (*Tag, error)

func (*Repository) LookupTree 

func (v *Repository) LookupTree(id *Oid) (*Tree, error)

func (*Repository) Merge 

func (r *Repository) Merge(theirHeads []*AnnotatedCommit, mergeOptions *MergeOptions, checkoutOptions *CheckoutOptions) error

func (*Repository) MergeAnalysis 

func (r *Repository) MergeAnalysis(theirHeads []*AnnotatedCommit) (MergeAnalysis, MergePreference, error)

MergeAnalysis returns the possible actions which could be taken by a 'git-merge' command. There may be multiple answers, so the first return value is a bitmask of MergeAnalysis values.

func (*Repository) MergeBase 

func (r *Repository) MergeBase(one *Oid, two *Oid) (*Oid, error)

func (*Repository) MergeBaseMany 

func (r *Repository) MergeBaseMany(oids []*Oid) (*Oid, error)

MergeBaseMany finds a merge base given a list of commits.

func (*Repository) MergeBaseOctopus 

func (r *Repository) MergeBaseOctopus(oids []*Oid) (*Oid, error)

MergeBaseOctopus finds a merge base in preparation for an octopus merge.

func (*Repository) MergeBases 

func (r *Repository) MergeBases(one, two *Oid) ([]*Oid, error)

MergeBases retrieves the list of merge bases between two commits.

If none are found, an empty slice is returned and the error is set approprately

func (*Repository) MergeBasesMany 

func (r *Repository) MergeBasesMany(oids []*Oid) ([]*Oid, error)

MergeBasesMany finds all merge bases given a list of commits.

func (*Repository) MergeCommits 

func (r *Repository) MergeCommits(ours *Commit, theirs *Commit, options *MergeOptions) (*Index, error)

func (*Repository) MergeTrees 

func (r *Repository) MergeTrees(ancestor *Tree, ours *Tree, theirs *Tree, options *MergeOptions) (*Index, error)

func (*Repository) Message 

func (r *Repository) Message() (string, error)

Message retrieves git's prepared message. Operations such as git revert/cherry-pick/merge with the -n option stop just short of creating a commit with the changes and save their prepared message in .git/MERGE_MSG so the next git-commit execution can present it to the user for them to amend if they wish.

Use this function to get the contents of this file. Don't forget to remove the file after you create the commit.

func (*Repository) NewBranchIterator 

func (repo *Repository) NewBranchIterator(flags BranchType) (*BranchIterator, error)

func (*Repository) NewNoteIterator 

func (repo *Repository) NewNoteIterator(ref string) (*NoteIterator, error)

NewNoteIterator creates a new iterator for notes

func (*Repository) NewPackbuilder 

func (repo *Repository) NewPackbuilder() (*Packbuilder, error)

func (*Repository) NewRefdb 

func (v *Repository) NewRefdb() (refdb *Refdb, err error)

func (*Repository) NewReferenceIterator 

func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error)

NewReferenceIterator creates a new iterator over reference names

func (*Repository) NewReferenceIteratorGlob 

func (repo *Repository) NewReferenceIteratorGlob(glob string) (*ReferenceIterator, error)

NewReferenceIteratorGlob creates an iterator over reference names that match the speicified glob. The glob is of the usual fnmatch type.

func (*Repository) NewReferenceNameIterator 

func (repo *Repository) NewReferenceNameIterator() (*ReferenceNameIterator, error)

NewReferenceIterator creates a new branch iterator over reference names

func (*Repository) Odb 

func (v *Repository) Odb() (odb *Odb, err error)

func (*Repository) OpenRebase 

func (r *Repository) OpenRebase(opts *RebaseOptions) (*Rebase, error)

OpenRebase opens an existing rebase that was previously started by either an invocation of InitRebase or by another client.

func (*Repository) PatchFromBuffers 

func (v *Repository) PatchFromBuffers(oldPath, newPath string, oldBuf, newBuf []byte, opts *DiffOptions) (*Patch, error)

func (*Repository) Path 

func (repo *Repository) Path() string

func (*Repository) RemoteName 

func (repo *Repository) RemoteName(canonicalBranchName string) (string, error)

func (*Repository) RemoveMessage 

func (r *Repository) RemoveMessage() error

RemoveMessage removes git's prepared message.

func (*Repository) ResetDefaultToCommit 

func (r *Repository) ResetDefaultToCommit(commit *Commit, pathspecs []string) error

func (*Repository) ResetToCommit 

func (r *Repository) ResetToCommit(commit *Commit, resetType ResetType, opts *CheckoutOptions) error

func (*Repository) Revert 

func (r *Repository) Revert(commit *Commit, revertOptions *RevertOptions) error

Revert the provided commit leaving the index updated with the results of the revert

func (*Repository) RevertCommit 

func (r *Repository) RevertCommit(revertCommit *Commit, ourCommit *Commit, mainline uint, mergeOptions *MergeOptions) (*Index, error)

RevertCommit reverts the provided commit against "ourCommit" The returned index contains the result of the revert and should be freed

func (*Repository) Revparse 

func (r *Repository) Revparse(spec string) (*Revspec, error)

func (*Repository) RevparseExt 

func (r *Repository) RevparseExt(spec string) (*Object, *Reference, error)

func (*Repository) RevparseSingle 

func (v *Repository) RevparseSingle(spec string) (*Object, error)

func (*Repository) SetConfig 

func (v *Repository) SetConfig(c *Config) error

SetConfig sets the configuration file for this repository.

This configuration file will be used for all configuration queries involving this repository.

func (*Repository) SetHead 

func (v *Repository) SetHead(refname string) error

func (*Repository) SetHeadDetached 

func (v *Repository) SetHeadDetached(id *Oid) error

func (*Repository) SetRefdb 

func (v *Repository) SetRefdb(refdb *Refdb)

func (*Repository) SetWorkdir 

func (repo *Repository) SetWorkdir(workdir string, updateGitlink bool) error

func (*Repository) State 

func (r *Repository) State() RepositoryState

func (*Repository) StateCleanup 

func (r *Repository) StateCleanup() error

func (*Repository) StatusFile 

func (v *Repository) StatusFile(path string) (Status, error)

func (*Repository) StatusList 

func (v *Repository) StatusList(opts *StatusOptions) (*StatusList, error)

func (*Repository) TreeBuilder 

func (v *Repository) TreeBuilder() (*TreeBuilder, error)

func (*Repository) TreeBuilderFromTree 

func (v *Repository) TreeBuilderFromTree(tree *Tree) (*TreeBuilder, error)

func (*Repository) UpstreamName 

func (repo *Repository) UpstreamName(canonicalBranchName string) (string, error)

func (*Repository) Walk 

func (v *Repository) Walk() (*RevWalk, error)

func (*Repository) Workdir 

func (repo *Repository) Workdir() string

type RepositoryItem 

type RepositoryItem int
const (
	RepositoryItemGitDir     RepositoryItem = C.GIT_REPOSITORY_ITEM_GITDIR
	RepositoryItemWorkDir    RepositoryItem = C.GIT_REPOSITORY_ITEM_WORKDIR
	RepositoryItemCommonDir  RepositoryItem = C.GIT_REPOSITORY_ITEM_COMMONDIR
	RepositoryItemIndex      RepositoryItem = C.GIT_REPOSITORY_ITEM_INDEX
	RepositoryItemObjects    RepositoryItem = C.GIT_REPOSITORY_ITEM_OBJECTS
	RepositoryItemRefs       RepositoryItem = C.GIT_REPOSITORY_ITEM_REFS
	RepositoryItemPackedRefs RepositoryItem = C.GIT_REPOSITORY_ITEM_PACKED_REFS
	RepositoryItemRemotes    RepositoryItem = C.GIT_REPOSITORY_ITEM_REMOTES
	RepositoryItemConfig     RepositoryItem = C.GIT_REPOSITORY_ITEM_CONFIG
	RepositoryItemInfo       RepositoryItem = C.GIT_REPOSITORY_ITEM_INFO
	RepositoryItemHooks      RepositoryItem = C.GIT_REPOSITORY_ITEM_HOOKS
	RepositoryItemLogs       RepositoryItem = C.GIT_REPOSITORY_ITEM_LOGS
	RepositoryItemModules    RepositoryItem = C.GIT_REPOSITORY_ITEM_MODULES
	RepositoryItemWorkTrees  RepositoryItem = C.GIT_REPOSITORY_ITEM_WORKTREES
)

type RepositoryOpenFlag 

type RepositoryOpenFlag int
const (
	RepositoryOpenNoSearch RepositoryOpenFlag = C.GIT_REPOSITORY_OPEN_NO_SEARCH
	RepositoryOpenCrossFs  RepositoryOpenFlag = C.GIT_REPOSITORY_OPEN_CROSS_FS
	RepositoryOpenBare     RepositoryOpenFlag = C.GIT_REPOSITORY_OPEN_BARE
	RepositoryOpenFromEnv  RepositoryOpenFlag = C.GIT_REPOSITORY_OPEN_FROM_ENV
	RepositoryOpenNoDotGit RepositoryOpenFlag = C.GIT_REPOSITORY_OPEN_NO_DOTGIT
)

type RepositoryState 

type RepositoryState int
const (
	RepositoryStateNone                 RepositoryState = C.GIT_REPOSITORY_STATE_NONE
	RepositoryStateMerge                RepositoryState = C.GIT_REPOSITORY_STATE_MERGE
	RepositoryStateRevert               RepositoryState = C.GIT_REPOSITORY_STATE_REVERT
	RepositoryStateCherrypick           RepositoryState = C.GIT_REPOSITORY_STATE_CHERRYPICK
	RepositoryStateBisect               RepositoryState = C.GIT_REPOSITORY_STATE_BISECT
	RepositoryStateRebase               RepositoryState = C.GIT_REPOSITORY_STATE_REBASE
	RepositoryStateRebaseInteractive    RepositoryState = C.GIT_REPOSITORY_STATE_REBASE_INTERACTIVE
	RepositoryStateRebaseMerge          RepositoryState = C.GIT_REPOSITORY_STATE_REBASE_MERGE
	RepositoryStateApplyMailbox         RepositoryState = C.GIT_REPOSITORY_STATE_APPLY_MAILBOX
	RepositoryStateApplyMailboxOrRebase RepositoryState = C.GIT_REPOSITORY_STATE_APPLY_MAILBOX_OR_REBASE
)

type ResetType 

type ResetType int
const (
	ResetSoft  ResetType = C.GIT_RESET_SOFT
	ResetMixed ResetType = C.GIT_RESET_MIXED
	ResetHard  ResetType = C.GIT_RESET_HARD
)

type RevWalk 

type RevWalk struct {
	// contains filtered or unexported fields
}

func (*RevWalk) Free 

func (v *RevWalk) Free()

func (*RevWalk) Hide 

func (v *RevWalk) Hide(id *Oid) error

func (*RevWalk) HideGlob 

func (v *RevWalk) HideGlob(glob string) error

func (*RevWalk) HideHead 

func (v *RevWalk) HideHead() (err error)

func (*RevWalk) HideRef 

func (v *RevWalk) HideRef(r string) error

func (*RevWalk) Iterate 

func (v *RevWalk) Iterate(fun RevWalkIterator) (err error)

func (*RevWalk) Next 

func (v *RevWalk) Next(id *Oid) (err error)

func (*RevWalk) Push 

func (v *RevWalk) Push(id *Oid) error

func (*RevWalk) PushGlob 

func (v *RevWalk) PushGlob(glob string) error

func (*RevWalk) PushHead 

func (v *RevWalk) PushHead() (err error)

func (*RevWalk) PushRange 

func (v *RevWalk) PushRange(r string) error

func (*RevWalk) PushRef 

func (v *RevWalk) PushRef(r string) error

func (*RevWalk) Reset 

func (v *RevWalk) Reset()

func (*RevWalk) SimplifyFirstParent 

func (v *RevWalk) SimplifyFirstParent()

func (*RevWalk) Sorting 

func (v *RevWalk) Sorting(sm SortType)

type RevWalkIterator 

type RevWalkIterator func(commit *Commit) bool

type RevertOptions 

type RevertOptions struct {
	Mainline     uint
	MergeOpts    MergeOptions
	CheckoutOpts CheckoutOptions
}

RevertOptions contains options for performing a revert

func DefaultRevertOptions 

func DefaultRevertOptions() (RevertOptions, error)

DefaultRevertOptions initialises a RevertOptions struct with default values

type RevparseFlag 

type RevparseFlag int
const (
	RevparseSingle    RevparseFlag = C.GIT_REVPARSE_SINGLE
	RevparseRange     RevparseFlag = C.GIT_REVPARSE_RANGE
	RevparseMergeBase RevparseFlag = C.GIT_REVPARSE_MERGE_BASE
)

type Revspec 

type Revspec struct {
	// contains filtered or unexported fields
}

func (*Revspec) Flags 

func (rs *Revspec) Flags() RevparseFlag

func (*Revspec) From 

func (rs *Revspec) From() *Object

func (*Revspec) To 

func (rs *Revspec) To() *Object

type Signature 

type Signature struct {
	Name  string
	Email string
	When  time.Time
}

func (*Signature) Offset 

func (v *Signature) Offset() int

Offset returns the time zone offset of v.When in minutes, which is what git wants.

type SmartServiceAction 

type SmartServiceAction int

SmartServiceAction is an action that the smart transport can ask a subtransport to perform. 

const (
	// SmartServiceActionUploadpackLs is used upon connecting to a remote, and is
	// used to perform reference discovery prior to performing a pull operation.
	SmartServiceActionUploadpackLs SmartServiceAction = C.GIT_SERVICE_UPLOADPACK_LS

	// SmartServiceActionUploadpack is used when performing a pull operation.
	SmartServiceActionUploadpack SmartServiceAction = C.GIT_SERVICE_UPLOADPACK

	// SmartServiceActionReceivepackLs is used upon connecting to a remote, and is
	// used to perform reference discovery prior to performing a push operation.
	SmartServiceActionReceivepackLs SmartServiceAction = C.GIT_SERVICE_RECEIVEPACK_LS

	// SmartServiceActionReceivepack is used when performing a push operation.
	SmartServiceActionReceivepack SmartServiceAction = C.GIT_SERVICE_RECEIVEPACK
)

type SmartSubtransport 

type SmartSubtransport interface {
	// Action creates a SmartSubtransportStream for the provided url and
	// requested action.
	Action(url string, action SmartServiceAction) (SmartSubtransportStream, error)

	// Close closes the SmartSubtransport.
	//
	// Subtransports are guaranteed a call to Close between
	// calls to Action, except for the following two "natural" progressions
	// of actions against a constant URL.
	//
	// 1. UPLOADPACK_LS -> UPLOADPACK
	// 2. RECEIVEPACK_LS -> RECEIVEPACK
	Close() error

	// Free releases the resources of the SmartSubtransport.
	Free()
}

SmartSubtransport is the interface for custom subtransports which carry data for the smart transport.

type SmartSubtransportCallback 

type SmartSubtransportCallback func(remote *Remote, transport *Transport) (SmartSubtransport, error)

SmartSubtransportCallback is a function which creates a new subtransport for the smart transport.

type SmartSubtransportStream 

type SmartSubtransportStream interface {
	io.Reader
	io.Writer

	// Free releases the resources of the SmartSubtransportStream.
	Free()
}

SmartSubtransportStream is the interface for streams used by the smart transport to read and write data from a subtransport.

type SortType 

type SortType uint
const (
	SortNone        SortType = C.GIT_SORT_NONE
	SortTopological SortType = C.GIT_SORT_TOPOLOGICAL
	SortTime        SortType = C.GIT_SORT_TIME
	SortReverse     SortType = C.GIT_SORT_REVERSE
)

type StashApplyFlag 

type StashApplyFlag int

StashApplyFlag are flags that affect the stash apply operation. 

const (
	// StashApplyDefault is the default.
	StashApplyDefault StashApplyFlag = C.GIT_STASH_APPLY_DEFAULT

	// StashApplyReinstateIndex will try to reinstate not only the
	// working tree's changes, but also the index's changes.
	StashApplyReinstateIndex StashApplyFlag = C.GIT_STASH_APPLY_REINSTATE_INDEX
)

type StashApplyOptions 

type StashApplyOptions struct {
	Flags            StashApplyFlag
	CheckoutOptions  CheckoutOptions            // options to use when writing files to the working directory
	ProgressCallback StashApplyProgressCallback // optional callback to notify the consumer of application progress
}

StashApplyOptions represents options to control the apply operation.

func DefaultStashApplyOptions 

func DefaultStashApplyOptions() (StashApplyOptions, error)

DefaultStashApplyOptions initializes the structure with default values.

type StashApplyProgress 

type StashApplyProgress int

StashApplyProgress are flags describing the progress of the apply operation. 

const (
	// StashApplyProgressNone means loading the stashed data from the object store.
	StashApplyProgressNone StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_NONE

	// StashApplyProgressLoadingStash means the stored index is being analyzed.
	StashApplyProgressLoadingStash StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_LOADING_STASH

	// StashApplyProgressAnalyzeIndex means the stored index is being analyzed.
	StashApplyProgressAnalyzeIndex StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_ANALYZE_INDEX

	// StashApplyProgressAnalyzeModified means the modified files are being analyzed.
	StashApplyProgressAnalyzeModified StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_ANALYZE_MODIFIED

	// StashApplyProgressAnalyzeUntracked means the untracked and ignored files are being analyzed.
	StashApplyProgressAnalyzeUntracked StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_ANALYZE_UNTRACKED

	// StashApplyProgressCheckoutUntracked means the untracked files are being written to disk.
	StashApplyProgressCheckoutUntracked StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_CHECKOUT_UNTRACKED

	// StashApplyProgressCheckoutModified means the modified files are being written to disk.
	StashApplyProgressCheckoutModified StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_CHECKOUT_MODIFIED

	// StashApplyProgressDone means the stash was applied successfully.
	StashApplyProgressDone StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_DONE
)

type StashApplyProgressCallback 

type StashApplyProgressCallback func(progress StashApplyProgress) error

StashApplyProgressCallback is the apply operation notification callback.

type StashCallback 

type StashCallback func(index int, message string, id *Oid) error

StashCallback is called per entry when interating over all the stashed states.

'index' is the position of the current stash in the stash list, 'message' is the message used when creating the stash and 'id' is the commit id of the stash.

type StashCollection 

type StashCollection struct {
	// contains filtered or unexported fields
}

StashCollection represents the possible operations that can be performed on the collection of stashes for a repository.

func (*StashCollection) Apply 

func (c *StashCollection) Apply(index int, opts StashApplyOptions) error

Apply applies a single stashed state from the stash list.

If local changes in the working directory conflict with changes in the stash then ErrorCodeConflict will be returned. In this case, the index will always remain unmodified and all files in the working directory will remain unmodified. However, if you are restoring untracked files or ignored files and there is a conflict when applying the modified files, then those files will remain in the working directory.

If passing the StashApplyReinstateIndex flag and there would be conflicts when reinstating the index, the function will return ErrorCodeConflict and both the working directory and index will be left unmodified.

Note that a minimum checkout strategy of 'CheckoutSafe' is implied.

'index' is the position within the stash list. 0 points to the most recent stashed state.

Returns error code ErrorCodeNotFound if there's no stashed state for the given index, error code ErrorCodeConflict if local changes in the working directory conflict with changes in the stash, the user returned error from the StashApplyProgressCallback, if any, or other error code.

Error codes can be interogated with IsErrorCode(err, ErrorCodeNotFound).

func (*StashCollection) Drop 

func (c *StashCollection) Drop(index int) error

Drop removes a single stashed state from the stash list.

'index' is the position within the stash list. 0 points to the most recent stashed state.

Returns error code ErrorCodeNotFound if there's no stashed state for the given index.

func (*StashCollection) Foreach 

func (c *StashCollection) Foreach(callback StashCallback) error

Foreach loops over all the stashed states and calls the callback for each one.

If callback returns an error, this will stop looping.

func (*StashCollection) Pop 

func (c *StashCollection) Pop(index int, opts StashApplyOptions) error

Pop applies a single stashed state from the stash list and removes it from the list if successful.

'index' is the position within the stash list. 0 points to the most recent stashed state.

'opts' controls how stashes are applied.

Returns error code ErrorCodeNotFound if there's no stashed state for the given index.

func (*StashCollection) Save 

func (c *StashCollection) Save(
	stasher *Signature, message string, flags StashFlag) (*Oid, error)

Save saves the local modifications to a new stash.

Stasher is the identity of the person performing the stashing. Message is the optional description along with the stashed state. Flags control the stashing process and are given as bitwise OR.

type StashFlag 

type StashFlag int

StashFlag are flags that affect the stash save operation. 

const (
	// StashDefault represents no option, default.
	StashDefault StashFlag = C.GIT_STASH_DEFAULT

	// StashKeepIndex leaves all changes already added to the
	// index intact in the working directory.
	StashKeepIndex StashFlag = C.GIT_STASH_KEEP_INDEX

	// StashIncludeUntracked means all untracked files are also
	// stashed and then cleaned up from the working directory.
	StashIncludeUntracked StashFlag = C.GIT_STASH_INCLUDE_UNTRACKED

	// StashIncludeIgnored means all ignored files are also
	// stashed and then cleaned up from the working directory.
	StashIncludeIgnored StashFlag = C.GIT_STASH_INCLUDE_IGNORED
)

type Status 

type Status int
const (
	StatusCurrent         Status = C.GIT_STATUS_CURRENT
	StatusIndexNew        Status = C.GIT_STATUS_INDEX_NEW
	StatusIndexModified   Status = C.GIT_STATUS_INDEX_MODIFIED
	StatusIndexDeleted    Status = C.GIT_STATUS_INDEX_DELETED
	StatusIndexRenamed    Status = C.GIT_STATUS_INDEX_RENAMED
	StatusIndexTypeChange Status = C.GIT_STATUS_INDEX_TYPECHANGE
	StatusWtNew           Status = C.GIT_STATUS_WT_NEW
	StatusWtModified      Status = C.GIT_STATUS_WT_MODIFIED
	StatusWtDeleted       Status = C.GIT_STATUS_WT_DELETED
	StatusWtTypeChange    Status = C.GIT_STATUS_WT_TYPECHANGE
	StatusWtRenamed       Status = C.GIT_STATUS_WT_RENAMED
	StatusIgnored         Status = C.GIT_STATUS_IGNORED
	StatusConflicted      Status = C.GIT_STATUS_CONFLICTED
)

type StatusEntry 

type StatusEntry struct {
	Status         Status
	HeadToIndex    DiffDelta
	IndexToWorkdir DiffDelta
}

type StatusList 

type StatusList struct {
	// contains filtered or unexported fields
}

func (*StatusList) ByIndex 

func (statusList *StatusList) ByIndex(index int) (StatusEntry, error)

func (*StatusList) EntryCount 

func (statusList *StatusList) EntryCount() (int, error)

func (*StatusList) Free 

func (statusList *StatusList) Free()

type StatusOpt 

type StatusOpt int
const (
	StatusOptIncludeUntracked      StatusOpt = C.GIT_STATUS_OPT_INCLUDE_UNTRACKED
	StatusOptIncludeIgnored        StatusOpt = C.GIT_STATUS_OPT_INCLUDE_IGNORED
	StatusOptIncludeUnmodified     StatusOpt = C.GIT_STATUS_OPT_INCLUDE_UNMODIFIED
	StatusOptExcludeSubmodules     StatusOpt = C.GIT_STATUS_OPT_EXCLUDE_SUBMODULES
	StatusOptRecurseUntrackedDirs  StatusOpt = C.GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS
	StatusOptDisablePathspecMatch  StatusOpt = C.GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH
	StatusOptRecurseIgnoredDirs    StatusOpt = C.GIT_STATUS_OPT_RECURSE_IGNORED_DIRS
	StatusOptRenamesHeadToIndex    StatusOpt = C.GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX
	StatusOptRenamesIndexToWorkdir StatusOpt = C.GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR
	StatusOptSortCaseSensitively   StatusOpt = C.GIT_STATUS_OPT_SORT_CASE_SENSITIVELY
	StatusOptSortCaseInsensitively StatusOpt = C.GIT_STATUS_OPT_SORT_CASE_INSENSITIVELY
	StatusOptRenamesFromRewrites   StatusOpt = C.GIT_STATUS_OPT_RENAMES_FROM_REWRITES
	StatusOptNoRefresh             StatusOpt = C.GIT_STATUS_OPT_NO_REFRESH
	StatusOptUpdateIndex           StatusOpt = C.GIT_STATUS_OPT_UPDATE_INDEX
)

type StatusOptions 

type StatusOptions struct {
	Show     StatusShow
	Flags    StatusOpt
	Pathspec []string
}

type StatusShow 

type StatusShow int
const (
	StatusShowIndexAndWorkdir StatusShow = C.GIT_STATUS_SHOW_INDEX_AND_WORKDIR
	StatusShowIndexOnly       StatusShow = C.GIT_STATUS_SHOW_INDEX_ONLY
	StatusShowWorkdirOnly     StatusShow = C.GIT_STATUS_SHOW_WORKDIR_ONLY
)

type Submodule 

type Submodule struct {
	// contains filtered or unexported fields
}

Submodule

func (*Submodule) AddToIndex 

func (sub *Submodule) AddToIndex(write_index bool) error

func (*Submodule) FetchRecurseSubmodules 

func (sub *Submodule) FetchRecurseSubmodules() SubmoduleRecurse

func (*Submodule) FinalizeAdd 

func (sub *Submodule) FinalizeAdd() error

func (*Submodule) Free 

func (sub *Submodule) Free()

func (*Submodule) HeadId 

func (sub *Submodule) HeadId() *Oid

func (*Submodule) Ignore 

func (sub *Submodule) Ignore() SubmoduleIgnore

func (*Submodule) IndexId 

func (sub *Submodule) IndexId() *Oid

func (*Submodule) Init 

func (sub *Submodule) Init(overwrite bool) error

func (*Submodule) Name 

func (sub *Submodule) Name() string

func (*Submodule) Open 

func (sub *Submodule) Open() (*Repository, error)

func (*Submodule) Path 

func (sub *Submodule) Path() string

func (*Submodule) Sync 

func (sub *Submodule) Sync() error

func (*Submodule) Update 

func (sub *Submodule) Update(init bool, opts *SubmoduleUpdateOptions) error

func (*Submodule) UpdateStrategy 

func (sub *Submodule) UpdateStrategy() SubmoduleUpdate

func (*Submodule) Url 

func (sub *Submodule) Url() string

func (*Submodule) WdId 

func (sub *Submodule) WdId() *Oid

type SubmoduleCallback 

type SubmoduleCallback func(sub *Submodule, name string) int

SubmoduleCallback is a function that is called for every submodule found in SubmoduleCollection.Foreach.

type SubmoduleCbk deprecated 

type SubmoduleCbk = SubmoduleCallback

Deprecated: SubmoduleCbk is a deprecated alias of SubmoduleCallback.

type SubmoduleCollection 

type SubmoduleCollection struct {
	// contains filtered or unexported fields
}

func (*SubmoduleCollection) Add 

func (c *SubmoduleCollection) Add(url, path string, use_git_link bool) (*Submodule, error)

func (*SubmoduleCollection) Foreach 

func (c *SubmoduleCollection) Foreach(callback SubmoduleCallback) error

func (*SubmoduleCollection) Lookup 

func (c *SubmoduleCollection) Lookup(name string) (*Submodule, error)

func (*SubmoduleCollection) SetFetchRecurseSubmodules 

func (c *SubmoduleCollection) SetFetchRecurseSubmodules(submodule string, recurse SubmoduleRecurse) error

func (*SubmoduleCollection) SetIgnore 

func (c *SubmoduleCollection) SetIgnore(submodule string, ignore SubmoduleIgnore) error

func (*SubmoduleCollection) SetUpdate 

func (c *SubmoduleCollection) SetUpdate(submodule string, update SubmoduleUpdate) error

func (*SubmoduleCollection) SetUrl 

func (c *SubmoduleCollection) SetUrl(submodule, url string) error

type SubmoduleIgnore 

type SubmoduleIgnore int
const (
	SubmoduleIgnoreNone      SubmoduleIgnore = C.GIT_SUBMODULE_IGNORE_NONE
	SubmoduleIgnoreUntracked SubmoduleIgnore = C.GIT_SUBMODULE_IGNORE_UNTRACKED
	SubmoduleIgnoreDirty     SubmoduleIgnore = C.GIT_SUBMODULE_IGNORE_DIRTY
	SubmoduleIgnoreAll       SubmoduleIgnore = C.GIT_SUBMODULE_IGNORE_ALL
)

type SubmoduleRecurse 

type SubmoduleRecurse int
const (
	SubmoduleRecurseNo       SubmoduleRecurse = C.GIT_SUBMODULE_RECURSE_NO
	SubmoduleRecurseYes      SubmoduleRecurse = C.GIT_SUBMODULE_RECURSE_YES
	SubmoduleRecurseOndemand SubmoduleRecurse = C.GIT_SUBMODULE_RECURSE_ONDEMAND
)

type SubmoduleStatus 

type SubmoduleStatus int
const (
	SubmoduleStatusInHead          SubmoduleStatus = C.GIT_SUBMODULE_STATUS_IN_HEAD
	SubmoduleStatusInIndex         SubmoduleStatus = C.GIT_SUBMODULE_STATUS_IN_INDEX
	SubmoduleStatusInConfig        SubmoduleStatus = C.GIT_SUBMODULE_STATUS_IN_CONFIG
	SubmoduleStatusInWd            SubmoduleStatus = C.GIT_SUBMODULE_STATUS_IN_WD
	SubmoduleStatusIndexAdded      SubmoduleStatus = C.GIT_SUBMODULE_STATUS_INDEX_ADDED
	SubmoduleStatusIndexDeleted    SubmoduleStatus = C.GIT_SUBMODULE_STATUS_INDEX_DELETED
	SubmoduleStatusIndexModified   SubmoduleStatus = C.GIT_SUBMODULE_STATUS_INDEX_MODIFIED
	SubmoduleStatusWdUninitialized SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_UNINITIALIZED
	SubmoduleStatusWdAdded         SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_ADDED
	SubmoduleStatusWdDeleted       SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_DELETED
	SubmoduleStatusWdModified      SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_MODIFIED
	SubmoduleStatusWdIndexModified SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED
	SubmoduleStatusWdWdModified    SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_WD_MODIFIED
	SubmoduleStatusWdUntracked     SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_UNTRACKED
)

type SubmoduleUpdate 

type SubmoduleUpdate int
const (
	SubmoduleUpdateCheckout SubmoduleUpdate = C.GIT_SUBMODULE_UPDATE_CHECKOUT
	SubmoduleUpdateRebase   SubmoduleUpdate = C.GIT_SUBMODULE_UPDATE_REBASE
	SubmoduleUpdateMerge    SubmoduleUpdate = C.GIT_SUBMODULE_UPDATE_MERGE
	SubmoduleUpdateNone     SubmoduleUpdate = C.GIT_SUBMODULE_UPDATE_NONE
)

type SubmoduleUpdateOptions 

type SubmoduleUpdateOptions struct {
	*CheckoutOpts
	*FetchOptions
}

SubmoduleUpdateOptions

type Tag 

type Tag struct {
	Object
	// contains filtered or unexported fields
}

Tag

func (*Tag) AsObject 

func (t *Tag) AsObject() *Object

func (*Tag) Message 

func (t *Tag) Message() string

func (*Tag) Name 

func (t *Tag) Name() string

func (*Tag) Tagger 

func (t *Tag) Tagger() *Signature

func (*Tag) Target 

func (t *Tag) Target() *Object

func (*Tag) TargetId 

func (t *Tag) TargetId() *Oid

func (*Tag) TargetType 

func (t *Tag) TargetType() ObjectType

type TagForeachCallback 

type TagForeachCallback func(name string, id *Oid) error

TagForeachCallback is called for each tag in the repository.

The name is the full ref name eg: "refs/tags/v1.0.0".

Note that the callback is called for lightweight tags as well, so repo.LookupTag() will return an error for these tags. Use repo.References.Lookup() instead.

type TagsCollection 

type TagsCollection struct {
	// contains filtered or unexported fields
}

func (*TagsCollection) Create 

func (c *TagsCollection) Create(name string, obj Objecter, tagger *Signature, message string) (*Oid, error)

func (*TagsCollection) CreateLightweight 

func (c *TagsCollection) CreateLightweight(name string, obj Objecter, force bool) (*Oid, error)

CreateLightweight creates a new lightweight tag pointing to an object and returns the id of the target object.

The name of the tag is validated for consistency (see git_tag_create() for the rules https://libgit2.github.com/libgit2/#HEAD/group/tag/git_tag_create) and should not conflict with an already existing tag name.

If force is true and a reference already exists with the given name, it'll be replaced.

The created tag is a simple reference and can be queried using repo.References.Lookup("refs/tags/<name>"). The name of the tag (eg "v1.0.0") is queried with ref.Shorthand().

func (*TagsCollection) Foreach 

func (c *TagsCollection) Foreach(callback TagForeachCallback) error

Foreach calls the callback for each tag in the repository.

func (*TagsCollection) List 

func (c *TagsCollection) List() ([]string, error)

List returns the names of all the tags in the repository, eg: ["v1.0.1", "v2.0.0"].

func (*TagsCollection) ListWithMatch 

func (c *TagsCollection) ListWithMatch(pattern string) ([]string, error)

ListWithMatch returns the names of all the tags in the repository that match a given pattern.

The pattern is a standard fnmatch(3) pattern http://man7.org/linux/man-pages/man3/fnmatch.3.html

func (*TagsCollection) Remove 

func (c *TagsCollection) Remove(name string) error

type Trailer 

type Trailer struct {
	Key   string
	Value string
}

Trailer represents a single git message trailer.

func MessageTrailers 

func MessageTrailers(message string) ([]Trailer, error)

MessageTrailers parses trailers out of a message, returning a slice of Trailer structs. Trailers are key/value pairs in the last paragraph of a message, not including any patches or conflicts that may be present.

type TransferProgress 

type TransferProgress struct {
	TotalObjects    uint
	IndexedObjects  uint
	ReceivedObjects uint
	LocalObjects    uint
	TotalDeltas     uint
	ReceivedBytes   uint
}

type TransferProgressCallback 

type TransferProgressCallback func(stats TransferProgress) ErrorCode

type Transport 

type Transport struct {
	// contains filtered or unexported fields
}

Transport encapsulates a way to communicate with a Remote.

func (*Transport) SmartCertificateCheck 

func (t *Transport) SmartCertificateCheck(cert *Certificate, valid bool, hostname string) error

SmartCertificateCheck calls the certificate check for this transport.

func (*Transport) SmartCredentials 

func (t *Transport) SmartCredentials(user string, methods CredentialType) (*Credential, error)

SmartCredentials calls the credentials callback for this transport.

func (*Transport) SmartProxyOptions 

func (t *Transport) SmartProxyOptions() (*ProxyOptions, error)

SmartProxyOptions gets a copy of the proxy options for this transport.

type TransportMessageCallback 

type TransportMessageCallback func(str string) ErrorCode

type Tree 

type Tree struct {
	Object
	// contains filtered or unexported fields
}

func (*Tree) AsObject 

func (t *Tree) AsObject() *Object

func (*Tree) EntryById 

func (t *Tree) EntryById(id *Oid) *TreeEntry

EntryById performs a lookup for a tree entry with the given SHA value.

It returns a *TreeEntry that is owned by the Tree. You don't have to free it, but you must not use it after the Tree is freed.

Warning: this must examine every entry in the tree, so it is not fast.

func (*Tree) EntryByIndex 

func (t *Tree) EntryByIndex(index uint64) *TreeEntry

func (*Tree) EntryByName 

func (t *Tree) EntryByName(filename string) *TreeEntry

func (*Tree) EntryByPath 

func (t *Tree) EntryByPath(path string) (*TreeEntry, error)

EntryByPath looks up an entry by its full path, recursing into deeper trees if necessary (i.e. if there are slashes in the path)

func (*Tree) EntryCount 

func (t *Tree) EntryCount() uint64

func (*Tree) Walk 

func (t *Tree) Walk(callback TreeWalkCallback) error

type TreeBuilder 

type TreeBuilder struct {
	// contains filtered or unexported fields
}

func (*TreeBuilder) Free 

func (v *TreeBuilder) Free()

func (*TreeBuilder) Insert 

func (v *TreeBuilder) Insert(filename string, id *Oid, filemode Filemode) error

func (*TreeBuilder) Remove 

func (v *TreeBuilder) Remove(filename string) error

func (*TreeBuilder) Write 

func (v *TreeBuilder) Write() (*Oid, error)

type TreeEntry 

type TreeEntry struct {
	Name     string
	Id       *Oid
	Type     ObjectType
	Filemode Filemode
}

type TreeWalkCallback 

type TreeWalkCallback func(string, *TreeEntry) int

type UpdateTipsCallback 

type UpdateTipsCallback func(refname string, a *Oid, b *Oid) ErrorCode

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.