This section is empty.


    View Source
    var (
    	// ErrNotFound is returned by New when the path is not found.
    	ErrNotFound = errors.New("path not found")
    	// ErrIdxNotFound is returned by Idxfile when the idx file is not found
    	ErrIdxNotFound = errors.New("idx file not found")
    	// ErrPackfileNotFound is returned by Packfile when the packfile is not found
    	ErrPackfileNotFound = errors.New("packfile not found")
    	// ErrConfigNotFound is returned by Config when the config is not found
    	ErrConfigNotFound = errors.New("config file not found")
    	// ErrPackedRefsDuplicatedRef is returned when a duplicated reference is
    	// found in the packed-ref file. This is usually the case for corrupted git
    	// repositories.
    	ErrPackedRefsDuplicatedRef = errors.New("duplicated ref found in packed-ref file")
    	// ErrPackedRefsBadFormat is returned when the packed-ref file corrupt.
    	ErrPackedRefsBadFormat = errors.New("malformed packed-ref")
    	// ErrSymRefTargetNotFound is returned when a symbolic reference is
    	// targeting a non-existing object. This usually means the repository
    	// is corrupt.
    	ErrSymRefTargetNotFound = errors.New("symbolic reference target not found")


    This section is empty.


    type DotGit

    type DotGit struct {
    	// contains filtered or unexported fields

      The DotGit type represents a local git repository on disk. This type is not zero-value-safe, use the New function to initialize it.

      func New

      func New(fs billy.Filesystem) *DotGit

        New returns a DotGit value ready to be used. The path argument must be the absolute path of a git repository directory (e.g. "/foo/bar/.git").

        func NewWithOptions

        func NewWithOptions(fs billy.Filesystem, o Options) *DotGit

          NewWithOptions sets non default configuration options. See New for complete help.

          func (*DotGit) Alternates

          func (d *DotGit) Alternates() ([]*DotGit, error)

            Alternates returns DotGit(s) based off paths in objects/info/alternates if available. This can be used to checks if it's a shared repository.

            func (*DotGit) Close

            func (d *DotGit) Close() error

              Close closes all opened files.

              func (*DotGit) Config

              func (d *DotGit) Config() (billy.File, error)

                Config returns a file pointer for read to the config file

                func (*DotGit) ConfigWriter

                func (d *DotGit) ConfigWriter() (billy.File, error)

                  ConfigWriter returns a file pointer for write to the config file

                  func (*DotGit) CountLooseRefs

                  func (d *DotGit) CountLooseRefs() (int, error)

                  func (*DotGit) DeleteOldObjectPackAndIndex

                  func (d *DotGit) DeleteOldObjectPackAndIndex(hash plumbing.Hash, t time.Time) error

                  func (*DotGit) ForEachObjectHash

                  func (d *DotGit) ForEachObjectHash(fun func(plumbing.Hash) error) error

                    ForEachObjectHash iterates over the hashes of objects found under the .git/objects/ directory and executes the provided function.

                    func (*DotGit) Fs

                    func (d *DotGit) Fs() billy.Filesystem

                      Fs returns the underlying filesystem of the DotGit folder.

                      func (*DotGit) Index

                      func (d *DotGit) Index() (billy.File, error)

                        Index returns a file pointer for read to the index file

                        func (*DotGit) IndexWriter

                        func (d *DotGit) IndexWriter() (billy.File, error)

                          IndexWriter returns a file pointer for write to the index file

                          func (*DotGit) Initialize

                          func (d *DotGit) Initialize() error

                            Initialize creates all the folder scaffolding.

                            func (*DotGit) Module

                            func (d *DotGit) Module(name string) (billy.Filesystem, error)

                              Module return a billy.Filesystem pointing to the module folder

                              func (*DotGit) NewObject

                              func (d *DotGit) NewObject() (*ObjectWriter, error)

                                NewObject return a writer for a new object file.

                                func (*DotGit) NewObjectPack

                                func (d *DotGit) NewObjectPack() (*PackWriter, error)

                                  NewObjectPack return a writer for a new packfile, it saves the packfile to disk and also generates and save the index for the given packfile.

                                  func (*DotGit) Object

                                  func (d *DotGit) Object(h plumbing.Hash) (billy.File, error)

                                    Object returns a fs.File pointing the object file, if exists

                                    func (*DotGit) ObjectDelete

                                    func (d *DotGit) ObjectDelete(h plumbing.Hash) error

                                      ObjectDelete removes the object file, if exists

                                      func (*DotGit) ObjectPack

                                      func (d *DotGit) ObjectPack(hash plumbing.Hash) (billy.File, error)

                                        ObjectPack returns a fs.File of the given packfile

                                        func (*DotGit) ObjectPackIdx

                                        func (d *DotGit) ObjectPackIdx(hash plumbing.Hash) (billy.File, error)

                                          ObjectPackIdx returns a fs.File of the index file for a given packfile

                                          func (*DotGit) ObjectPacks

                                          func (d *DotGit) ObjectPacks() ([]plumbing.Hash, error)

                                            ObjectPacks returns the list of availables packfiles

                                            func (*DotGit) ObjectStat

                                            func (d *DotGit) ObjectStat(h plumbing.Hash) (os.FileInfo, error)

                                              ObjectStat returns a os.FileInfo pointing the object file, if exists

                                              func (*DotGit) Objects

                                              func (d *DotGit) Objects() ([]plumbing.Hash, error)

                                                Objects returns a slice with the hashes of objects found under the .git/objects/ directory.

                                                func (*DotGit) PackRefs

                                                func (d *DotGit) PackRefs() (err error)

                                                  PackRefs packs all loose refs into the packed-refs file.

                                                  This implementation only works under the assumption that the view of the file system won't be updated during this operation. This strategy would not work on a general file system though, without locking each loose reference and checking it again before deleting the file, because otherwise an updated reference could sneak in and then be deleted by the packed-refs process. Alternatively, every ref update could also lock packed-refs, so only one lock is required during ref-packing. But that would worsen performance in the common case.

                                                  TODO: add an "all" boolean like the `git pack-refs --all` flag. When `all` is false, it would only pack refs that have already been packed, plus all tags.

                                                  func (*DotGit) Ref

                                                    Ref returns the reference for a given reference name.

                                                    func (*DotGit) Refs

                                                    func (d *DotGit) Refs() ([]*plumbing.Reference, error)

                                                      Refs scans the git directory collecting references, which it returns. Symbolic references are resolved and included in the output.

                                                      func (*DotGit) RemoveRef

                                                      func (d *DotGit) RemoveRef(name plumbing.ReferenceName) error

                                                        RemoveRef removes a reference by name.

                                                        func (*DotGit) SetRef

                                                        func (d *DotGit) SetRef(r, old *plumbing.Reference) error

                                                        func (*DotGit) Shallow

                                                        func (d *DotGit) Shallow() (billy.File, error)

                                                          Shallow returns a file pointer for read to the shallow file

                                                          func (*DotGit) ShallowWriter

                                                          func (d *DotGit) ShallowWriter() (billy.File, error)

                                                            ShallowWriter returns a file pointer for write to the shallow file

                                                            type ObjectWriter

                                                            type ObjectWriter struct {
                                                            	// contains filtered or unexported fields

                                                            func (*ObjectWriter) Close

                                                            func (w *ObjectWriter) Close() error

                                                            type Options

                                                            type Options struct {
                                                            	// ExclusiveAccess means that the filesystem is not modified externally
                                                            	// while the repo is open.
                                                            	ExclusiveAccess bool
                                                            	// KeepDescriptors makes the file descriptors to be reused but they will
                                                            	// need to be manually closed calling Close().
                                                            	KeepDescriptors bool

                                                              Options holds configuration for the storage.

                                                              type PackWriter

                                                              type PackWriter struct {
                                                              	Notify func(plumbing.Hash, *idxfile.Writer)
                                                              	// contains filtered or unexported fields

                                                                PackWriter is a io.Writer that generates the packfile index simultaneously, a packfile.Decoder is used with a file reader to read the file being written this operation is synchronized with the write operations. The packfile is written in a temp file, when Close is called this file is renamed/moved (depends on the Filesystem implementation) to the final location, if the PackWriter is not used, nothing is written

                                                                func (*PackWriter) Close

                                                                func (w *PackWriter) Close() error

                                                                  Close closes all the file descriptors and save the final packfile, if nothing was written, the tempfiles are deleted without writing a packfile.

                                                                  func (*PackWriter) Write

                                                                  func (w *PackWriter) Write(p []byte) (int, error)