git

package module
Version: v0.28.4 Latest Latest
Warning

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

Go to latest
Published: Dec 10, 2019 License: MIT Imports: 14 Imported by: 115

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)

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 added in v0.28.4

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 added in v0.28.4

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

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

func NewMempack added in v0.28.4

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

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

func (*Mempack) Dump added in v0.28.4

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 added in v0.28.4

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 added in v0.28.4

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 added in v0.28.4

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 added in v0.28.4

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

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL