go-git.v4: gopkg.in/src-d/go-git.v4/storage/filesystem/dotgit Index | Files

package dotgit

import "gopkg.in/src-d/go-git.v4/storage/filesystem/dotgit"

https://github.com/git/git/blob/master/Documentation/gitrepository-layout.txt

Index

Package Files

dotgit.go dotgit_rewrite_packed_refs.go dotgit_setref.go writers.go

Variables

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

type DotGit Uses

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 Uses

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 Uses

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

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

func (*DotGit) Alternates Uses

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 Uses

func (d *DotGit) Close() error

Close closes all opened files.

func (*DotGit) Config Uses

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

Config returns a file pointer for read to the config file

func (*DotGit) ConfigWriter Uses

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

ConfigWriter returns a file pointer for write to the config file

func (*DotGit) CountLooseRefs Uses

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

func (*DotGit) DeleteOldObjectPackAndIndex Uses

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

func (*DotGit) ForEachObjectHash Uses

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 Uses

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

Fs returns the underlying filesystem of the DotGit folder.

func (*DotGit) Index Uses

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

Index returns a file pointer for read to the index file

func (*DotGit) IndexWriter Uses

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

IndexWriter returns a file pointer for write to the index file

func (*DotGit) Initialize Uses

func (d *DotGit) Initialize() error

Initialize creates all the folder scaffolding.

func (*DotGit) Module Uses

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

Module return a billy.Filesystem pointing to the module folder

func (*DotGit) NewObject Uses

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

NewObject return a writer for a new object file.

func (*DotGit) NewObjectPack Uses

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 Uses

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

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

func (*DotGit) ObjectDelete Uses

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

ObjectDelete removes the object file, if exists

func (*DotGit) ObjectPack Uses

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

ObjectPack returns a fs.File of the given packfile

func (*DotGit) ObjectPackIdx Uses

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 Uses

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

ObjectPacks returns the list of availables packfiles

func (*DotGit) ObjectStat Uses

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

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

func (*DotGit) Objects Uses

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 Uses

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 Uses

func (d *DotGit) Ref(name plumbing.ReferenceName) (*plumbing.Reference, error)

Ref returns the reference for a given reference name.

func (*DotGit) Refs Uses

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 Uses

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

RemoveRef removes a reference by name.

func (*DotGit) SetRef Uses

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

func (*DotGit) Shallow Uses

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

Shallow returns a file pointer for read to the shallow file

func (*DotGit) ShallowWriter Uses

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

ShallowWriter returns a file pointer for write to the shallow file

type ObjectWriter Uses

type ObjectWriter struct {
    objfile.Writer
    // contains filtered or unexported fields
}

func (*ObjectWriter) Close Uses

func (w *ObjectWriter) Close() error

type Options Uses

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 Uses

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 Uses

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 Uses

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

Package dotgit imports 19 packages (graph) and is imported by 7 packages. Updated 2019-08-04. Refresh now. Tools for package owners.