Documentation

Overview

    Package object contains implementations of all Git objects and utility functions to work with them.

    Index

    Constants

    View Source
    const DateFormat = "Mon Jan 02 15:04:05 2006 -0700"

      DateFormat is the format being used in the original git implementation

      Variables

      View Source
      var (
      	ErrMaxTreeDepth      = errors.New("maximum tree depth exceeded")
      	ErrFileNotFound      = errors.New("file not found")
      	ErrDirectoryNotFound = errors.New("directory not found")
      	ErrEntryNotFound     = errors.New("entry not found")
      )

        New errors defined by this package.

        View Source
        var (
        	ErrCanceled = errors.New("operation canceled")
        )
        View Source
        var ErrParentNotFound = errors.New("commit parent not found")
        View Source
        var ErrUnsupportedObject = errors.New("unsupported object type")

          ErrUnsupportedObject trigger when a non-supported object is being decoded.

          Functions

          func NewTreeRootNode

          func NewTreeRootNode(t *Tree) noder.Noder

            NewTreeRootNode returns the root node of a Tree

            Types

            type Blob

            type Blob struct {
            	// Hash of the blob.
            	Hash plumbing.Hash
            	// Size of the (uncompressed) blob.
            	Size int64
            	// contains filtered or unexported fields
            }

              Blob is used to store arbitrary data - it is generally a file.

              func DecodeBlob

              func DecodeBlob(o plumbing.EncodedObject) (*Blob, error)

                DecodeObject decodes an encoded object into a *Blob.

                func GetBlob

                  GetBlob gets a blob from an object storer and decodes it.

                  func (*Blob) Decode

                  func (b *Blob) Decode(o plumbing.EncodedObject) error

                    Decode transforms a plumbing.EncodedObject into a Blob struct.

                    func (*Blob) Encode

                    func (b *Blob) Encode(o plumbing.EncodedObject) (err error)

                      Encode transforms a Blob into a plumbing.EncodedObject.

                      func (*Blob) ID

                      func (b *Blob) ID() plumbing.Hash

                        ID returns the object ID of the blob. The returned value will always match the current value of Blob.Hash.

                        ID is present to fulfill the Object interface.

                        func (*Blob) Reader

                        func (b *Blob) Reader() (io.ReadCloser, error)

                          Reader returns a reader allow the access to the content of the blob

                          func (*Blob) Type

                          func (b *Blob) Type() plumbing.ObjectType

                            Type returns the type of object. It always returns plumbing.BlobObject.

                            Type is present to fulfill the Object interface.

                            type BlobIter

                            type BlobIter struct {
                            	storer.EncodedObjectIter
                            	// contains filtered or unexported fields
                            }

                              BlobIter provides an iterator for a set of blobs.

                              func NewBlobIter

                                NewBlobIter takes a storer.EncodedObjectStorer and a storer.EncodedObjectIter and returns a *BlobIter that iterates over all blobs contained in the storer.EncodedObjectIter.

                                Any non-blob object returned by the storer.EncodedObjectIter is skipped.

                                func (*BlobIter) ForEach

                                func (iter *BlobIter) ForEach(cb func(*Blob) error) error

                                  ForEach call the cb function for each blob contained on this iter until an error happens or the end of the iter is reached. If ErrStop is sent the iteration is stop but no error is returned. The iterator is closed.

                                  func (*BlobIter) Next

                                  func (iter *BlobIter) Next() (*Blob, error)

                                    Next moves the iterator to the next blob and returns a pointer to it. If there are no more blobs, it returns io.EOF.

                                    type Change

                                    type Change struct {
                                    	From ChangeEntry
                                    	To   ChangeEntry
                                    }

                                      Change values represent a detected change between two git trees. For modifications, From is the original status of the node and To is its final status. For insertions, From is the zero value and for deletions To is the zero value.

                                      func (*Change) Action

                                      func (c *Change) Action() (merkletrie.Action, error)

                                        Action returns the kind of action represented by the change, an insertion, a deletion or a modification.

                                        func (*Change) Files

                                        func (c *Change) Files() (from, to *File, err error)

                                          Files return the files before and after a change. For insertions from will be nil. For deletions to will be nil.

                                          func (*Change) Patch

                                          func (c *Change) Patch() (*Patch, error)

                                            Patch returns a Patch with all the file changes in chunks. This representation can be used to create several diff outputs.

                                            func (*Change) PatchContext

                                            func (c *Change) PatchContext(ctx context.Context) (*Patch, error)

                                              Patch returns a Patch with all the file changes in chunks. This representation can be used to create several diff outputs. If context expires, an non-nil error will be returned Provided context must be non-nil

                                              func (*Change) String

                                              func (c *Change) String() string

                                              type ChangeEntry

                                              type ChangeEntry struct {
                                              	// Full path of the node using "/" as separator.
                                              	Name string
                                              	// Parent tree of the node that has changed.
                                              	Tree *Tree
                                              	// The entry of the node.
                                              	TreeEntry TreeEntry
                                              }

                                                ChangeEntry values represent a node that has suffered a change.

                                                type Changes

                                                type Changes []*Change

                                                  Changes represents a collection of changes between two git trees. Implements sort.Interface lexicographically over the path of the changed files.

                                                  func DiffTree

                                                  func DiffTree(a, b *Tree) (Changes, error)

                                                    DiffTree compares the content and mode of the blobs found via two tree objects.

                                                    func DiffTreeContext

                                                    func DiffTreeContext(ctx context.Context, a, b *Tree) (Changes, error)

                                                      DiffTree compares the content and mode of the blobs found via two tree objects. Provided context must be non-nil. An error will be return if context expires

                                                      func (Changes) Len

                                                      func (c Changes) Len() int

                                                      func (Changes) Less

                                                      func (c Changes) Less(i, j int) bool

                                                      func (Changes) Patch

                                                      func (c Changes) Patch() (*Patch, error)

                                                        Patch returns a Patch with all the changes in chunks. This representation can be used to create several diff outputs.

                                                        func (Changes) PatchContext

                                                        func (c Changes) PatchContext(ctx context.Context) (*Patch, error)

                                                          Patch returns a Patch with all the changes in chunks. This representation can be used to create several diff outputs. If context expires, an non-nil error will be returned Provided context must be non-nil

                                                          func (Changes) String

                                                          func (c Changes) String() string

                                                          func (Changes) Swap

                                                          func (c Changes) Swap(i, j int)

                                                          type Commit

                                                          type Commit struct {
                                                          	// Hash of the commit object.
                                                          	Hash plumbing.Hash
                                                          	// Author is the original author of the commit.
                                                          	Author Signature
                                                          	// Committer is the one performing the commit, might be different from
                                                          	// Author.
                                                          	Committer Signature
                                                          	// PGPSignature is the PGP signature of the commit.
                                                          	PGPSignature string
                                                          	// Message is the commit message, contains arbitrary text.
                                                          	Message string
                                                          	// TreeHash is the hash of the root tree of the commit.
                                                          	TreeHash plumbing.Hash
                                                          	// ParentHashes are the hashes of the parent commits of the commit.
                                                          	ParentHashes []plumbing.Hash
                                                          	// contains filtered or unexported fields
                                                          }

                                                            Commit points to a single tree, marking it as what the project looked like at a certain point in time. It contains meta-information about that point in time, such as a timestamp, the author of the changes since the last commit, a pointer to the previous commit(s), etc. http://shafiulazam.com/gitbook/1_the_git_object_model.html

                                                            func DecodeCommit

                                                              DecodeCommit decodes an encoded object into a *Commit and associates it to the given object storer.

                                                              func GetCommit

                                                              func GetCommit(s storer.EncodedObjectStorer, h plumbing.Hash) (*Commit, error)

                                                                GetCommit gets a commit from an object storer and decodes it.

                                                                func Independents

                                                                func Independents(commits []*Commit) ([]*Commit, error)

                                                                  Independents returns a subset of the passed commits, that are not reachable the others It mimics the behavior of `git merge-base --independent commit...`.

                                                                  func (*Commit) Decode

                                                                  func (c *Commit) Decode(o plumbing.EncodedObject) (err error)

                                                                    Decode transforms a plumbing.EncodedObject into a Commit struct.

                                                                    func (*Commit) Encode

                                                                    func (b *Commit) Encode(o plumbing.EncodedObject) error

                                                                      Encode transforms a Commit into a plumbing.EncodedObject.

                                                                      func (*Commit) EncodeWithoutSignature

                                                                      func (b *Commit) EncodeWithoutSignature(o plumbing.EncodedObject) error

                                                                        EncodeWithoutSignature export a Commit into a plumbing.EncodedObject without the signature (correspond to the payload of the PGP signature).

                                                                        func (*Commit) File

                                                                        func (c *Commit) File(path string) (*File, error)

                                                                          File returns the file with the specified "path" in the commit and a nil error if the file exists. If the file does not exist, it returns a nil file and the ErrFileNotFound error.

                                                                          func (*Commit) Files

                                                                          func (c *Commit) Files() (*FileIter, error)

                                                                            Files returns a FileIter allowing to iterate over the Tree

                                                                            func (*Commit) ID

                                                                            func (c *Commit) ID() plumbing.Hash

                                                                              ID returns the object ID of the commit. The returned value will always match the current value of Commit.Hash.

                                                                              ID is present to fulfill the Object interface.

                                                                              func (*Commit) IsAncestor

                                                                              func (c *Commit) IsAncestor(other *Commit) (bool, error)

                                                                                IsAncestor returns true if the actual commit is ancestor of the passed one. It returns an error if the history is not transversable It mimics the behavior of `git merge --is-ancestor actual other`

                                                                                func (*Commit) MergeBase

                                                                                func (c *Commit) MergeBase(other *Commit) ([]*Commit, error)

                                                                                  MergeBase mimics the behavior of `git merge-base actual other`, returning the best common ancestor between the actual and the passed one. The best common ancestors can not be reached from other common ancestors.

                                                                                  func (*Commit) NumParents

                                                                                  func (c *Commit) NumParents() int

                                                                                    NumParents returns the number of parents in a commit.

                                                                                    func (*Commit) Parent

                                                                                    func (c *Commit) Parent(i int) (*Commit, error)

                                                                                      Parent returns the ith parent of a commit.

                                                                                      func (*Commit) Parents

                                                                                      func (c *Commit) Parents() CommitIter

                                                                                        Parents return a CommitIter to the parent Commits.

                                                                                        func (*Commit) Patch

                                                                                        func (c *Commit) Patch(to *Commit) (*Patch, error)

                                                                                          Patch returns the Patch between the actual commit and the provided one.

                                                                                          func (*Commit) PatchContext

                                                                                          func (c *Commit) PatchContext(ctx context.Context, to *Commit) (*Patch, error)

                                                                                            PatchContext returns the Patch between the actual commit and the provided one. Error will be return if context expires. Provided context must be non-nil.

                                                                                            func (*Commit) Stats

                                                                                            func (c *Commit) Stats() (FileStats, error)

                                                                                              Stats returns the stats of a commit.

                                                                                              func (*Commit) StatsContext

                                                                                              func (c *Commit) StatsContext(ctx context.Context) (FileStats, error)

                                                                                                StatsContext returns the stats of a commit. Error will be return if context expires. Provided context must be non-nil.

                                                                                                func (*Commit) String

                                                                                                func (c *Commit) String() string

                                                                                                func (*Commit) Tree

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

                                                                                                  Tree returns the Tree from the commit.

                                                                                                  func (*Commit) Type

                                                                                                  func (c *Commit) Type() plumbing.ObjectType

                                                                                                    Type returns the type of object. It always returns plumbing.CommitObject.

                                                                                                    Type is present to fulfill the Object interface.

                                                                                                    func (*Commit) Verify

                                                                                                    func (c *Commit) Verify(armoredKeyRing string) (*openpgp.Entity, error)

                                                                                                      Verify performs PGP verification of the commit with a provided armored keyring and returns openpgp.Entity associated with verifying key on success.

                                                                                                      type CommitFilter

                                                                                                      type CommitFilter func(*Commit) bool

                                                                                                        CommitFilter returns a boolean for the passed Commit

                                                                                                        type CommitIter

                                                                                                        type CommitIter interface {
                                                                                                        	Next() (*Commit, error)
                                                                                                        	ForEach(func(*Commit) error) error
                                                                                                        	Close()
                                                                                                        }

                                                                                                          CommitIter is a generic closable interface for iterating over commits.

                                                                                                          func NewCommitAllIter

                                                                                                          func NewCommitAllIter(repoStorer storage.Storer, commitIterFunc func(*Commit) CommitIter) (CommitIter, error)

                                                                                                            NewCommitAllIter returns a new commit iterator for all refs. repoStorer is a repo Storer used to get commits and references. commitIterFunc is a commit iterator function, used to iterate through ref commits in chosen order

                                                                                                            func NewCommitFileIterFromIter

                                                                                                            func NewCommitFileIterFromIter(fileName string, commitIter CommitIter, checkParent bool) CommitIter

                                                                                                              NewCommitFileIterFromIter returns a commit iterator which performs diffTree between successive trees returned from the commit iterator from the argument. The purpose of this is to find the commits that explain how the files that match the path came to be. If checkParent is true then the function double checks if potential parent (next commit in a path) is one of the parents in the tree (it's used by `git log --all`).

                                                                                                              func NewCommitIter

                                                                                                                NewCommitIter takes a storer.EncodedObjectStorer and a storer.EncodedObjectIter and returns a CommitIter that iterates over all commits contained in the storer.EncodedObjectIter.

                                                                                                                Any non-commit object returned by the storer.EncodedObjectIter is skipped.

                                                                                                                func NewCommitIterBSF

                                                                                                                func NewCommitIterBSF(
                                                                                                                	c *Commit,
                                                                                                                	seenExternal map[plumbing.Hash]bool,
                                                                                                                	ignore []plumbing.Hash,
                                                                                                                ) CommitIter

                                                                                                                  NewCommitIterBSF returns a CommitIter that walks the commit history, starting at the given commit and visiting its parents in pre-order. The given callback will be called for each visited commit. Each commit will be visited only once. If the callback returns an error, walking will stop and will return the error. Other errors might be returned if the history cannot be traversed (e.g. missing objects). Ignore allows to skip some commits from being iterated.

                                                                                                                  func NewCommitIterCTime

                                                                                                                  func NewCommitIterCTime(
                                                                                                                  	c *Commit,
                                                                                                                  	seenExternal map[plumbing.Hash]bool,
                                                                                                                  	ignore []plumbing.Hash,
                                                                                                                  ) CommitIter

                                                                                                                    NewCommitIterCTime returns a CommitIter that walks the commit history, starting at the given commit and visiting its parents while preserving Committer Time order. this appears to be the closest order to `git log` The given callback will be called for each visited commit. Each commit will be visited only once. If the callback returns an error, walking will stop and will return the error. Other errors might be returned if the history cannot be traversed (e.g. missing objects). Ignore allows to skip some commits from being iterated.

                                                                                                                    func NewCommitPostorderIter

                                                                                                                    func NewCommitPostorderIter(c *Commit, ignore []plumbing.Hash) CommitIter

                                                                                                                      NewCommitPostorderIter returns a CommitIter that walks the commit history like WalkCommitHistory but in post-order. This means that after walking a merge commit, the merged commit will be walked before the base it was merged on. This can be useful if you wish to see the history in chronological order. Ignore allows to skip some commits from being iterated.

                                                                                                                      func NewCommitPreorderIter

                                                                                                                      func NewCommitPreorderIter(
                                                                                                                      	c *Commit,
                                                                                                                      	seenExternal map[plumbing.Hash]bool,
                                                                                                                      	ignore []plumbing.Hash,
                                                                                                                      ) CommitIter

                                                                                                                        NewCommitPreorderIter returns a CommitIter that walks the commit history, starting at the given commit and visiting its parents in pre-order. The given callback will be called for each visited commit. Each commit will be visited only once. If the callback returns an error, walking will stop and will return the error. Other errors might be returned if the history cannot be traversed (e.g. missing objects). Ignore allows to skip some commits from being iterated.

                                                                                                                        func NewFilterCommitIter

                                                                                                                        func NewFilterCommitIter(
                                                                                                                        	from *Commit,
                                                                                                                        	isValid *CommitFilter,
                                                                                                                        	isLimit *CommitFilter,
                                                                                                                        ) CommitIter

                                                                                                                          NewFilterCommitIter returns a CommitIter that walks the commit history, starting at the passed commit and visiting its parents in Breadth-first order. The commits returned by the CommitIter will validate the passed CommitFilter. The history won't be transversed beyond a commit if isLimit is true for it. Each commit will be visited only once. If the commit history can not be traversed, or the Close() method is called, the CommitIter won't return more commits. If no isValid is passed, all ancestors of from commit will be valid. If no isLimit is limmit, all ancestors of all commits will be visited.

                                                                                                                          type File

                                                                                                                          type File struct {
                                                                                                                          	// Name is the path of the file. It might be relative to a tree,
                                                                                                                          	// depending of the function that generates it.
                                                                                                                          	Name string
                                                                                                                          	// Mode is the file mode.
                                                                                                                          	Mode filemode.FileMode
                                                                                                                          	// Blob with the contents of the file.
                                                                                                                          	Blob
                                                                                                                          }

                                                                                                                            File represents git file objects.

                                                                                                                            func NewFile

                                                                                                                            func NewFile(name string, m filemode.FileMode, b *Blob) *File

                                                                                                                              NewFile returns a File based on the given blob object

                                                                                                                              func (*File) Contents

                                                                                                                              func (f *File) Contents() (content string, err error)

                                                                                                                                Contents returns the contents of a file as a string.

                                                                                                                                func (*File) IsBinary

                                                                                                                                func (f *File) IsBinary() (bin bool, err error)

                                                                                                                                  IsBinary returns if the file is binary or not

                                                                                                                                  func (*File) Lines

                                                                                                                                  func (f *File) Lines() ([]string, error)

                                                                                                                                    Lines returns a slice of lines from the contents of a file, stripping all end of line characters. If the last line is empty (does not end in an end of line), it is also stripped.

                                                                                                                                    type FileIter

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

                                                                                                                                      FileIter provides an iterator for the files in a tree.

                                                                                                                                      func NewFileIter

                                                                                                                                      func NewFileIter(s storer.EncodedObjectStorer, t *Tree) *FileIter

                                                                                                                                        NewFileIter takes a storer.EncodedObjectStorer and a Tree and returns a *FileIter that iterates over all files contained in the tree, recursively.

                                                                                                                                        func (*FileIter) Close

                                                                                                                                        func (iter *FileIter) Close()

                                                                                                                                        func (*FileIter) ForEach

                                                                                                                                        func (iter *FileIter) ForEach(cb func(*File) error) error

                                                                                                                                          ForEach call the cb function for each file contained in this iter until an error happens or the end of the iter is reached. If plumbing.ErrStop is sent the iteration is stop but no error is returned. The iterator is closed.

                                                                                                                                          func (*FileIter) Next

                                                                                                                                          func (iter *FileIter) Next() (*File, error)

                                                                                                                                            Next moves the iterator to the next file and returns a pointer to it. If there are no more files, it returns io.EOF.

                                                                                                                                            type FileStat

                                                                                                                                            type FileStat struct {
                                                                                                                                            	Name     string
                                                                                                                                            	Addition int
                                                                                                                                            	Deletion int
                                                                                                                                            }

                                                                                                                                              FileStat stores the status of changes in content of a file.

                                                                                                                                              func (FileStat) String

                                                                                                                                              func (fs FileStat) String() string

                                                                                                                                              type FileStats

                                                                                                                                              type FileStats []FileStat

                                                                                                                                                FileStats is a collection of FileStat.

                                                                                                                                                func (FileStats) String

                                                                                                                                                func (fileStats FileStats) String() string

                                                                                                                                                type Hash

                                                                                                                                                type Hash plumbing.Hash

                                                                                                                                                  Hash represents the hash of an object

                                                                                                                                                  type Object

                                                                                                                                                  type Object interface {
                                                                                                                                                  	ID() plumbing.Hash
                                                                                                                                                  	Type() plumbing.ObjectType
                                                                                                                                                  	Decode(plumbing.EncodedObject) error
                                                                                                                                                  	Encode(plumbing.EncodedObject) error
                                                                                                                                                  }

                                                                                                                                                    Object is a generic representation of any git object. It is implemented by Commit, Tree, Blob, and Tag, and includes the functions that are common to them.

                                                                                                                                                    Object is returned when an object can be of any type. It is frequently used with a type cast to acquire the specific type of object:

                                                                                                                                                    func process(obj Object) {
                                                                                                                                                    	switch o := obj.(type) {
                                                                                                                                                    	case *Commit:
                                                                                                                                                    		// o is a Commit
                                                                                                                                                    	case *Tree:
                                                                                                                                                    		// o is a Tree
                                                                                                                                                    	case *Blob:
                                                                                                                                                    		// o is a Blob
                                                                                                                                                    	case *Tag:
                                                                                                                                                    		// o is a Tag
                                                                                                                                                    	}
                                                                                                                                                    }
                                                                                                                                                    

                                                                                                                                                    This interface is intentionally different from plumbing.EncodedObject, which is a lower level interface used by storage implementations to read and write objects in its encoded form.

                                                                                                                                                    func DecodeObject

                                                                                                                                                      DecodeObject decodes an encoded object into an Object and associates it to the given object storer.

                                                                                                                                                      func GetObject

                                                                                                                                                        GetObject gets an object from an object storer and decodes it.

                                                                                                                                                        type ObjectIter

                                                                                                                                                        type ObjectIter struct {
                                                                                                                                                        	storer.EncodedObjectIter
                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                        }

                                                                                                                                                          ObjectIter provides an iterator for a set of objects.

                                                                                                                                                          func NewObjectIter

                                                                                                                                                            NewObjectIter takes a storer.EncodedObjectStorer and a storer.EncodedObjectIter and returns an *ObjectIter that iterates over all objects contained in the storer.EncodedObjectIter.

                                                                                                                                                            func (*ObjectIter) ForEach

                                                                                                                                                            func (iter *ObjectIter) ForEach(cb func(Object) error) error

                                                                                                                                                              ForEach call the cb function for each object contained on this iter until an error happens or the end of the iter is reached. If ErrStop is sent the iteration is stop but no error is returned. The iterator is closed.

                                                                                                                                                              func (*ObjectIter) Next

                                                                                                                                                              func (iter *ObjectIter) Next() (Object, error)

                                                                                                                                                                Next moves the iterator to the next object and returns a pointer to it. If there are no more objects, it returns io.EOF.

                                                                                                                                                                type Patch

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

                                                                                                                                                                  textPatch is an implementation of fdiff.Patch interface

                                                                                                                                                                  func (*Patch) Encode

                                                                                                                                                                  func (p *Patch) Encode(w io.Writer) error

                                                                                                                                                                  func (*Patch) FilePatches

                                                                                                                                                                  func (t *Patch) FilePatches() []fdiff.FilePatch

                                                                                                                                                                  func (*Patch) Message

                                                                                                                                                                  func (t *Patch) Message() string

                                                                                                                                                                  func (*Patch) Stats

                                                                                                                                                                  func (p *Patch) Stats() FileStats

                                                                                                                                                                  func (*Patch) String

                                                                                                                                                                  func (p *Patch) String() string

                                                                                                                                                                  type Signature

                                                                                                                                                                  type Signature struct {
                                                                                                                                                                  	// Name represents a person name. It is an arbitrary string.
                                                                                                                                                                  	Name string
                                                                                                                                                                  	// Email is an email, but it cannot be assumed to be well-formed.
                                                                                                                                                                  	Email string
                                                                                                                                                                  	// When is the timestamp of the signature.
                                                                                                                                                                  	When time.Time
                                                                                                                                                                  }

                                                                                                                                                                    Signature is used to identify who and when created a commit or tag.

                                                                                                                                                                    func (*Signature) Decode

                                                                                                                                                                    func (s *Signature) Decode(b []byte)

                                                                                                                                                                      Decode decodes a byte slice into a signature

                                                                                                                                                                      func (*Signature) Encode

                                                                                                                                                                      func (s *Signature) Encode(w io.Writer) error

                                                                                                                                                                        Encode encodes a Signature into a writer.

                                                                                                                                                                        func (*Signature) String

                                                                                                                                                                        func (s *Signature) String() string

                                                                                                                                                                        type Tag

                                                                                                                                                                        type Tag struct {
                                                                                                                                                                        	// Hash of the tag.
                                                                                                                                                                        	Hash plumbing.Hash
                                                                                                                                                                        	// Name of the tag.
                                                                                                                                                                        	Name string
                                                                                                                                                                        	// Tagger is the one who created the tag.
                                                                                                                                                                        	Tagger Signature
                                                                                                                                                                        	// Message is an arbitrary text message.
                                                                                                                                                                        	Message string
                                                                                                                                                                        	// PGPSignature is the PGP signature of the tag.
                                                                                                                                                                        	PGPSignature string
                                                                                                                                                                        	// TargetType is the object type of the target.
                                                                                                                                                                        	TargetType plumbing.ObjectType
                                                                                                                                                                        	// Target is the hash of the target object.
                                                                                                                                                                        	Target plumbing.Hash
                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                        }

                                                                                                                                                                          Tag represents an annotated tag object. It points to a single git object of any type, but tags typically are applied to commit or blob objects. It provides a reference that associates the target with a tag name. It also contains meta-information about the tag, including the tagger, tag date and message.

                                                                                                                                                                          Note that this is not used for lightweight tags.

                                                                                                                                                                          https://git-scm.com/book/en/v2/Git-Internals-Git-References#Tags

                                                                                                                                                                          func DecodeTag

                                                                                                                                                                            DecodeTag decodes an encoded object into a *Commit and associates it to the given object storer.

                                                                                                                                                                            func GetTag

                                                                                                                                                                              GetTag gets a tag from an object storer and decodes it.

                                                                                                                                                                              func (*Tag) Blob

                                                                                                                                                                              func (t *Tag) Blob() (*Blob, error)

                                                                                                                                                                                Blob returns the blob pointed to by the tag. If the tag points to a different type of object ErrUnsupportedObject will be returned.

                                                                                                                                                                                func (*Tag) Commit

                                                                                                                                                                                func (t *Tag) Commit() (*Commit, error)

                                                                                                                                                                                  Commit returns the commit pointed to by the tag. If the tag points to a different type of object ErrUnsupportedObject will be returned.

                                                                                                                                                                                  func (*Tag) Decode

                                                                                                                                                                                  func (t *Tag) Decode(o plumbing.EncodedObject) (err error)

                                                                                                                                                                                    Decode transforms a plumbing.EncodedObject into a Tag struct.

                                                                                                                                                                                    func (*Tag) Encode

                                                                                                                                                                                    func (t *Tag) Encode(o plumbing.EncodedObject) error

                                                                                                                                                                                      Encode transforms a Tag into a plumbing.EncodedObject.

                                                                                                                                                                                      func (*Tag) EncodeWithoutSignature

                                                                                                                                                                                      func (t *Tag) EncodeWithoutSignature(o plumbing.EncodedObject) error

                                                                                                                                                                                        EncodeWithoutSignature export a Tag into a plumbing.EncodedObject without the signature (correspond to the payload of the PGP signature).

                                                                                                                                                                                        func (*Tag) ID

                                                                                                                                                                                        func (t *Tag) ID() plumbing.Hash

                                                                                                                                                                                          ID returns the object ID of the tag, not the object that the tag references. The returned value will always match the current value of Tag.Hash.

                                                                                                                                                                                          ID is present to fulfill the Object interface.

                                                                                                                                                                                          func (*Tag) Object

                                                                                                                                                                                          func (t *Tag) Object() (Object, error)

                                                                                                                                                                                            Object returns the object pointed to by the tag.

                                                                                                                                                                                            func (*Tag) String

                                                                                                                                                                                            func (t *Tag) String() string

                                                                                                                                                                                              String returns the meta information contained in the tag as a formatted string.

                                                                                                                                                                                              func (*Tag) Tree

                                                                                                                                                                                              func (t *Tag) Tree() (*Tree, error)

                                                                                                                                                                                                Tree returns the tree pointed to by the tag. If the tag points to a commit object the tree of that commit will be returned. If the tag does not point to a commit or tree object ErrUnsupportedObject will be returned.

                                                                                                                                                                                                func (*Tag) Type

                                                                                                                                                                                                func (t *Tag) Type() plumbing.ObjectType

                                                                                                                                                                                                  Type returns the type of object. It always returns plumbing.TagObject.

                                                                                                                                                                                                  Type is present to fulfill the Object interface.

                                                                                                                                                                                                  func (*Tag) Verify

                                                                                                                                                                                                  func (t *Tag) Verify(armoredKeyRing string) (*openpgp.Entity, error)

                                                                                                                                                                                                    Verify performs PGP verification of the tag with a provided armored keyring and returns openpgp.Entity associated with verifying key on success.

                                                                                                                                                                                                    type TagIter

                                                                                                                                                                                                    type TagIter struct {
                                                                                                                                                                                                    	storer.EncodedObjectIter
                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                    }

                                                                                                                                                                                                      TagIter provides an iterator for a set of tags.

                                                                                                                                                                                                      func NewTagIter

                                                                                                                                                                                                        NewTagIter takes a storer.EncodedObjectStorer and a storer.EncodedObjectIter and returns a *TagIter that iterates over all tags contained in the storer.EncodedObjectIter.

                                                                                                                                                                                                        Any non-tag object returned by the storer.EncodedObjectIter is skipped.

                                                                                                                                                                                                        func (*TagIter) ForEach

                                                                                                                                                                                                        func (iter *TagIter) ForEach(cb func(*Tag) error) error

                                                                                                                                                                                                          ForEach call the cb function for each tag contained on this iter until an error happens or the end of the iter is reached. If ErrStop is sent the iteration is stop but no error is returned. The iterator is closed.

                                                                                                                                                                                                          func (*TagIter) Next

                                                                                                                                                                                                          func (iter *TagIter) Next() (*Tag, error)

                                                                                                                                                                                                            Next moves the iterator to the next tag and returns a pointer to it. If there are no more tags, it returns io.EOF.

                                                                                                                                                                                                            type Tree

                                                                                                                                                                                                            type Tree struct {
                                                                                                                                                                                                            	Entries []TreeEntry
                                                                                                                                                                                                            	Hash    plumbing.Hash
                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                            }

                                                                                                                                                                                                              Tree is basically like a directory - it references a bunch of other trees and/or blobs (i.e. files and sub-directories)

                                                                                                                                                                                                              func DecodeTree

                                                                                                                                                                                                                DecodeTree decodes an encoded object into a *Tree and associates it to the given object storer.

                                                                                                                                                                                                                func GetTree

                                                                                                                                                                                                                  GetTree gets a tree from an object storer and decodes it.

                                                                                                                                                                                                                  func (*Tree) Decode

                                                                                                                                                                                                                  func (t *Tree) Decode(o plumbing.EncodedObject) (err error)

                                                                                                                                                                                                                    Decode transform an plumbing.EncodedObject into a Tree struct

                                                                                                                                                                                                                    func (*Tree) Diff

                                                                                                                                                                                                                    func (from *Tree) Diff(to *Tree) (Changes, error)

                                                                                                                                                                                                                      Diff returns a list of changes between this tree and the provided one

                                                                                                                                                                                                                      func (*Tree) DiffContext

                                                                                                                                                                                                                      func (from *Tree) DiffContext(ctx context.Context, to *Tree) (Changes, error)

                                                                                                                                                                                                                        Diff returns a list of changes between this tree and the provided one Error will be returned if context expires Provided context must be non nil

                                                                                                                                                                                                                        func (*Tree) Encode

                                                                                                                                                                                                                        func (t *Tree) Encode(o plumbing.EncodedObject) (err error)

                                                                                                                                                                                                                          Encode transforms a Tree into a plumbing.EncodedObject.

                                                                                                                                                                                                                          func (*Tree) File

                                                                                                                                                                                                                          func (t *Tree) File(path string) (*File, error)

                                                                                                                                                                                                                            File returns the hash of the file identified by the `path` argument. The path is interpreted as relative to the tree receiver.

                                                                                                                                                                                                                            func (*Tree) Files

                                                                                                                                                                                                                            func (t *Tree) Files() *FileIter

                                                                                                                                                                                                                              Files returns a FileIter allowing to iterate over the Tree

                                                                                                                                                                                                                              func (*Tree) FindEntry

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

                                                                                                                                                                                                                                FindEntry search a TreeEntry in this tree or any subtree.

                                                                                                                                                                                                                                func (*Tree) ID

                                                                                                                                                                                                                                func (t *Tree) ID() plumbing.Hash

                                                                                                                                                                                                                                  ID returns the object ID of the tree. The returned value will always match the current value of Tree.Hash.

                                                                                                                                                                                                                                  ID is present to fulfill the Object interface.

                                                                                                                                                                                                                                  func (*Tree) Patch

                                                                                                                                                                                                                                  func (from *Tree) Patch(to *Tree) (*Patch, error)

                                                                                                                                                                                                                                    Patch returns a slice of Patch objects with all the changes between trees in chunks. This representation can be used to create several diff outputs.

                                                                                                                                                                                                                                    func (*Tree) PatchContext

                                                                                                                                                                                                                                    func (from *Tree) PatchContext(ctx context.Context, to *Tree) (*Patch, error)

                                                                                                                                                                                                                                      Patch returns a slice of Patch objects with all the changes between trees in chunks. This representation can be used to create several diff outputs. If context expires, an error will be returned Provided context must be non-nil

                                                                                                                                                                                                                                      func (*Tree) Size

                                                                                                                                                                                                                                      func (t *Tree) Size(path string) (int64, error)

                                                                                                                                                                                                                                        Size returns the plaintext size of an object, without reading it into memory.

                                                                                                                                                                                                                                        func (*Tree) Tree

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

                                                                                                                                                                                                                                          Tree returns the tree identified by the `path` argument. The path is interpreted as relative to the tree receiver.

                                                                                                                                                                                                                                          func (*Tree) TreeEntryFile

                                                                                                                                                                                                                                          func (t *Tree) TreeEntryFile(e *TreeEntry) (*File, error)

                                                                                                                                                                                                                                            TreeEntryFile returns the *File for a given *TreeEntry.

                                                                                                                                                                                                                                            func (*Tree) Type

                                                                                                                                                                                                                                            func (t *Tree) Type() plumbing.ObjectType

                                                                                                                                                                                                                                              Type returns the type of object. It always returns plumbing.TreeObject.

                                                                                                                                                                                                                                              type TreeEntry

                                                                                                                                                                                                                                              type TreeEntry struct {
                                                                                                                                                                                                                                              	Name string
                                                                                                                                                                                                                                              	Mode filemode.FileMode
                                                                                                                                                                                                                                              	Hash plumbing.Hash
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                TreeEntry represents a file

                                                                                                                                                                                                                                                type TreeIter

                                                                                                                                                                                                                                                type TreeIter struct {
                                                                                                                                                                                                                                                	storer.EncodedObjectIter
                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  TreeIter provides an iterator for a set of trees.

                                                                                                                                                                                                                                                  func NewTreeIter

                                                                                                                                                                                                                                                    NewTreeIter takes a storer.EncodedObjectStorer and a storer.EncodedObjectIter and returns a *TreeIter that iterates over all tree contained in the storer.EncodedObjectIter.

                                                                                                                                                                                                                                                    Any non-tree object returned by the storer.EncodedObjectIter is skipped.

                                                                                                                                                                                                                                                    func (*TreeIter) ForEach

                                                                                                                                                                                                                                                    func (iter *TreeIter) ForEach(cb func(*Tree) error) error

                                                                                                                                                                                                                                                      ForEach call the cb function for each tree contained on this iter until an error happens or the end of the iter is reached. If ErrStop is sent the iteration is stop but no error is returned. The iterator is closed.

                                                                                                                                                                                                                                                      func (*TreeIter) Next

                                                                                                                                                                                                                                                      func (iter *TreeIter) Next() (*Tree, error)

                                                                                                                                                                                                                                                        Next moves the iterator to the next tree and returns a pointer to it. If there are no more trees, it returns io.EOF.

                                                                                                                                                                                                                                                        type TreeWalker

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

                                                                                                                                                                                                                                                          TreeWalker provides a means of walking through all of the entries in a Tree.

                                                                                                                                                                                                                                                          func NewTreeWalker

                                                                                                                                                                                                                                                          func NewTreeWalker(t *Tree, recursive bool, seen map[plumbing.Hash]bool) *TreeWalker

                                                                                                                                                                                                                                                            NewTreeWalker returns a new TreeWalker for the given tree.

                                                                                                                                                                                                                                                            It is the caller's responsibility to call Close() when finished with the tree walker.

                                                                                                                                                                                                                                                            func (*TreeWalker) Close

                                                                                                                                                                                                                                                            func (w *TreeWalker) Close()

                                                                                                                                                                                                                                                              Close releases any resources used by the TreeWalker.

                                                                                                                                                                                                                                                              func (*TreeWalker) Next

                                                                                                                                                                                                                                                              func (w *TreeWalker) Next() (name string, entry TreeEntry, err error)

                                                                                                                                                                                                                                                                Next returns the next object from the tree. Objects are returned in order and subtrees are included. After the last object has been returned further calls to Next() will return io.EOF.

                                                                                                                                                                                                                                                                In the current implementation any objects which cannot be found in the underlying repository will be skipped automatically. It is possible that this may change in future versions.

                                                                                                                                                                                                                                                                func (*TreeWalker) Tree

                                                                                                                                                                                                                                                                func (w *TreeWalker) Tree() *Tree

                                                                                                                                                                                                                                                                  Tree returns the tree that the tree walker most recently operated on.

                                                                                                                                                                                                                                                                  Directories

                                                                                                                                                                                                                                                                  Path Synopsis
                                                                                                                                                                                                                                                                  Package commitgraph provides an interface for efficient traversal over Git commit graph either through the regular object storage, or optionally with the index stored in commit-graph file (Git 2.18+).
                                                                                                                                                                                                                                                                  Package commitgraph provides an interface for efficient traversal over Git commit graph either through the regular object storage, or optionally with the index stored in commit-graph file (Git 2.18+).