README

git2go

GoDoc Build Status

Go bindings for libgit2.

Which branch to use

The numbered branches work against the version of libgit2 as specified by their number. You can import them in your project via gopkg.in, e.g. if you have libgit2 v0.25 installed you'd import with

import "gopkg.in/libgit2/git2go.v25"

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

The master branch follows the tip of libgit2 itself (with some lag) and as such has no guarantees on its own API nor does it have expectations the stability of libgit2's. Thus this only supports statically linking against libgit2.

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 gopkg.in, e.g. to work against libgit2 v0.25

import "gopkg.in/libgit2/git2go.v25"
Master branch, or static linking

If using master or building a branch 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 master 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.

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 master 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

./script/build-libgit2-static.sh
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)
Expand ▾ Collapse ▴

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 (
	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
)

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 CallbackGitTreeWalk

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

        export CallbackGitTreeWalk

        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 IsErrorClass

            func IsErrorClass(err error, c ErrorClass) bool

            func IsErrorCode

            func IsErrorCode(err error, c ErrorCode) bool

            func MakeGitError

            func MakeGitError(errorCode C.int) error

            func MakeGitError2

            func MakeGitError2(err int) error

            func MwindowMappedLimit

            func MwindowMappedLimit() (int, error)

            func MwindowSize

            func MwindowSize() (int, error)

            func ReferenceIsValidName

            func ReferenceIsValidName(name string) bool

              ReferenceIsValidName ensures 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 RemoteIsValidName

              func RemoteIsValidName(name string) bool

              func SearchPath

              func SearchPath(level ConfigLevel) (string, 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 SubmoduleStatusIsUnmodified

              func SubmoduleStatusIsUnmodified(status int) bool

              func SubmoduleVisitor

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

                export SubmoduleVisitor

                Types

                type AnnotatedCommit

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

                func (*AnnotatedCommit) Free

                func (mh *AnnotatedCommit) Free()

                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

                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) Size

                func (v *Blob) Size() int64

                type BlobCallbackData

                type BlobCallbackData struct {
                	Callback BlobChunkCallback
                	Error    error
                }

                type BlobChunkCallback

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

                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
                  }

                  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 CheckoutOpts

                    type CheckoutOpts struct {
                    	Strategy         CheckoutStrategy   // Default will be a dry run
                    	DisableFilters   bool               // Don't apply filters like CRLF conversion
                    	DirMode          os.FileMode        // Default is 0755
                    	FileMode         os.FileMode        // Default is 0644 or 0755 as dictated by blob
                    	FileOpenFlags    int                // Default is O_CREAT | O_TRUNC | O_WRONLY
                    	NotifyFlags      CheckoutNotifyType // Default will be none
                    	NotifyCallback   CheckoutNotifyCallback
                    	ProgressCallback CheckoutProgressCallback
                    	TargetDirectory  string // Alternative checkout path to workdir
                    	Paths            []string
                    	Baseline         *Tree
                    }

                    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 CheckoutOpts
                    }

                    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) 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) 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) 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

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

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

                                      func NewCredDefault

                                      func NewCredDefault() (int, Cred)

                                      func NewCredSshKey

                                      func NewCredSshKey(username string, publicKeyPath string, privateKeyPath string, passphrase string) (int, Cred)

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

                                        func NewCredSshKeyFromAgent

                                        func NewCredSshKeyFromAgent(username string) (int, Cred)

                                        func NewCredSshKeyFromMemory

                                        func NewCredSshKeyFromMemory(username string, publicKey string, privateKey string, passphrase string) (int, Cred)

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

                                          func NewCredUserpassPlaintext

                                          func NewCredUserpassPlaintext(username string, password string) (int, Cred)

                                          func (*Cred) HasUsername

                                          func (o *Cred) HasUsername() bool

                                          func (*Cred) Type

                                          func (o *Cred) Type() CredType

                                          type CredType

                                          type CredType uint
                                          const (
                                          	CredTypeUserpassPlaintext CredType = C.GIT_CREDTYPE_USERPASS_PLAINTEXT
                                          	CredTypeSshKey            CredType = C.GIT_CREDTYPE_SSH_KEY
                                          	CredTypeSshCustom         CredType = C.GIT_CREDTYPE_SSH_CUSTOM
                                          	CredTypeDefault           CredType = C.GIT_CREDTYPE_DEFAULT
                                          )

                                          type CredentialsCallback

                                          type CredentialsCallback func(url string, username_from_url string, allowed_types CredType) (ErrorCode, *Cred)

                                          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
                                          )

                                          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.

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

                                                            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)

                                                            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 DiffFlag

                                                              type DiffFlag int
                                                              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(DiffDelta, float64) (DiffForEachHunkCallback, error)

                                                              type DiffForEachHunkCallback

                                                              type DiffForEachHunkCallback func(DiffHunk) (DiffForEachLineCallback, error)

                                                              type DiffForEachLineCallback

                                                              type DiffForEachLineCallback func(DiffLine) error

                                                              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

                                                              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
                                                              	DiffIgnoreWitespaceEol     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

                                                              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 (
                                                              	ErrClassNone       ErrorClass = C.GITERR_NONE
                                                              	ErrClassNoMemory   ErrorClass = C.GITERR_NOMEMORY
                                                              	ErrClassOs         ErrorClass = C.GITERR_OS
                                                              	ErrClassInvalid    ErrorClass = C.GITERR_INVALID
                                                              	ErrClassReference  ErrorClass = C.GITERR_REFERENCE
                                                              	ErrClassZlib       ErrorClass = C.GITERR_ZLIB
                                                              	ErrClassRepository ErrorClass = C.GITERR_REPOSITORY
                                                              	ErrClassConfig     ErrorClass = C.GITERR_CONFIG
                                                              	ErrClassRegex      ErrorClass = C.GITERR_REGEX
                                                              	ErrClassOdb        ErrorClass = C.GITERR_ODB
                                                              	ErrClassIndex      ErrorClass = C.GITERR_INDEX
                                                              	ErrClassObject     ErrorClass = C.GITERR_OBJECT
                                                              	ErrClassNet        ErrorClass = C.GITERR_NET
                                                              	ErrClassTag        ErrorClass = C.GITERR_TAG
                                                              	ErrClassTree       ErrorClass = C.GITERR_TREE
                                                              	ErrClassIndexer    ErrorClass = C.GITERR_INDEXER
                                                              	ErrClassSSL        ErrorClass = C.GITERR_SSL
                                                              	ErrClassSubmodule  ErrorClass = C.GITERR_SUBMODULE
                                                              	ErrClassThread     ErrorClass = C.GITERR_THREAD
                                                              	ErrClassStash      ErrorClass = C.GITERR_STASH
                                                              	ErrClassCheckout   ErrorClass = C.GITERR_CHECKOUT
                                                              	ErrClassFetchHead  ErrorClass = C.GITERR_FETCHHEAD
                                                              	ErrClassMerge      ErrorClass = C.GITERR_MERGE
                                                              	ErrClassSsh        ErrorClass = C.GITERR_SSH
                                                              	ErrClassFilter     ErrorClass = C.GITERR_FILTER
                                                              	ErrClassRevert     ErrorClass = C.GITERR_REVERT
                                                              	ErrClassCallback   ErrorClass = C.GITERR_CALLBACK
                                                              	ErrClassRebase     ErrorClass = C.GITERR_REBASE
                                                              )

                                                              type ErrorCode

                                                              type ErrorCode int
                                                              const (
                                                              
                                                              	// No error
                                                              	ErrOk ErrorCode = C.GIT_OK
                                                              
                                                              	// Generic error
                                                              	ErrGeneric ErrorCode = C.GIT_ERROR
                                                              	// Requested object could not be found
                                                              	ErrNotFound ErrorCode = C.GIT_ENOTFOUND
                                                              	// Object exists preventing operation
                                                              	ErrExists ErrorCode = C.GIT_EEXISTS
                                                              	// More than one object matches
                                                              	ErrAmbigious ErrorCode = C.GIT_EAMBIGUOUS
                                                              	// Output buffer too short to hold data
                                                              	ErrBuffs ErrorCode = C.GIT_EBUFS
                                                              
                                                              	// GIT_EUSER is a special error that is never generated by libgit2
                                                              	// code.  You can return it from a callback (e.g to stop an iteration)
                                                              	// to know that it was generated by the callback and not by libgit2.
                                                              	ErrUser ErrorCode = C.GIT_EUSER
                                                              
                                                              	// Operation not allowed on bare repository
                                                              	ErrBareRepo ErrorCode = C.GIT_EBAREREPO
                                                              	// HEAD refers to branch with no commits
                                                              	ErrUnbornBranch ErrorCode = C.GIT_EUNBORNBRANCH
                                                              	// Merge in progress prevented operation
                                                              	ErrUnmerged ErrorCode = C.GIT_EUNMERGED
                                                              	// Reference was not fast-forwardable
                                                              	ErrNonFastForward ErrorCode = C.GIT_ENONFASTFORWARD
                                                              	// Name/ref spec was not in a valid format
                                                              	ErrInvalidSpec ErrorCode = C.GIT_EINVALIDSPEC
                                                              	// Checkout conflicts prevented operation
                                                              	ErrConflict ErrorCode = C.GIT_ECONFLICT
                                                              	// Lock file prevented operation
                                                              	ErrLocked ErrorCode = C.GIT_ELOCKED
                                                              	// Reference value does not match expected
                                                              	ErrModified ErrorCode = C.GIT_EMODIFIED
                                                              	// Authentication failed
                                                              	ErrAuth ErrorCode = C.GIT_EAUTH
                                                              	// Server certificate is invalid
                                                              	ErrCertificate ErrorCode = C.GIT_ECERTIFICATE
                                                              	// Patch/merge has already been applied
                                                              	ErrApplied ErrorCode = C.GIT_EAPPLIED
                                                              	// The requested peel operation is not possible
                                                              	ErrPeel ErrorCode = C.GIT_EPEEL
                                                              	// Unexpected EOF
                                                              	ErrEOF ErrorCode = C.GIT_EEOF
                                                              	// Uncommitted changes in index prevented operation
                                                              	ErrUncommitted ErrorCode = C.GIT_EUNCOMMITTED
                                                              	// The operation is not valid for a directory
                                                              	ErrDirectory ErrorCode = C.GIT_EDIRECTORY
                                                              	// A merge conflict exists and cannot continue
                                                              	ErrMergeConflict ErrorCode = C.GIT_EMERGECONFLICT
                                                              
                                                              	// Internal only
                                                              	ErrPassthrough ErrorCode = C.GIT_PASSTHROUGH
                                                              	// Signals end of iteration with iterator
                                                              	ErrIterOver ErrorCode = C.GIT_ITEROVER
                                                              )

                                                              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
                                                                }

                                                                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) 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
                                                                      }

                                                                        Server host key information. If Kind is HostkeyMD5 the MD5 field will be filled. If Kind is HostkeySHA1, then HashSHA1 will be filled.

                                                                        type HostkeyKind

                                                                        type HostkeyKind uint
                                                                        const (
                                                                        	HostkeyMD5  HostkeyKind = C.GIT_CERT_SSH_MD5
                                                                        	HostkeySHA1 HostkeyKind = C.GIT_CERT_SSH_SHA1
                                                                        )

                                                                        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 IndexAddOpts, 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) 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) 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)

                                                                                  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 IndexAddOpts

                                                                                        type IndexAddOpts uint
                                                                                        const (
                                                                                        	IndexAddDefault              IndexAddOpts = C.GIT_INDEX_ADD_DEFAULT
                                                                                        	IndexAddForce                IndexAddOpts = C.GIT_INDEX_ADD_FORCE
                                                                                        	IndexAddDisablePathspecMatch IndexAddOpts = C.GIT_INDEX_ADD_DISABLE_PATHSPEC_MATCH
                                                                                        	IndexAddCheckPathspec        IndexAddOpts = C.GIT_INDEX_ADD_CHECK_PATHSPEC
                                                                                        )

                                                                                        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

                                                                                        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

                                                                                        type IndexStageOpts int
                                                                                        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 IndexStageOpts = C.GIT_INDEX_STAGE_ANY
                                                                                        	// IndexStageNormal is a normal staged file in the index.
                                                                                        	IndexStageNormal IndexStageOpts = C.GIT_INDEX_STAGE_NORMAL
                                                                                        	// IndexStageAncestor is the ancestor side of a conflict.
                                                                                        	IndexStageAncestor IndexStageOpts = C.GIT_INDEX_STAGE_ANCESTOR
                                                                                        	// IndexStageOurs is the "ours" side of a conflict.
                                                                                        	IndexStageOurs IndexStageOpts = C.GIT_INDEX_STAGE_OURS
                                                                                        	// IndexStageTheirs is the "theirs" side of a conflict.
                                                                                        	IndexStageTheirs IndexStageOpts = C.GIT_INDEX_STAGE_THEIRS
                                                                                        )

                                                                                        type IndexTime

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

                                                                                        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()

                                                                                                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
                                                                                                	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
                                                                                                )

                                                                                                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.

                                                                                                                              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, ErrInvalidSpec 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 ErrInvalidSpec.

                                                                                                                                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) 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) 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 (*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 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
                                                                                                                                                      }

                                                                                                                                                      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 (rebase *Rebase) Free()

                                                                                                                                                                  Free frees the Rebase object.

                                                                                                                                                                  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 CheckoutOpts
                                                                                                                                                                            }

                                                                                                                                                                              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.

                                                                                                                                                                                        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 ReferenceIterator

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

                                                                                                                                                                                                func (*ReferenceIterator) Free

                                                                                                                                                                                                func (v *ReferenceIterator) Free()

                                                                                                                                                                                                  Free the reference iterator

                                                                                                                                                                                                  func (*ReferenceIterator) Names

                                                                                                                                                                                                  func (*ReferenceIterator) Next

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

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

                                                                                                                                                                                                    type ReferenceNameIterator

                                                                                                                                                                                                    type ReferenceNameIterator struct {
                                                                                                                                                                                                    	*ReferenceIterator
                                                                                                                                                                                                    }

                                                                                                                                                                                                    func (*ReferenceNameIterator) Next

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

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

                                                                                                                                                                                                      type ReferenceType

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

                                                                                                                                                                                                      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()

                                                                                                                                                                                                          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 RemoteCollection

                                                                                                                                                                                                          type RemoteCollection struct {
                                                                                                                                                                                                          	// 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) Delete

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

                                                                                                                                                                                                          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 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) BlameFile

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

                                                                                                                                                                                                            func (*Repository) CheckoutHead

                                                                                                                                                                                                            func (v *Repository) CheckoutHead(opts *CheckoutOpts) 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 *CheckoutOpts) 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 *CheckoutOpts) error

                                                                                                                                                                                                                func (*Repository) Cherrypick

                                                                                                                                                                                                                func (v *Repository) Cherrypick(commit *Commit, opts CherrypickOptions) 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) CreateCommitFromIds

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

                                                                                                                                                                                                                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) 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) 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 *CheckoutOpts) 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) 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) 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) 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) ResetDefaultToCommit

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

                                                                                                                                                                                                                                  func (*Repository) ResetToCommit

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

                                                                                                                                                                                                                                  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) 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 RepositoryOpenFlag

                                                                                                                                                                                                                                  type RepositoryOpenFlag int

                                                                                                                                                                                                                                  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 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 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  CheckoutOpts               // 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 ErrConflict 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 ErrConflict 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 ErrNotFound if there's no stashed state for the given index, error code ErrConflict 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, ErrNotFound).

                                                                                                                                                                                                                                                    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 ErrNotFound 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 ErrNotFound 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 SubmoduleCbk

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

                                                                                                                                                                                                                                                                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(cbk SubmoduleCbk) 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

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