repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
src-d/go-git | storage/filesystem/dotgit/dotgit.go | ObjectPacks | func (d *DotGit) ObjectPacks() ([]plumbing.Hash, error) {
if !d.options.ExclusiveAccess {
return d.objectPacks()
}
err := d.genPackList()
if err != nil {
return nil, err
}
return d.packList, nil
} | go | func (d *DotGit) ObjectPacks() ([]plumbing.Hash, error) {
if !d.options.ExclusiveAccess {
return d.objectPacks()
}
err := d.genPackList()
if err != nil {
return nil, err
}
return d.packList, nil
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"ObjectPacks",
"(",
")",
"(",
"[",
"]",
"plumbing",
".",
"Hash",
",",
"error",
")",
"{",
"if",
"!",
"d",
".",
"options",
".",
"ExclusiveAccess",
"{",
"return",
"d",
".",
"objectPacks",
"(",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"d",
".",
"genPackList",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"packList",
",",
"nil",
"\n",
"}"
] | // ObjectPacks returns the list of availables packfiles | [
"ObjectPacks",
"returns",
"the",
"list",
"of",
"availables",
"packfiles"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L201-L212 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | ObjectPackIdx | func (d *DotGit) ObjectPackIdx(hash plumbing.Hash) (billy.File, error) {
err := d.hasPack(hash)
if err != nil {
return nil, err
}
return d.objectPackOpen(hash, `idx`)
} | go | func (d *DotGit) ObjectPackIdx(hash plumbing.Hash) (billy.File, error) {
err := d.hasPack(hash)
if err != nil {
return nil, err
}
return d.objectPackOpen(hash, `idx`)
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"ObjectPackIdx",
"(",
"hash",
"plumbing",
".",
"Hash",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"err",
":=",
"d",
".",
"hasPack",
"(",
"hash",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"objectPackOpen",
"(",
"hash",
",",
"`idx`",
")",
"\n",
"}"
] | // ObjectPackIdx returns a fs.File of the index file for a given packfile | [
"ObjectPackIdx",
"returns",
"a",
"fs",
".",
"File",
"of",
"the",
"index",
"file",
"for",
"a",
"given",
"packfile"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L292-L299 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | NewObject | func (d *DotGit) NewObject() (*ObjectWriter, error) {
d.cleanObjectList()
return newObjectWriter(d.fs)
} | go | func (d *DotGit) NewObject() (*ObjectWriter, error) {
d.cleanObjectList()
return newObjectWriter(d.fs)
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"NewObject",
"(",
")",
"(",
"*",
"ObjectWriter",
",",
"error",
")",
"{",
"d",
".",
"cleanObjectList",
"(",
")",
"\n\n",
"return",
"newObjectWriter",
"(",
"d",
".",
"fs",
")",
"\n",
"}"
] | // NewObject return a writer for a new object file. | [
"NewObject",
"return",
"a",
"writer",
"for",
"a",
"new",
"object",
"file",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L323-L327 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | hasIncomingObjects | func (d *DotGit) hasIncomingObjects() bool {
if !d.incomingChecked {
directoryContents, err := d.fs.ReadDir(objectsPath)
if err == nil {
for _, file := range directoryContents {
if strings.HasPrefix(file.Name(), "incoming-") && file.IsDir() {
d.incomingDirName = file.Name()
}
}
}
d.incomingChecked = true
}
return d.incomingDirName != ""
} | go | func (d *DotGit) hasIncomingObjects() bool {
if !d.incomingChecked {
directoryContents, err := d.fs.ReadDir(objectsPath)
if err == nil {
for _, file := range directoryContents {
if strings.HasPrefix(file.Name(), "incoming-") && file.IsDir() {
d.incomingDirName = file.Name()
}
}
}
d.incomingChecked = true
}
return d.incomingDirName != ""
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"hasIncomingObjects",
"(",
")",
"bool",
"{",
"if",
"!",
"d",
".",
"incomingChecked",
"{",
"directoryContents",
",",
"err",
":=",
"d",
".",
"fs",
".",
"ReadDir",
"(",
"objectsPath",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"for",
"_",
",",
"file",
":=",
"range",
"directoryContents",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"file",
".",
"Name",
"(",
")",
",",
"\"",
"\"",
")",
"&&",
"file",
".",
"IsDir",
"(",
")",
"{",
"d",
".",
"incomingDirName",
"=",
"file",
".",
"Name",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"d",
".",
"incomingChecked",
"=",
"true",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"incomingDirName",
"!=",
"\"",
"\"",
"\n",
"}"
] | // hasIncomingObjects searches for an incoming directory and keeps its name
// so it doesn't have to be found each time an object is accessed. | [
"hasIncomingObjects",
"searches",
"for",
"an",
"incoming",
"directory",
"and",
"keeps",
"its",
"name",
"so",
"it",
"doesn",
"t",
"have",
"to",
"be",
"found",
"each",
"time",
"an",
"object",
"is",
"accessed",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L515-L530 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | Object | func (d *DotGit) Object(h plumbing.Hash) (billy.File, error) {
err := d.hasObject(h)
if err != nil {
return nil, err
}
obj1, err1 := d.fs.Open(d.objectPath(h))
if os.IsNotExist(err1) && d.hasIncomingObjects() {
obj2, err2 := d.fs.Open(d.incomingObjectPath(h))
if err2 != nil {
return obj1, err1
}
return obj2, err2
}
return obj1, err1
} | go | func (d *DotGit) Object(h plumbing.Hash) (billy.File, error) {
err := d.hasObject(h)
if err != nil {
return nil, err
}
obj1, err1 := d.fs.Open(d.objectPath(h))
if os.IsNotExist(err1) && d.hasIncomingObjects() {
obj2, err2 := d.fs.Open(d.incomingObjectPath(h))
if err2 != nil {
return obj1, err1
}
return obj2, err2
}
return obj1, err1
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"Object",
"(",
"h",
"plumbing",
".",
"Hash",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"err",
":=",
"d",
".",
"hasObject",
"(",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"obj1",
",",
"err1",
":=",
"d",
".",
"fs",
".",
"Open",
"(",
"d",
".",
"objectPath",
"(",
"h",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err1",
")",
"&&",
"d",
".",
"hasIncomingObjects",
"(",
")",
"{",
"obj2",
",",
"err2",
":=",
"d",
".",
"fs",
".",
"Open",
"(",
"d",
".",
"incomingObjectPath",
"(",
"h",
")",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"{",
"return",
"obj1",
",",
"err1",
"\n",
"}",
"\n",
"return",
"obj2",
",",
"err2",
"\n",
"}",
"\n",
"return",
"obj1",
",",
"err1",
"\n",
"}"
] | // Object returns a fs.File pointing the object file, if exists | [
"Object",
"returns",
"a",
"fs",
".",
"File",
"pointing",
"the",
"object",
"file",
"if",
"exists"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L533-L548 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | ObjectStat | func (d *DotGit) ObjectStat(h plumbing.Hash) (os.FileInfo, error) {
err := d.hasObject(h)
if err != nil {
return nil, err
}
obj1, err1 := d.fs.Stat(d.objectPath(h))
if os.IsNotExist(err1) && d.hasIncomingObjects() {
obj2, err2 := d.fs.Stat(d.incomingObjectPath(h))
if err2 != nil {
return obj1, err1
}
return obj2, err2
}
return obj1, err1
} | go | func (d *DotGit) ObjectStat(h plumbing.Hash) (os.FileInfo, error) {
err := d.hasObject(h)
if err != nil {
return nil, err
}
obj1, err1 := d.fs.Stat(d.objectPath(h))
if os.IsNotExist(err1) && d.hasIncomingObjects() {
obj2, err2 := d.fs.Stat(d.incomingObjectPath(h))
if err2 != nil {
return obj1, err1
}
return obj2, err2
}
return obj1, err1
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"ObjectStat",
"(",
"h",
"plumbing",
".",
"Hash",
")",
"(",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"err",
":=",
"d",
".",
"hasObject",
"(",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"obj1",
",",
"err1",
":=",
"d",
".",
"fs",
".",
"Stat",
"(",
"d",
".",
"objectPath",
"(",
"h",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err1",
")",
"&&",
"d",
".",
"hasIncomingObjects",
"(",
")",
"{",
"obj2",
",",
"err2",
":=",
"d",
".",
"fs",
".",
"Stat",
"(",
"d",
".",
"incomingObjectPath",
"(",
"h",
")",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"{",
"return",
"obj1",
",",
"err1",
"\n",
"}",
"\n",
"return",
"obj2",
",",
"err2",
"\n",
"}",
"\n",
"return",
"obj1",
",",
"err1",
"\n",
"}"
] | // ObjectStat returns a os.FileInfo pointing the object file, if exists | [
"ObjectStat",
"returns",
"a",
"os",
".",
"FileInfo",
"pointing",
"the",
"object",
"file",
"if",
"exists"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L551-L566 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | ObjectDelete | func (d *DotGit) ObjectDelete(h plumbing.Hash) error {
d.cleanObjectList()
err1 := d.fs.Remove(d.objectPath(h))
if os.IsNotExist(err1) && d.hasIncomingObjects() {
err2 := d.fs.Remove(d.incomingObjectPath(h))
if err2 != nil {
return err1
}
return err2
}
return err1
} | go | func (d *DotGit) ObjectDelete(h plumbing.Hash) error {
d.cleanObjectList()
err1 := d.fs.Remove(d.objectPath(h))
if os.IsNotExist(err1) && d.hasIncomingObjects() {
err2 := d.fs.Remove(d.incomingObjectPath(h))
if err2 != nil {
return err1
}
return err2
}
return err1
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"ObjectDelete",
"(",
"h",
"plumbing",
".",
"Hash",
")",
"error",
"{",
"d",
".",
"cleanObjectList",
"(",
")",
"\n\n",
"err1",
":=",
"d",
".",
"fs",
".",
"Remove",
"(",
"d",
".",
"objectPath",
"(",
"h",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err1",
")",
"&&",
"d",
".",
"hasIncomingObjects",
"(",
")",
"{",
"err2",
":=",
"d",
".",
"fs",
".",
"Remove",
"(",
"d",
".",
"incomingObjectPath",
"(",
"h",
")",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"{",
"return",
"err1",
"\n",
"}",
"\n",
"return",
"err2",
"\n",
"}",
"\n",
"return",
"err1",
"\n",
"}"
] | // ObjectDelete removes the object file, if exists | [
"ObjectDelete",
"removes",
"the",
"object",
"file",
"if",
"exists"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L569-L581 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | Refs | func (d *DotGit) Refs() ([]*plumbing.Reference, error) {
var refs []*plumbing.Reference
var seen = make(map[plumbing.ReferenceName]bool)
if err := d.addRefsFromRefDir(&refs, seen); err != nil {
return nil, err
}
if err := d.addRefsFromPackedRefs(&refs, seen); err != nil {
return nil, err
}
if err := d.addRefFromHEAD(&refs); err != nil {
return nil, err
}
return refs, nil
} | go | func (d *DotGit) Refs() ([]*plumbing.Reference, error) {
var refs []*plumbing.Reference
var seen = make(map[plumbing.ReferenceName]bool)
if err := d.addRefsFromRefDir(&refs, seen); err != nil {
return nil, err
}
if err := d.addRefsFromPackedRefs(&refs, seen); err != nil {
return nil, err
}
if err := d.addRefFromHEAD(&refs); err != nil {
return nil, err
}
return refs, nil
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"Refs",
"(",
")",
"(",
"[",
"]",
"*",
"plumbing",
".",
"Reference",
",",
"error",
")",
"{",
"var",
"refs",
"[",
"]",
"*",
"plumbing",
".",
"Reference",
"\n",
"var",
"seen",
"=",
"make",
"(",
"map",
"[",
"plumbing",
".",
"ReferenceName",
"]",
"bool",
")",
"\n",
"if",
"err",
":=",
"d",
".",
"addRefsFromRefDir",
"(",
"&",
"refs",
",",
"seen",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"d",
".",
"addRefsFromPackedRefs",
"(",
"&",
"refs",
",",
"seen",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"d",
".",
"addRefFromHEAD",
"(",
"&",
"refs",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"refs",
",",
"nil",
"\n",
"}"
] | // Refs scans the git directory collecting references, which it returns.
// Symbolic references are resolved and included in the output. | [
"Refs",
"scans",
"the",
"git",
"directory",
"collecting",
"references",
"which",
"it",
"returns",
".",
"Symbolic",
"references",
"are",
"resolved",
"and",
"included",
"in",
"the",
"output",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L627-L643 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | Ref | func (d *DotGit) Ref(name plumbing.ReferenceName) (*plumbing.Reference, error) {
ref, err := d.readReferenceFile(".", name.String())
if err == nil {
return ref, nil
}
return d.packedRef(name)
} | go | func (d *DotGit) Ref(name plumbing.ReferenceName) (*plumbing.Reference, error) {
ref, err := d.readReferenceFile(".", name.String())
if err == nil {
return ref, nil
}
return d.packedRef(name)
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"Ref",
"(",
"name",
"plumbing",
".",
"ReferenceName",
")",
"(",
"*",
"plumbing",
".",
"Reference",
",",
"error",
")",
"{",
"ref",
",",
"err",
":=",
"d",
".",
"readReferenceFile",
"(",
"\"",
"\"",
",",
"name",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"ref",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"packedRef",
"(",
"name",
")",
"\n",
"}"
] | // Ref returns the reference for a given reference name. | [
"Ref",
"returns",
"the",
"reference",
"for",
"a",
"given",
"reference",
"name",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L646-L653 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | RemoveRef | func (d *DotGit) RemoveRef(name plumbing.ReferenceName) error {
path := d.fs.Join(".", name.String())
_, err := d.fs.Stat(path)
if err == nil {
err = d.fs.Remove(path)
// Drop down to remove it from the packed refs file, too.
}
if err != nil && !os.IsNotExist(err) {
return err
}
return d.rewritePackedRefsWithoutRef(name)
} | go | func (d *DotGit) RemoveRef(name plumbing.ReferenceName) error {
path := d.fs.Join(".", name.String())
_, err := d.fs.Stat(path)
if err == nil {
err = d.fs.Remove(path)
// Drop down to remove it from the packed refs file, too.
}
if err != nil && !os.IsNotExist(err) {
return err
}
return d.rewritePackedRefsWithoutRef(name)
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"RemoveRef",
"(",
"name",
"plumbing",
".",
"ReferenceName",
")",
"error",
"{",
"path",
":=",
"d",
".",
"fs",
".",
"Join",
"(",
"\"",
"\"",
",",
"name",
".",
"String",
"(",
")",
")",
"\n",
"_",
",",
"err",
":=",
"d",
".",
"fs",
".",
"Stat",
"(",
"path",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"d",
".",
"fs",
".",
"Remove",
"(",
"path",
")",
"\n",
"// Drop down to remove it from the packed refs file, too.",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"&&",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"rewritePackedRefsWithoutRef",
"(",
"name",
")",
"\n",
"}"
] | // RemoveRef removes a reference by name. | [
"RemoveRef",
"removes",
"a",
"reference",
"by",
"name",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L701-L714 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | processLine | func (d *DotGit) processLine(line string) (*plumbing.Reference, error) {
if len(line) == 0 {
return nil, nil
}
switch line[0] {
case '#': // comment - ignore
return nil, nil
case '^': // annotated tag commit of the previous line - ignore
return nil, nil
default:
ws := strings.Split(line, " ") // hash then ref
if len(ws) != 2 {
return nil, ErrPackedRefsBadFormat
}
return plumbing.NewReferenceFromStrings(ws[1], ws[0]), nil
}
} | go | func (d *DotGit) processLine(line string) (*plumbing.Reference, error) {
if len(line) == 0 {
return nil, nil
}
switch line[0] {
case '#': // comment - ignore
return nil, nil
case '^': // annotated tag commit of the previous line - ignore
return nil, nil
default:
ws := strings.Split(line, " ") // hash then ref
if len(ws) != 2 {
return nil, ErrPackedRefsBadFormat
}
return plumbing.NewReferenceFromStrings(ws[1], ws[0]), nil
}
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"processLine",
"(",
"line",
"string",
")",
"(",
"*",
"plumbing",
".",
"Reference",
",",
"error",
")",
"{",
"if",
"len",
"(",
"line",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"switch",
"line",
"[",
"0",
"]",
"{",
"case",
"'#'",
":",
"// comment - ignore",
"return",
"nil",
",",
"nil",
"\n",
"case",
"'^'",
":",
"// annotated tag commit of the previous line - ignore",
"return",
"nil",
",",
"nil",
"\n",
"default",
":",
"ws",
":=",
"strings",
".",
"Split",
"(",
"line",
",",
"\"",
"\"",
")",
"// hash then ref",
"\n",
"if",
"len",
"(",
"ws",
")",
"!=",
"2",
"{",
"return",
"nil",
",",
"ErrPackedRefsBadFormat",
"\n",
"}",
"\n\n",
"return",
"plumbing",
".",
"NewReferenceFromStrings",
"(",
"ws",
"[",
"1",
"]",
",",
"ws",
"[",
"0",
"]",
")",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // process lines from a packed-refs file | [
"process",
"lines",
"from",
"a",
"packed",
"-",
"refs",
"file"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L854-L872 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit.go | Module | func (d *DotGit) Module(name string) (billy.Filesystem, error) {
return d.fs.Chroot(d.fs.Join(modulePath, name))
} | go | func (d *DotGit) Module(name string) (billy.Filesystem, error) {
return d.fs.Chroot(d.fs.Join(modulePath, name))
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"Module",
"(",
"name",
"string",
")",
"(",
"billy",
".",
"Filesystem",
",",
"error",
")",
"{",
"return",
"d",
".",
"fs",
".",
"Chroot",
"(",
"d",
".",
"fs",
".",
"Join",
"(",
"modulePath",
",",
"name",
")",
")",
"\n",
"}"
] | // Module return a billy.Filesystem pointing to the module folder | [
"Module",
"return",
"a",
"billy",
".",
"Filesystem",
"pointing",
"to",
"the",
"module",
"folder"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L1028-L1030 | train |
src-d/go-git | plumbing/filemode/filemode.go | Bytes | func (m FileMode) Bytes() []byte {
ret := make([]byte, 4)
binary.LittleEndian.PutUint32(ret, uint32(m))
return ret[:]
} | go | func (m FileMode) Bytes() []byte {
ret := make([]byte, 4)
binary.LittleEndian.PutUint32(ret, uint32(m))
return ret[:]
} | [
"func",
"(",
"m",
"FileMode",
")",
"Bytes",
"(",
")",
"[",
"]",
"byte",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4",
")",
"\n",
"binary",
".",
"LittleEndian",
".",
"PutUint32",
"(",
"ret",
",",
"uint32",
"(",
"m",
")",
")",
"\n",
"return",
"ret",
"[",
":",
"]",
"\n",
"}"
] | // Bytes return a slice of 4 bytes with the mode in little endian
// encoding. | [
"Bytes",
"return",
"a",
"slice",
"of",
"4",
"bytes",
"with",
"the",
"mode",
"in",
"little",
"endian",
"encoding",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/filemode/filemode.go#L118-L122 | train |
src-d/go-git | plumbing/filemode/filemode.go | IsFile | func (m FileMode) IsFile() bool {
return m == Regular ||
m == Deprecated ||
m == Executable ||
m == Symlink
} | go | func (m FileMode) IsFile() bool {
return m == Regular ||
m == Deprecated ||
m == Executable ||
m == Symlink
} | [
"func",
"(",
"m",
"FileMode",
")",
"IsFile",
"(",
")",
"bool",
"{",
"return",
"m",
"==",
"Regular",
"||",
"m",
"==",
"Deprecated",
"||",
"m",
"==",
"Executable",
"||",
"m",
"==",
"Symlink",
"\n",
"}"
] | // IsFile returns if the FileMode represents that of a file, this is,
// Regular, Deprecated, Excutable or Link. | [
"IsFile",
"returns",
"if",
"the",
"FileMode",
"represents",
"that",
"of",
"a",
"file",
"this",
"is",
"Regular",
"Deprecated",
"Excutable",
"or",
"Link",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/filemode/filemode.go#L156-L161 | train |
src-d/go-git | storage/filesystem/shallow.go | Shallow | func (s *ShallowStorage) Shallow() ([]plumbing.Hash, error) {
f, err := s.dir.Shallow()
if f == nil || err != nil {
return nil, err
}
defer ioutil.CheckClose(f, &err)
var hash []plumbing.Hash
scn := bufio.NewScanner(f)
for scn.Scan() {
hash = append(hash, plumbing.NewHash(scn.Text()))
}
return hash, scn.Err()
} | go | func (s *ShallowStorage) Shallow() ([]plumbing.Hash, error) {
f, err := s.dir.Shallow()
if f == nil || err != nil {
return nil, err
}
defer ioutil.CheckClose(f, &err)
var hash []plumbing.Hash
scn := bufio.NewScanner(f)
for scn.Scan() {
hash = append(hash, plumbing.NewHash(scn.Text()))
}
return hash, scn.Err()
} | [
"func",
"(",
"s",
"*",
"ShallowStorage",
")",
"Shallow",
"(",
")",
"(",
"[",
"]",
"plumbing",
".",
"Hash",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"s",
".",
"dir",
".",
"Shallow",
"(",
")",
"\n",
"if",
"f",
"==",
"nil",
"||",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"defer",
"ioutil",
".",
"CheckClose",
"(",
"f",
",",
"&",
"err",
")",
"\n\n",
"var",
"hash",
"[",
"]",
"plumbing",
".",
"Hash",
"\n\n",
"scn",
":=",
"bufio",
".",
"NewScanner",
"(",
"f",
")",
"\n",
"for",
"scn",
".",
"Scan",
"(",
")",
"{",
"hash",
"=",
"append",
"(",
"hash",
",",
"plumbing",
".",
"NewHash",
"(",
"scn",
".",
"Text",
"(",
")",
")",
")",
"\n",
"}",
"\n\n",
"return",
"hash",
",",
"scn",
".",
"Err",
"(",
")",
"\n",
"}"
] | // Shallow return the shallow commits reading from shallo file from .git | [
"Shallow",
"return",
"the",
"shallow",
"commits",
"reading",
"from",
"shallo",
"file",
"from",
".",
"git"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/shallow.go#L38-L54 | train |
src-d/go-git | plumbing/protocol/packp/ulreq.go | NewUploadRequest | func NewUploadRequest() *UploadRequest {
return &UploadRequest{
Capabilities: capability.NewList(),
Wants: []plumbing.Hash{},
Shallows: []plumbing.Hash{},
Depth: DepthCommits(0),
}
} | go | func NewUploadRequest() *UploadRequest {
return &UploadRequest{
Capabilities: capability.NewList(),
Wants: []plumbing.Hash{},
Shallows: []plumbing.Hash{},
Depth: DepthCommits(0),
}
} | [
"func",
"NewUploadRequest",
"(",
")",
"*",
"UploadRequest",
"{",
"return",
"&",
"UploadRequest",
"{",
"Capabilities",
":",
"capability",
".",
"NewList",
"(",
")",
",",
"Wants",
":",
"[",
"]",
"plumbing",
".",
"Hash",
"{",
"}",
",",
"Shallows",
":",
"[",
"]",
"plumbing",
".",
"Hash",
"{",
"}",
",",
"Depth",
":",
"DepthCommits",
"(",
"0",
")",
",",
"}",
"\n",
"}"
] | // NewUploadRequest returns a pointer to a new UploadRequest value, ready to be
// used. It has no capabilities, wants or shallows and an infinite depth. Please
// note that to encode an upload-request it has to have at least one wanted hash. | [
"NewUploadRequest",
"returns",
"a",
"pointer",
"to",
"a",
"new",
"UploadRequest",
"value",
"ready",
"to",
"be",
"used",
".",
"It",
"has",
"no",
"capabilities",
"wants",
"or",
"shallows",
"and",
"an",
"infinite",
"depth",
".",
"Please",
"note",
"that",
"to",
"encode",
"an",
"upload",
"-",
"request",
"it",
"has",
"to",
"have",
"at",
"least",
"one",
"wanted",
"hash",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/ulreq.go#L61-L68 | train |
src-d/go-git | plumbing/format/pktline/scanner.go | readPayloadLen | func (s *Scanner) readPayloadLen() (int, error) {
if _, err := io.ReadFull(s.r, s.len[:]); err != nil {
if err == io.ErrUnexpectedEOF {
return 0, ErrInvalidPktLen
}
return 0, err
}
n, err := hexDecode(s.len)
if err != nil {
return 0, err
}
switch {
case n == 0:
return 0, nil
case n <= lenSize:
return 0, ErrInvalidPktLen
case n > OversizePayloadMax+lenSize:
return 0, ErrInvalidPktLen
default:
return n - lenSize, nil
}
} | go | func (s *Scanner) readPayloadLen() (int, error) {
if _, err := io.ReadFull(s.r, s.len[:]); err != nil {
if err == io.ErrUnexpectedEOF {
return 0, ErrInvalidPktLen
}
return 0, err
}
n, err := hexDecode(s.len)
if err != nil {
return 0, err
}
switch {
case n == 0:
return 0, nil
case n <= lenSize:
return 0, ErrInvalidPktLen
case n > OversizePayloadMax+lenSize:
return 0, ErrInvalidPktLen
default:
return n - lenSize, nil
}
} | [
"func",
"(",
"s",
"*",
"Scanner",
")",
"readPayloadLen",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"_",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"s",
".",
"r",
",",
"s",
".",
"len",
"[",
":",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"io",
".",
"ErrUnexpectedEOF",
"{",
"return",
"0",
",",
"ErrInvalidPktLen",
"\n",
"}",
"\n\n",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"n",
",",
"err",
":=",
"hexDecode",
"(",
"s",
".",
"len",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"{",
"case",
"n",
"==",
"0",
":",
"return",
"0",
",",
"nil",
"\n",
"case",
"n",
"<=",
"lenSize",
":",
"return",
"0",
",",
"ErrInvalidPktLen",
"\n",
"case",
"n",
">",
"OversizePayloadMax",
"+",
"lenSize",
":",
"return",
"0",
",",
"ErrInvalidPktLen",
"\n",
"default",
":",
"return",
"n",
"-",
"lenSize",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // Method readPayloadLen returns the payload length by reading the
// pkt-len and subtracting the pkt-len size. | [
"Method",
"readPayloadLen",
"returns",
"the",
"payload",
"length",
"by",
"reading",
"the",
"pkt",
"-",
"len",
"and",
"subtracting",
"the",
"pkt",
"-",
"len",
"size",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/pktline/scanner.go#L81-L105 | train |
src-d/go-git | storage/filesystem/dotgit/dotgit_setref.go | setRefNorwfs | func (d *DotGit) setRefNorwfs(fileName, content string, old *plumbing.Reference) error {
_, err := d.fs.Stat(fileName)
if err == nil && old != nil {
fRead, err := d.fs.Open(fileName)
if err != nil {
return err
}
ref, err := d.readReferenceFrom(fRead, old.Name().String())
fRead.Close()
if err != nil {
return err
}
if ref.Hash() != old.Hash() {
return fmt.Errorf("reference has changed concurrently")
}
}
f, err := d.fs.Create(fileName)
if err != nil {
return err
}
defer f.Close()
_, err = f.Write([]byte(content))
return err
} | go | func (d *DotGit) setRefNorwfs(fileName, content string, old *plumbing.Reference) error {
_, err := d.fs.Stat(fileName)
if err == nil && old != nil {
fRead, err := d.fs.Open(fileName)
if err != nil {
return err
}
ref, err := d.readReferenceFrom(fRead, old.Name().String())
fRead.Close()
if err != nil {
return err
}
if ref.Hash() != old.Hash() {
return fmt.Errorf("reference has changed concurrently")
}
}
f, err := d.fs.Create(fileName)
if err != nil {
return err
}
defer f.Close()
_, err = f.Write([]byte(content))
return err
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"setRefNorwfs",
"(",
"fileName",
",",
"content",
"string",
",",
"old",
"*",
"plumbing",
".",
"Reference",
")",
"error",
"{",
"_",
",",
"err",
":=",
"d",
".",
"fs",
".",
"Stat",
"(",
"fileName",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"old",
"!=",
"nil",
"{",
"fRead",
",",
"err",
":=",
"d",
".",
"fs",
".",
"Open",
"(",
"fileName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"ref",
",",
"err",
":=",
"d",
".",
"readReferenceFrom",
"(",
"fRead",
",",
"old",
".",
"Name",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"fRead",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"ref",
".",
"Hash",
"(",
")",
"!=",
"old",
".",
"Hash",
"(",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"f",
",",
"err",
":=",
"d",
".",
"fs",
".",
"Create",
"(",
"fileName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"_",
",",
"err",
"=",
"f",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"content",
")",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // There are some filesystems that don't support opening files in RDWD mode.
// In these filesystems the standard SetRef function can not be used as it
// reads the reference file to check that it's not modified before updating it.
//
// This version of the function writes the reference without extra checks
// making it compatible with these simple filesystems. This is usually not
// a problem as they should be accessed by only one process at a time. | [
"There",
"are",
"some",
"filesystems",
"that",
"don",
"t",
"support",
"opening",
"files",
"in",
"RDWD",
"mode",
".",
"In",
"these",
"filesystems",
"the",
"standard",
"SetRef",
"function",
"can",
"not",
"be",
"used",
"as",
"it",
"reads",
"the",
"reference",
"file",
"to",
"check",
"that",
"it",
"s",
"not",
"modified",
"before",
"updating",
"it",
".",
"This",
"version",
"of",
"the",
"function",
"writes",
"the",
"reference",
"without",
"extra",
"checks",
"making",
"it",
"compatible",
"with",
"these",
"simple",
"filesystems",
".",
"This",
"is",
"usually",
"not",
"a",
"problem",
"as",
"they",
"should",
"be",
"accessed",
"by",
"only",
"one",
"process",
"at",
"a",
"time",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit_setref.go#L61-L90 | train |
src-d/go-git | _examples/branch/main.go | main | func main() {
CheckArgs("<url>", "<directory>")
url, directory := os.Args[1], os.Args[2]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
})
CheckIfError(err)
// Create a new branch to the current HEAD
Info("git branch my-branch")
headRef, err := r.Head()
CheckIfError(err)
// Create a new plumbing.HashReference object with the name of the branch
// and the hash from the HEAD. The reference name should be a full reference
// name and not an abbreviated one, as is used on the git cli.
//
// For tags we should use `refs/tags/%s` instead of `refs/heads/%s` used
// for branches.
ref := plumbing.NewHashReference("refs/heads/my-branch", headRef.Hash())
// The created reference is saved in the storage.
err = r.Storer.SetReference(ref)
CheckIfError(err)
// Or deleted from it.
Info("git branch -D my-branch")
err = r.Storer.RemoveReference(ref.Name())
CheckIfError(err)
} | go | func main() {
CheckArgs("<url>", "<directory>")
url, directory := os.Args[1], os.Args[2]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
})
CheckIfError(err)
// Create a new branch to the current HEAD
Info("git branch my-branch")
headRef, err := r.Head()
CheckIfError(err)
// Create a new plumbing.HashReference object with the name of the branch
// and the hash from the HEAD. The reference name should be a full reference
// name and not an abbreviated one, as is used on the git cli.
//
// For tags we should use `refs/tags/%s` instead of `refs/heads/%s` used
// for branches.
ref := plumbing.NewHashReference("refs/heads/my-branch", headRef.Hash())
// The created reference is saved in the storage.
err = r.Storer.SetReference(ref)
CheckIfError(err)
// Or deleted from it.
Info("git branch -D my-branch")
err = r.Storer.RemoveReference(ref.Name())
CheckIfError(err)
} | [
"func",
"main",
"(",
")",
"{",
"CheckArgs",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"url",
",",
"directory",
":=",
"os",
".",
"Args",
"[",
"1",
"]",
",",
"os",
".",
"Args",
"[",
"2",
"]",
"\n\n",
"// Clone the given repository to the given directory",
"Info",
"(",
"\"",
"\"",
",",
"url",
",",
"directory",
")",
"\n",
"r",
",",
"err",
":=",
"git",
".",
"PlainClone",
"(",
"directory",
",",
"false",
",",
"&",
"git",
".",
"CloneOptions",
"{",
"URL",
":",
"url",
",",
"}",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"// Create a new branch to the current HEAD",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"headRef",
",",
"err",
":=",
"r",
".",
"Head",
"(",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"// Create a new plumbing.HashReference object with the name of the branch",
"// and the hash from the HEAD. The reference name should be a full reference",
"// name and not an abbreviated one, as is used on the git cli.",
"//",
"// For tags we should use `refs/tags/%s` instead of `refs/heads/%s` used",
"// for branches.",
"ref",
":=",
"plumbing",
".",
"NewHashReference",
"(",
"\"",
"\"",
",",
"headRef",
".",
"Hash",
"(",
")",
")",
"\n\n",
"// The created reference is saved in the storage.",
"err",
"=",
"r",
".",
"Storer",
".",
"SetReference",
"(",
"ref",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"// Or deleted from it.",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"err",
"=",
"r",
".",
"Storer",
".",
"RemoveReference",
"(",
"ref",
".",
"Name",
"(",
")",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n",
"}"
] | // An example of how to create and remove branches or any other kind of reference. | [
"An",
"example",
"of",
"how",
"to",
"create",
"and",
"remove",
"branches",
"or",
"any",
"other",
"kind",
"of",
"reference",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/_examples/branch/main.go#L12-L45 | train |
src-d/go-git | utils/ioutil/common.go | NonEmptyReader | func NonEmptyReader(r io.Reader) (io.Reader, error) {
pr, ok := r.(readPeeker)
if !ok {
pr = bufio.NewReader(r)
}
_, err := pr.Peek(1)
if err == io.EOF {
return nil, ErrEmptyReader
}
if err != nil {
return nil, err
}
return pr, nil
} | go | func NonEmptyReader(r io.Reader) (io.Reader, error) {
pr, ok := r.(readPeeker)
if !ok {
pr = bufio.NewReader(r)
}
_, err := pr.Peek(1)
if err == io.EOF {
return nil, ErrEmptyReader
}
if err != nil {
return nil, err
}
return pr, nil
} | [
"func",
"NonEmptyReader",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"io",
".",
"Reader",
",",
"error",
")",
"{",
"pr",
",",
"ok",
":=",
"r",
".",
"(",
"readPeeker",
")",
"\n",
"if",
"!",
"ok",
"{",
"pr",
"=",
"bufio",
".",
"NewReader",
"(",
"r",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"pr",
".",
"Peek",
"(",
"1",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"return",
"nil",
",",
"ErrEmptyReader",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"pr",
",",
"nil",
"\n",
"}"
] | // NonEmptyReader takes a reader and returns it if it is not empty, or
// `ErrEmptyReader` if it is empty. If there is an error when reading the first
// byte of the given reader, it will be propagated. | [
"NonEmptyReader",
"takes",
"a",
"reader",
"and",
"returns",
"it",
"if",
"it",
"is",
"not",
"empty",
"or",
"ErrEmptyReader",
"if",
"it",
"is",
"empty",
".",
"If",
"there",
"is",
"an",
"error",
"when",
"reading",
"the",
"first",
"byte",
"of",
"the",
"given",
"reader",
"it",
"will",
"be",
"propagated",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/ioutil/common.go#L25-L41 | train |
src-d/go-git | utils/ioutil/common.go | NewReadCloser | func NewReadCloser(r io.Reader, c io.Closer) io.ReadCloser {
return &readCloser{Reader: r, closer: c}
} | go | func NewReadCloser(r io.Reader, c io.Closer) io.ReadCloser {
return &readCloser{Reader: r, closer: c}
} | [
"func",
"NewReadCloser",
"(",
"r",
"io",
".",
"Reader",
",",
"c",
"io",
".",
"Closer",
")",
"io",
".",
"ReadCloser",
"{",
"return",
"&",
"readCloser",
"{",
"Reader",
":",
"r",
",",
"closer",
":",
"c",
"}",
"\n",
"}"
] | // NewReadCloser creates an `io.ReadCloser` with the given `io.Reader` and
// `io.Closer`. | [
"NewReadCloser",
"creates",
"an",
"io",
".",
"ReadCloser",
"with",
"the",
"given",
"io",
".",
"Reader",
"and",
"io",
".",
"Closer",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/ioutil/common.go#L54-L56 | train |
src-d/go-git | utils/ioutil/common.go | NewWriteCloser | func NewWriteCloser(w io.Writer, c io.Closer) io.WriteCloser {
return &writeCloser{Writer: w, closer: c}
} | go | func NewWriteCloser(w io.Writer, c io.Closer) io.WriteCloser {
return &writeCloser{Writer: w, closer: c}
} | [
"func",
"NewWriteCloser",
"(",
"w",
"io",
".",
"Writer",
",",
"c",
"io",
".",
"Closer",
")",
"io",
".",
"WriteCloser",
"{",
"return",
"&",
"writeCloser",
"{",
"Writer",
":",
"w",
",",
"closer",
":",
"c",
"}",
"\n",
"}"
] | // NewWriteCloser creates an `io.WriteCloser` with the given `io.Writer` and
// `io.Closer`. | [
"NewWriteCloser",
"creates",
"an",
"io",
".",
"WriteCloser",
"with",
"the",
"given",
"io",
".",
"Writer",
"and",
"io",
".",
"Closer",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/ioutil/common.go#L69-L71 | train |
src-d/go-git | utils/ioutil/common.go | NewContextWriteCloser | func NewContextWriteCloser(ctx context.Context, w io.WriteCloser) io.WriteCloser {
ctxw := ctxio.NewWriter(ctx, w)
return NewWriteCloser(ctxw, w)
} | go | func NewContextWriteCloser(ctx context.Context, w io.WriteCloser) io.WriteCloser {
ctxw := ctxio.NewWriter(ctx, w)
return NewWriteCloser(ctxw, w)
} | [
"func",
"NewContextWriteCloser",
"(",
"ctx",
"context",
".",
"Context",
",",
"w",
"io",
".",
"WriteCloser",
")",
"io",
".",
"WriteCloser",
"{",
"ctxw",
":=",
"ctxio",
".",
"NewWriter",
"(",
"ctx",
",",
"w",
")",
"\n",
"return",
"NewWriteCloser",
"(",
"ctxw",
",",
"w",
")",
"\n",
"}"
] | // NewContextWriteCloser as NewContextWriter but with io.Closer interface. | [
"NewContextWriteCloser",
"as",
"NewContextWriter",
"but",
"with",
"io",
".",
"Closer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/ioutil/common.go#L109-L112 | train |
src-d/go-git | utils/ioutil/common.go | NewContextReadCloser | func NewContextReadCloser(ctx context.Context, r io.ReadCloser) io.ReadCloser {
ctxr := ctxio.NewReader(ctx, r)
return NewReadCloser(ctxr, r)
} | go | func NewContextReadCloser(ctx context.Context, r io.ReadCloser) io.ReadCloser {
ctxr := ctxio.NewReader(ctx, r)
return NewReadCloser(ctxr, r)
} | [
"func",
"NewContextReadCloser",
"(",
"ctx",
"context",
".",
"Context",
",",
"r",
"io",
".",
"ReadCloser",
")",
"io",
".",
"ReadCloser",
"{",
"ctxr",
":=",
"ctxio",
".",
"NewReader",
"(",
"ctx",
",",
"r",
")",
"\n",
"return",
"NewReadCloser",
"(",
"ctxr",
",",
"r",
")",
"\n",
"}"
] | // NewContextReadCloser as NewContextReader but with io.Closer interface. | [
"NewContextReadCloser",
"as",
"NewContextReader",
"but",
"with",
"io",
".",
"Closer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/ioutil/common.go#L115-L118 | train |
src-d/go-git | utils/diff/diff.go | Dst | func Dst(diffs []diffmatchpatch.Diff) string {
var text bytes.Buffer
for _, d := range diffs {
if d.Type != diffmatchpatch.DiffDelete {
text.WriteString(d.Text)
}
}
return text.String()
} | go | func Dst(diffs []diffmatchpatch.Diff) string {
var text bytes.Buffer
for _, d := range diffs {
if d.Type != diffmatchpatch.DiffDelete {
text.WriteString(d.Text)
}
}
return text.String()
} | [
"func",
"Dst",
"(",
"diffs",
"[",
"]",
"diffmatchpatch",
".",
"Diff",
")",
"string",
"{",
"var",
"text",
"bytes",
".",
"Buffer",
"\n",
"for",
"_",
",",
"d",
":=",
"range",
"diffs",
"{",
"if",
"d",
".",
"Type",
"!=",
"diffmatchpatch",
".",
"DiffDelete",
"{",
"text",
".",
"WriteString",
"(",
"d",
".",
"Text",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"text",
".",
"String",
"(",
")",
"\n",
"}"
] | // Dst computes and returns the destination text. | [
"Dst",
"computes",
"and",
"returns",
"the",
"destination",
"text",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/diff/diff.go#L42-L50 | train |
src-d/go-git | utils/diff/diff.go | Src | func Src(diffs []diffmatchpatch.Diff) string {
var text bytes.Buffer
for _, d := range diffs {
if d.Type != diffmatchpatch.DiffInsert {
text.WriteString(d.Text)
}
}
return text.String()
} | go | func Src(diffs []diffmatchpatch.Diff) string {
var text bytes.Buffer
for _, d := range diffs {
if d.Type != diffmatchpatch.DiffInsert {
text.WriteString(d.Text)
}
}
return text.String()
} | [
"func",
"Src",
"(",
"diffs",
"[",
"]",
"diffmatchpatch",
".",
"Diff",
")",
"string",
"{",
"var",
"text",
"bytes",
".",
"Buffer",
"\n",
"for",
"_",
",",
"d",
":=",
"range",
"diffs",
"{",
"if",
"d",
".",
"Type",
"!=",
"diffmatchpatch",
".",
"DiffInsert",
"{",
"text",
".",
"WriteString",
"(",
"d",
".",
"Text",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"text",
".",
"String",
"(",
")",
"\n",
"}"
] | // Src computes and returns the source text | [
"Src",
"computes",
"and",
"returns",
"the",
"source",
"text"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/diff/diff.go#L53-L61 | train |
src-d/go-git | plumbing/protocol/packp/advrefs.go | NewAdvRefs | func NewAdvRefs() *AdvRefs {
return &AdvRefs{
Prefix: [][]byte{},
Capabilities: capability.NewList(),
References: make(map[string]plumbing.Hash),
Peeled: make(map[string]plumbing.Hash),
Shallows: []plumbing.Hash{},
}
} | go | func NewAdvRefs() *AdvRefs {
return &AdvRefs{
Prefix: [][]byte{},
Capabilities: capability.NewList(),
References: make(map[string]plumbing.Hash),
Peeled: make(map[string]plumbing.Hash),
Shallows: []plumbing.Hash{},
}
} | [
"func",
"NewAdvRefs",
"(",
")",
"*",
"AdvRefs",
"{",
"return",
"&",
"AdvRefs",
"{",
"Prefix",
":",
"[",
"]",
"[",
"]",
"byte",
"{",
"}",
",",
"Capabilities",
":",
"capability",
".",
"NewList",
"(",
")",
",",
"References",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"plumbing",
".",
"Hash",
")",
",",
"Peeled",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"plumbing",
".",
"Hash",
")",
",",
"Shallows",
":",
"[",
"]",
"plumbing",
".",
"Hash",
"{",
"}",
",",
"}",
"\n",
"}"
] | // NewAdvRefs returns a pointer to a new AdvRefs value, ready to be used. | [
"NewAdvRefs",
"returns",
"a",
"pointer",
"to",
"a",
"new",
"AdvRefs",
"value",
"ready",
"to",
"be",
"used",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/advrefs.go#L46-L54 | train |
src-d/go-git | plumbing/protocol/packp/uppackresp.go | NewUploadPackResponse | func NewUploadPackResponse(req *UploadPackRequest) *UploadPackResponse {
isShallow := !req.Depth.IsZero()
isMultiACK := req.Capabilities.Supports(capability.MultiACK) ||
req.Capabilities.Supports(capability.MultiACKDetailed)
return &UploadPackResponse{
isShallow: isShallow,
isMultiACK: isMultiACK,
}
} | go | func NewUploadPackResponse(req *UploadPackRequest) *UploadPackResponse {
isShallow := !req.Depth.IsZero()
isMultiACK := req.Capabilities.Supports(capability.MultiACK) ||
req.Capabilities.Supports(capability.MultiACKDetailed)
return &UploadPackResponse{
isShallow: isShallow,
isMultiACK: isMultiACK,
}
} | [
"func",
"NewUploadPackResponse",
"(",
"req",
"*",
"UploadPackRequest",
")",
"*",
"UploadPackResponse",
"{",
"isShallow",
":=",
"!",
"req",
".",
"Depth",
".",
"IsZero",
"(",
")",
"\n",
"isMultiACK",
":=",
"req",
".",
"Capabilities",
".",
"Supports",
"(",
"capability",
".",
"MultiACK",
")",
"||",
"req",
".",
"Capabilities",
".",
"Supports",
"(",
"capability",
".",
"MultiACKDetailed",
")",
"\n\n",
"return",
"&",
"UploadPackResponse",
"{",
"isShallow",
":",
"isShallow",
",",
"isMultiACK",
":",
"isMultiACK",
",",
"}",
"\n",
"}"
] | // NewUploadPackResponse create a new UploadPackResponse instance, the request
// being responded by the response is required. | [
"NewUploadPackResponse",
"create",
"a",
"new",
"UploadPackResponse",
"instance",
"the",
"request",
"being",
"responded",
"by",
"the",
"response",
"is",
"required",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/uppackresp.go#L32-L41 | train |
src-d/go-git | plumbing/protocol/packp/uppackresp.go | NewUploadPackResponseWithPackfile | func NewUploadPackResponseWithPackfile(req *UploadPackRequest,
pf io.ReadCloser) *UploadPackResponse {
r := NewUploadPackResponse(req)
r.r = pf
return r
} | go | func NewUploadPackResponseWithPackfile(req *UploadPackRequest,
pf io.ReadCloser) *UploadPackResponse {
r := NewUploadPackResponse(req)
r.r = pf
return r
} | [
"func",
"NewUploadPackResponseWithPackfile",
"(",
"req",
"*",
"UploadPackRequest",
",",
"pf",
"io",
".",
"ReadCloser",
")",
"*",
"UploadPackResponse",
"{",
"r",
":=",
"NewUploadPackResponse",
"(",
"req",
")",
"\n",
"r",
".",
"r",
"=",
"pf",
"\n",
"return",
"r",
"\n",
"}"
] | // NewUploadPackResponseWithPackfile creates a new UploadPackResponse instance,
// and sets its packfile reader. | [
"NewUploadPackResponseWithPackfile",
"creates",
"a",
"new",
"UploadPackResponse",
"instance",
"and",
"sets",
"its",
"packfile",
"reader",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/uppackresp.go#L45-L51 | train |
src-d/go-git | plumbing/protocol/packp/uppackresp.go | Decode | func (r *UploadPackResponse) Decode(reader io.ReadCloser) error {
buf := bufio.NewReader(reader)
if r.isShallow {
if err := r.ShallowUpdate.Decode(buf); err != nil {
return err
}
}
if err := r.ServerResponse.Decode(buf, r.isMultiACK); err != nil {
return err
}
// now the reader is ready to read the packfile content
r.r = ioutil.NewReadCloser(buf, reader)
return nil
} | go | func (r *UploadPackResponse) Decode(reader io.ReadCloser) error {
buf := bufio.NewReader(reader)
if r.isShallow {
if err := r.ShallowUpdate.Decode(buf); err != nil {
return err
}
}
if err := r.ServerResponse.Decode(buf, r.isMultiACK); err != nil {
return err
}
// now the reader is ready to read the packfile content
r.r = ioutil.NewReadCloser(buf, reader)
return nil
} | [
"func",
"(",
"r",
"*",
"UploadPackResponse",
")",
"Decode",
"(",
"reader",
"io",
".",
"ReadCloser",
")",
"error",
"{",
"buf",
":=",
"bufio",
".",
"NewReader",
"(",
"reader",
")",
"\n\n",
"if",
"r",
".",
"isShallow",
"{",
"if",
"err",
":=",
"r",
".",
"ShallowUpdate",
".",
"Decode",
"(",
"buf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"r",
".",
"ServerResponse",
".",
"Decode",
"(",
"buf",
",",
"r",
".",
"isMultiACK",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// now the reader is ready to read the packfile content",
"r",
".",
"r",
"=",
"ioutil",
".",
"NewReadCloser",
"(",
"buf",
",",
"reader",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Decode decodes all the responses sent by upload-pack service into the struct
// and prepares it to read the packfile using the Read method | [
"Decode",
"decodes",
"all",
"the",
"responses",
"sent",
"by",
"upload",
"-",
"pack",
"service",
"into",
"the",
"struct",
"and",
"prepares",
"it",
"to",
"read",
"the",
"packfile",
"using",
"the",
"Read",
"method"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/uppackresp.go#L55-L72 | train |
src-d/go-git | plumbing/protocol/packp/uppackresp.go | Encode | func (r *UploadPackResponse) Encode(w io.Writer) (err error) {
if r.isShallow {
if err := r.ShallowUpdate.Encode(w); err != nil {
return err
}
}
if err := r.ServerResponse.Encode(w); err != nil {
return err
}
defer ioutil.CheckClose(r.r, &err)
_, err = io.Copy(w, r.r)
return err
} | go | func (r *UploadPackResponse) Encode(w io.Writer) (err error) {
if r.isShallow {
if err := r.ShallowUpdate.Encode(w); err != nil {
return err
}
}
if err := r.ServerResponse.Encode(w); err != nil {
return err
}
defer ioutil.CheckClose(r.r, &err)
_, err = io.Copy(w, r.r)
return err
} | [
"func",
"(",
"r",
"*",
"UploadPackResponse",
")",
"Encode",
"(",
"w",
"io",
".",
"Writer",
")",
"(",
"err",
"error",
")",
"{",
"if",
"r",
".",
"isShallow",
"{",
"if",
"err",
":=",
"r",
".",
"ShallowUpdate",
".",
"Encode",
"(",
"w",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"r",
".",
"ServerResponse",
".",
"Encode",
"(",
"w",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"defer",
"ioutil",
".",
"CheckClose",
"(",
"r",
".",
"r",
",",
"&",
"err",
")",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"w",
",",
"r",
".",
"r",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Encode encodes an UploadPackResponse. | [
"Encode",
"encodes",
"an",
"UploadPackResponse",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/uppackresp.go#L75-L89 | train |
src-d/go-git | plumbing/protocol/packp/uppackresp.go | Read | func (r *UploadPackResponse) Read(p []byte) (int, error) {
if r.r == nil {
return 0, ErrUploadPackResponseNotDecoded
}
return r.r.Read(p)
} | go | func (r *UploadPackResponse) Read(p []byte) (int, error) {
if r.r == nil {
return 0, ErrUploadPackResponseNotDecoded
}
return r.r.Read(p)
} | [
"func",
"(",
"r",
"*",
"UploadPackResponse",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"r",
".",
"r",
"==",
"nil",
"{",
"return",
"0",
",",
"ErrUploadPackResponseNotDecoded",
"\n",
"}",
"\n\n",
"return",
"r",
".",
"r",
".",
"Read",
"(",
"p",
")",
"\n",
"}"
] | // Read reads the packfile data, if the request was done with any Sideband
// capability the content read should be demultiplexed. If the methods wasn't
// called before the ErrUploadPackResponseNotDecoded will be return | [
"Read",
"reads",
"the",
"packfile",
"data",
"if",
"the",
"request",
"was",
"done",
"with",
"any",
"Sideband",
"capability",
"the",
"content",
"read",
"should",
"be",
"demultiplexed",
".",
"If",
"the",
"methods",
"wasn",
"t",
"called",
"before",
"the",
"ErrUploadPackResponseNotDecoded",
"will",
"be",
"return"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/uppackresp.go#L94-L100 | train |
src-d/go-git | plumbing/protocol/packp/uppackresp.go | Close | func (r *UploadPackResponse) Close() error {
if r.r == nil {
return nil
}
return r.r.Close()
} | go | func (r *UploadPackResponse) Close() error {
if r.r == nil {
return nil
}
return r.r.Close()
} | [
"func",
"(",
"r",
"*",
"UploadPackResponse",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"r",
".",
"r",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"r",
".",
"r",
".",
"Close",
"(",
")",
"\n",
"}"
] | // Close the underlying reader, if any | [
"Close",
"the",
"underlying",
"reader",
"if",
"any"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/uppackresp.go#L103-L109 | train |
src-d/go-git | storage/transactional/shallow.go | NewShallowStorage | func NewShallowStorage(base, temporal storer.ShallowStorer) *ShallowStorage {
return &ShallowStorage{
ShallowStorer: base,
temporal: temporal,
}
} | go | func NewShallowStorage(base, temporal storer.ShallowStorer) *ShallowStorage {
return &ShallowStorage{
ShallowStorer: base,
temporal: temporal,
}
} | [
"func",
"NewShallowStorage",
"(",
"base",
",",
"temporal",
"storer",
".",
"ShallowStorer",
")",
"*",
"ShallowStorage",
"{",
"return",
"&",
"ShallowStorage",
"{",
"ShallowStorer",
":",
"base",
",",
"temporal",
":",
"temporal",
",",
"}",
"\n",
"}"
] | // NewShallowStorage returns a new ShallowStorage based on a base storer and
// a temporal storer. | [
"NewShallowStorage",
"returns",
"a",
"new",
"ShallowStorage",
"based",
"on",
"a",
"base",
"storer",
"and",
"a",
"temporal",
"storer",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/shallow.go#L16-L21 | train |
src-d/go-git | storage/transactional/shallow.go | SetShallow | func (s *ShallowStorage) SetShallow(commits []plumbing.Hash) error {
return s.temporal.SetShallow(commits)
} | go | func (s *ShallowStorage) SetShallow(commits []plumbing.Hash) error {
return s.temporal.SetShallow(commits)
} | [
"func",
"(",
"s",
"*",
"ShallowStorage",
")",
"SetShallow",
"(",
"commits",
"[",
"]",
"plumbing",
".",
"Hash",
")",
"error",
"{",
"return",
"s",
".",
"temporal",
".",
"SetShallow",
"(",
"commits",
")",
"\n",
"}"
] | // SetShallow honors the storer.ShallowStorer interface. | [
"SetShallow",
"honors",
"the",
"storer",
".",
"ShallowStorer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/shallow.go#L24-L26 | train |
src-d/go-git | storage/transactional/shallow.go | Shallow | func (s *ShallowStorage) Shallow() ([]plumbing.Hash, error) {
shallow, err := s.temporal.Shallow()
if err != nil {
return nil, err
}
if len(shallow) != 0 {
return shallow, nil
}
return s.ShallowStorer.Shallow()
} | go | func (s *ShallowStorage) Shallow() ([]plumbing.Hash, error) {
shallow, err := s.temporal.Shallow()
if err != nil {
return nil, err
}
if len(shallow) != 0 {
return shallow, nil
}
return s.ShallowStorer.Shallow()
} | [
"func",
"(",
"s",
"*",
"ShallowStorage",
")",
"Shallow",
"(",
")",
"(",
"[",
"]",
"plumbing",
".",
"Hash",
",",
"error",
")",
"{",
"shallow",
",",
"err",
":=",
"s",
".",
"temporal",
".",
"Shallow",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"shallow",
")",
"!=",
"0",
"{",
"return",
"shallow",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"ShallowStorer",
".",
"Shallow",
"(",
")",
"\n",
"}"
] | // Shallow honors the storer.ShallowStorer interface. | [
"Shallow",
"honors",
"the",
"storer",
".",
"ShallowStorer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/shallow.go#L29-L40 | train |
src-d/go-git | storage/transactional/shallow.go | Commit | func (s *ShallowStorage) Commit() error {
commits, err := s.temporal.Shallow()
if err != nil || len(commits) == 0 {
return err
}
return s.ShallowStorer.SetShallow(commits)
} | go | func (s *ShallowStorage) Commit() error {
commits, err := s.temporal.Shallow()
if err != nil || len(commits) == 0 {
return err
}
return s.ShallowStorer.SetShallow(commits)
} | [
"func",
"(",
"s",
"*",
"ShallowStorage",
")",
"Commit",
"(",
")",
"error",
"{",
"commits",
",",
"err",
":=",
"s",
".",
"temporal",
".",
"Shallow",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"len",
"(",
"commits",
")",
"==",
"0",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"ShallowStorer",
".",
"SetShallow",
"(",
"commits",
")",
"\n",
"}"
] | // Commit it copies the shallow information of the temporal storage into the
// base storage. | [
"Commit",
"it",
"copies",
"the",
"shallow",
"information",
"of",
"the",
"temporal",
"storage",
"into",
"the",
"base",
"storage",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/shallow.go#L44-L51 | train |
src-d/go-git | plumbing/transport/server/server.go | NewServer | func NewServer(loader Loader) transport.Transport {
return &server{
loader,
&handler{asClient: false},
}
} | go | func NewServer(loader Loader) transport.Transport {
return &server{
loader,
&handler{asClient: false},
}
} | [
"func",
"NewServer",
"(",
"loader",
"Loader",
")",
"transport",
".",
"Transport",
"{",
"return",
"&",
"server",
"{",
"loader",
",",
"&",
"handler",
"{",
"asClient",
":",
"false",
"}",
",",
"}",
"\n",
"}"
] | // NewServer returns a transport.Transport implementing a git server,
// independent of transport. Each transport must wrap this. | [
"NewServer",
"returns",
"a",
"transport",
".",
"Transport",
"implementing",
"a",
"git",
"server",
"independent",
"of",
"transport",
".",
"Each",
"transport",
"must",
"wrap",
"this",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/server/server.go#L30-L35 | train |
src-d/go-git | plumbing/transport/server/server.go | NewClient | func NewClient(loader Loader) transport.Transport {
return &server{
loader,
&handler{asClient: true},
}
} | go | func NewClient(loader Loader) transport.Transport {
return &server{
loader,
&handler{asClient: true},
}
} | [
"func",
"NewClient",
"(",
"loader",
"Loader",
")",
"transport",
".",
"Transport",
"{",
"return",
"&",
"server",
"{",
"loader",
",",
"&",
"handler",
"{",
"asClient",
":",
"true",
"}",
",",
"}",
"\n",
"}"
] | // NewClient returns a transport.Transport implementing a client with an
// embedded server. | [
"NewClient",
"returns",
"a",
"transport",
".",
"Transport",
"implementing",
"a",
"client",
"with",
"an",
"embedded",
"server",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/server/server.go#L39-L44 | train |
src-d/go-git | plumbing/storer/object.go | NewEncodedObjectLookupIter | func NewEncodedObjectLookupIter(
storage EncodedObjectStorer, t plumbing.ObjectType, series []plumbing.Hash) *EncodedObjectLookupIter {
return &EncodedObjectLookupIter{
storage: storage,
series: series,
t: t,
}
} | go | func NewEncodedObjectLookupIter(
storage EncodedObjectStorer, t plumbing.ObjectType, series []plumbing.Hash) *EncodedObjectLookupIter {
return &EncodedObjectLookupIter{
storage: storage,
series: series,
t: t,
}
} | [
"func",
"NewEncodedObjectLookupIter",
"(",
"storage",
"EncodedObjectStorer",
",",
"t",
"plumbing",
".",
"ObjectType",
",",
"series",
"[",
"]",
"plumbing",
".",
"Hash",
")",
"*",
"EncodedObjectLookupIter",
"{",
"return",
"&",
"EncodedObjectLookupIter",
"{",
"storage",
":",
"storage",
",",
"series",
":",
"series",
",",
"t",
":",
"t",
",",
"}",
"\n",
"}"
] | // NewEncodedObjectLookupIter returns an object iterator given an object storage
// and a slice of object hashes. | [
"NewEncodedObjectLookupIter",
"returns",
"an",
"object",
"iterator",
"given",
"an",
"object",
"storage",
"and",
"a",
"slice",
"of",
"object",
"hashes",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/storer/object.go#L132-L139 | train |
src-d/go-git | plumbing/storer/object.go | Next | func (iter *EncodedObjectLookupIter) Next() (plumbing.EncodedObject, error) {
if iter.pos >= len(iter.series) {
return nil, io.EOF
}
hash := iter.series[iter.pos]
obj, err := iter.storage.EncodedObject(iter.t, hash)
if err == nil {
iter.pos++
}
return obj, err
} | go | func (iter *EncodedObjectLookupIter) Next() (plumbing.EncodedObject, error) {
if iter.pos >= len(iter.series) {
return nil, io.EOF
}
hash := iter.series[iter.pos]
obj, err := iter.storage.EncodedObject(iter.t, hash)
if err == nil {
iter.pos++
}
return obj, err
} | [
"func",
"(",
"iter",
"*",
"EncodedObjectLookupIter",
")",
"Next",
"(",
")",
"(",
"plumbing",
".",
"EncodedObject",
",",
"error",
")",
"{",
"if",
"iter",
".",
"pos",
">=",
"len",
"(",
"iter",
".",
"series",
")",
"{",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n\n",
"hash",
":=",
"iter",
".",
"series",
"[",
"iter",
".",
"pos",
"]",
"\n",
"obj",
",",
"err",
":=",
"iter",
".",
"storage",
".",
"EncodedObject",
"(",
"iter",
".",
"t",
",",
"hash",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"iter",
".",
"pos",
"++",
"\n",
"}",
"\n\n",
"return",
"obj",
",",
"err",
"\n",
"}"
] | // Next returns the next object from the iterator. If the iterator has reached
// the end it will return io.EOF as an error. If the object can't be found in
// the object storage, it will return plumbing.ErrObjectNotFound as an error.
// If the object is retreieved successfully error will be nil. | [
"Next",
"returns",
"the",
"next",
"object",
"from",
"the",
"iterator",
".",
"If",
"the",
"iterator",
"has",
"reached",
"the",
"end",
"it",
"will",
"return",
"io",
".",
"EOF",
"as",
"an",
"error",
".",
"If",
"the",
"object",
"can",
"t",
"be",
"found",
"in",
"the",
"object",
"storage",
"it",
"will",
"return",
"plumbing",
".",
"ErrObjectNotFound",
"as",
"an",
"error",
".",
"If",
"the",
"object",
"is",
"retreieved",
"successfully",
"error",
"will",
"be",
"nil",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/storer/object.go#L145-L157 | train |
src-d/go-git | plumbing/storer/object.go | Next | func (iter *EncodedObjectSliceIter) Next() (plumbing.EncodedObject, error) {
if len(iter.series) == 0 {
return nil, io.EOF
}
obj := iter.series[0]
iter.series = iter.series[1:]
return obj, nil
} | go | func (iter *EncodedObjectSliceIter) Next() (plumbing.EncodedObject, error) {
if len(iter.series) == 0 {
return nil, io.EOF
}
obj := iter.series[0]
iter.series = iter.series[1:]
return obj, nil
} | [
"func",
"(",
"iter",
"*",
"EncodedObjectSliceIter",
")",
"Next",
"(",
")",
"(",
"plumbing",
".",
"EncodedObject",
",",
"error",
")",
"{",
"if",
"len",
"(",
"iter",
".",
"series",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n\n",
"obj",
":=",
"iter",
".",
"series",
"[",
"0",
"]",
"\n",
"iter",
".",
"series",
"=",
"iter",
".",
"series",
"[",
"1",
":",
"]",
"\n\n",
"return",
"obj",
",",
"nil",
"\n",
"}"
] | // Next returns the next object from the iterator. If the iterator has reached
// the end it will return io.EOF as an error. If the object is retreieved
// successfully error will be nil. | [
"Next",
"returns",
"the",
"next",
"object",
"from",
"the",
"iterator",
".",
"If",
"the",
"iterator",
"has",
"reached",
"the",
"end",
"it",
"will",
"return",
"io",
".",
"EOF",
"as",
"an",
"error",
".",
"If",
"the",
"object",
"is",
"retreieved",
"successfully",
"error",
"will",
"be",
"nil",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/storer/object.go#L192-L201 | train |
src-d/go-git | plumbing/storer/object.go | Next | func (iter *MultiEncodedObjectIter) Next() (plumbing.EncodedObject, error) {
if len(iter.iters) == 0 {
return nil, io.EOF
}
obj, err := iter.iters[0].Next()
if err == io.EOF {
iter.iters[0].Close()
iter.iters = iter.iters[1:]
return iter.Next()
}
return obj, err
} | go | func (iter *MultiEncodedObjectIter) Next() (plumbing.EncodedObject, error) {
if len(iter.iters) == 0 {
return nil, io.EOF
}
obj, err := iter.iters[0].Next()
if err == io.EOF {
iter.iters[0].Close()
iter.iters = iter.iters[1:]
return iter.Next()
}
return obj, err
} | [
"func",
"(",
"iter",
"*",
"MultiEncodedObjectIter",
")",
"Next",
"(",
")",
"(",
"plumbing",
".",
"EncodedObject",
",",
"error",
")",
"{",
"if",
"len",
"(",
"iter",
".",
"iters",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n\n",
"obj",
",",
"err",
":=",
"iter",
".",
"iters",
"[",
"0",
"]",
".",
"Next",
"(",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"iter",
".",
"iters",
"[",
"0",
"]",
".",
"Close",
"(",
")",
"\n",
"iter",
".",
"iters",
"=",
"iter",
".",
"iters",
"[",
"1",
":",
"]",
"\n",
"return",
"iter",
".",
"Next",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"obj",
",",
"err",
"\n",
"}"
] | // Next returns the next object from the iterator, if one iterator reach io.EOF
// is removed and the next one is used. | [
"Next",
"returns",
"the",
"next",
"object",
"from",
"the",
"iterator",
"if",
"one",
"iterator",
"reach",
"io",
".",
"EOF",
"is",
"removed",
"and",
"the",
"next",
"one",
"is",
"used",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/storer/object.go#L232-L245 | train |
src-d/go-git | plumbing/storer/object.go | ForEachIterator | func ForEachIterator(iter bareIterator, cb func(plumbing.EncodedObject) error) error {
defer iter.Close()
for {
obj, err := iter.Next()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if err := cb(obj); err != nil {
if err == ErrStop {
return nil
}
return err
}
}
} | go | func ForEachIterator(iter bareIterator, cb func(plumbing.EncodedObject) error) error {
defer iter.Close()
for {
obj, err := iter.Next()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if err := cb(obj); err != nil {
if err == ErrStop {
return nil
}
return err
}
}
} | [
"func",
"ForEachIterator",
"(",
"iter",
"bareIterator",
",",
"cb",
"func",
"(",
"plumbing",
".",
"EncodedObject",
")",
"error",
")",
"error",
"{",
"defer",
"iter",
".",
"Close",
"(",
")",
"\n",
"for",
"{",
"obj",
",",
"err",
":=",
"iter",
".",
"Next",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"cb",
"(",
"obj",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"ErrStop",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // ForEachIterator is a helper function to build iterators without need to
// rewrite the same ForEach function each time. | [
"ForEachIterator",
"is",
"a",
"helper",
"function",
"to",
"build",
"iterators",
"without",
"need",
"to",
"rewrite",
"the",
"same",
"ForEach",
"function",
"each",
"time",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/storer/object.go#L268-L288 | train |
src-d/go-git | plumbing/format/pktline/encoder.go | Flush | func (e *Encoder) Flush() error {
_, err := e.w.Write(FlushPkt)
return err
} | go | func (e *Encoder) Flush() error {
_, err := e.w.Write(FlushPkt)
return err
} | [
"func",
"(",
"e",
"*",
"Encoder",
")",
"Flush",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"e",
".",
"w",
".",
"Write",
"(",
"FlushPkt",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Flush encodes a flush-pkt to the output stream. | [
"Flush",
"encodes",
"a",
"flush",
"-",
"pkt",
"to",
"the",
"output",
"stream",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/pktline/encoder.go#L45-L48 | train |
src-d/go-git | plumbing/format/pktline/encoder.go | Encode | func (e *Encoder) Encode(payloads ...[]byte) error {
for _, p := range payloads {
if err := e.encodeLine(p); err != nil {
return err
}
}
return nil
} | go | func (e *Encoder) Encode(payloads ...[]byte) error {
for _, p := range payloads {
if err := e.encodeLine(p); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"e",
"*",
"Encoder",
")",
"Encode",
"(",
"payloads",
"...",
"[",
"]",
"byte",
")",
"error",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"payloads",
"{",
"if",
"err",
":=",
"e",
".",
"encodeLine",
"(",
"p",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Encode encodes a pkt-line with the payload specified and write it to
// the output stream. If several payloads are specified, each of them
// will get streamed in their own pkt-lines. | [
"Encode",
"encodes",
"a",
"pkt",
"-",
"line",
"with",
"the",
"payload",
"specified",
"and",
"write",
"it",
"to",
"the",
"output",
"stream",
".",
"If",
"several",
"payloads",
"are",
"specified",
"each",
"of",
"them",
"will",
"get",
"streamed",
"in",
"their",
"own",
"pkt",
"-",
"lines",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/pktline/encoder.go#L53-L61 | train |
src-d/go-git | plumbing/format/pktline/encoder.go | EncodeString | func (e *Encoder) EncodeString(payloads ...string) error {
for _, p := range payloads {
if err := e.Encode([]byte(p)); err != nil {
return err
}
}
return nil
} | go | func (e *Encoder) EncodeString(payloads ...string) error {
for _, p := range payloads {
if err := e.Encode([]byte(p)); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"e",
"*",
"Encoder",
")",
"EncodeString",
"(",
"payloads",
"...",
"string",
")",
"error",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"payloads",
"{",
"if",
"err",
":=",
"e",
".",
"Encode",
"(",
"[",
"]",
"byte",
"(",
"p",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // EncodeString works similarly as Encode but payloads are specified as strings. | [
"EncodeString",
"works",
"similarly",
"as",
"Encode",
"but",
"payloads",
"are",
"specified",
"as",
"strings",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/pktline/encoder.go#L105-L113 | train |
src-d/go-git | plumbing/format/pktline/encoder.go | Encodef | func (e *Encoder) Encodef(format string, a ...interface{}) error {
return e.EncodeString(
fmt.Sprintf(format, a...),
)
} | go | func (e *Encoder) Encodef(format string, a ...interface{}) error {
return e.EncodeString(
fmt.Sprintf(format, a...),
)
} | [
"func",
"(",
"e",
"*",
"Encoder",
")",
"Encodef",
"(",
"format",
"string",
",",
"a",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"e",
".",
"EncodeString",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"a",
"...",
")",
",",
")",
"\n",
"}"
] | // Encodef encodes a single pkt-line with the payload formatted as
// the format specifier. The rest of the arguments will be used in
// the format string. | [
"Encodef",
"encodes",
"a",
"single",
"pkt",
"-",
"line",
"with",
"the",
"payload",
"formatted",
"as",
"the",
"format",
"specifier",
".",
"The",
"rest",
"of",
"the",
"arguments",
"will",
"be",
"used",
"in",
"the",
"format",
"string",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/pktline/encoder.go#L118-L122 | train |
src-d/go-git | plumbing/object/blob.go | GetBlob | func GetBlob(s storer.EncodedObjectStorer, h plumbing.Hash) (*Blob, error) {
o, err := s.EncodedObject(plumbing.BlobObject, h)
if err != nil {
return nil, err
}
return DecodeBlob(o)
} | go | func GetBlob(s storer.EncodedObjectStorer, h plumbing.Hash) (*Blob, error) {
o, err := s.EncodedObject(plumbing.BlobObject, h)
if err != nil {
return nil, err
}
return DecodeBlob(o)
} | [
"func",
"GetBlob",
"(",
"s",
"storer",
".",
"EncodedObjectStorer",
",",
"h",
"plumbing",
".",
"Hash",
")",
"(",
"*",
"Blob",
",",
"error",
")",
"{",
"o",
",",
"err",
":=",
"s",
".",
"EncodedObject",
"(",
"plumbing",
".",
"BlobObject",
",",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"DecodeBlob",
"(",
"o",
")",
"\n",
"}"
] | // GetBlob gets a blob from an object storer and decodes it. | [
"GetBlob",
"gets",
"a",
"blob",
"from",
"an",
"object",
"storer",
"and",
"decodes",
"it",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/object/blob.go#L22-L29 | train |
src-d/go-git | plumbing/object/blob.go | Decode | func (b *Blob) Decode(o plumbing.EncodedObject) error {
if o.Type() != plumbing.BlobObject {
return ErrUnsupportedObject
}
b.Hash = o.Hash()
b.Size = o.Size()
b.obj = o
return nil
} | go | func (b *Blob) Decode(o plumbing.EncodedObject) error {
if o.Type() != plumbing.BlobObject {
return ErrUnsupportedObject
}
b.Hash = o.Hash()
b.Size = o.Size()
b.obj = o
return nil
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"Decode",
"(",
"o",
"plumbing",
".",
"EncodedObject",
")",
"error",
"{",
"if",
"o",
".",
"Type",
"(",
")",
"!=",
"plumbing",
".",
"BlobObject",
"{",
"return",
"ErrUnsupportedObject",
"\n",
"}",
"\n\n",
"b",
".",
"Hash",
"=",
"o",
".",
"Hash",
"(",
")",
"\n",
"b",
".",
"Size",
"=",
"o",
".",
"Size",
"(",
")",
"\n",
"b",
".",
"obj",
"=",
"o",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Decode transforms a plumbing.EncodedObject into a Blob struct. | [
"Decode",
"transforms",
"a",
"plumbing",
".",
"EncodedObject",
"into",
"a",
"Blob",
"struct",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/object/blob.go#L57-L67 | train |
src-d/go-git | plumbing/object/blob.go | Encode | func (b *Blob) Encode(o plumbing.EncodedObject) (err error) {
o.SetType(plumbing.BlobObject)
w, err := o.Writer()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
r, err := b.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(r, &err)
_, err = io.Copy(w, r)
return err
} | go | func (b *Blob) Encode(o plumbing.EncodedObject) (err error) {
o.SetType(plumbing.BlobObject)
w, err := o.Writer()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
r, err := b.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(r, &err)
_, err = io.Copy(w, r)
return err
} | [
"func",
"(",
"b",
"*",
"Blob",
")",
"Encode",
"(",
"o",
"plumbing",
".",
"EncodedObject",
")",
"(",
"err",
"error",
")",
"{",
"o",
".",
"SetType",
"(",
"plumbing",
".",
"BlobObject",
")",
"\n\n",
"w",
",",
"err",
":=",
"o",
".",
"Writer",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"defer",
"ioutil",
".",
"CheckClose",
"(",
"w",
",",
"&",
"err",
")",
"\n\n",
"r",
",",
"err",
":=",
"b",
".",
"Reader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"defer",
"ioutil",
".",
"CheckClose",
"(",
"r",
",",
"&",
"err",
")",
"\n\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Encode transforms a Blob into a plumbing.EncodedObject. | [
"Encode",
"transforms",
"a",
"Blob",
"into",
"a",
"plumbing",
".",
"EncodedObject",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/object/blob.go#L70-L89 | train |
src-d/go-git | plumbing/object/blob.go | Next | func (iter *BlobIter) Next() (*Blob, error) {
for {
obj, err := iter.EncodedObjectIter.Next()
if err != nil {
return nil, err
}
if obj.Type() != plumbing.BlobObject {
continue
}
return DecodeBlob(obj)
}
} | go | func (iter *BlobIter) Next() (*Blob, error) {
for {
obj, err := iter.EncodedObjectIter.Next()
if err != nil {
return nil, err
}
if obj.Type() != plumbing.BlobObject {
continue
}
return DecodeBlob(obj)
}
} | [
"func",
"(",
"iter",
"*",
"BlobIter",
")",
"Next",
"(",
")",
"(",
"*",
"Blob",
",",
"error",
")",
"{",
"for",
"{",
"obj",
",",
"err",
":=",
"iter",
".",
"EncodedObjectIter",
".",
"Next",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"obj",
".",
"Type",
"(",
")",
"!=",
"plumbing",
".",
"BlobObject",
"{",
"continue",
"\n",
"}",
"\n\n",
"return",
"DecodeBlob",
"(",
"obj",
")",
"\n",
"}",
"\n",
"}"
] | // Next moves the iterator to the next blob and returns a pointer to it. If
// there are no more blobs, it returns io.EOF. | [
"Next",
"moves",
"the",
"iterator",
"to",
"the",
"next",
"blob",
"and",
"returns",
"a",
"pointer",
"to",
"it",
".",
"If",
"there",
"are",
"no",
"more",
"blobs",
"it",
"returns",
"io",
".",
"EOF",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/object/blob.go#L113-L126 | train |
src-d/go-git | plumbing/object/blob.go | ForEach | func (iter *BlobIter) ForEach(cb func(*Blob) error) error {
return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
if obj.Type() != plumbing.BlobObject {
return nil
}
b, err := DecodeBlob(obj)
if err != nil {
return err
}
return cb(b)
})
} | go | func (iter *BlobIter) ForEach(cb func(*Blob) error) error {
return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
if obj.Type() != plumbing.BlobObject {
return nil
}
b, err := DecodeBlob(obj)
if err != nil {
return err
}
return cb(b)
})
} | [
"func",
"(",
"iter",
"*",
"BlobIter",
")",
"ForEach",
"(",
"cb",
"func",
"(",
"*",
"Blob",
")",
"error",
")",
"error",
"{",
"return",
"iter",
".",
"EncodedObjectIter",
".",
"ForEach",
"(",
"func",
"(",
"obj",
"plumbing",
".",
"EncodedObject",
")",
"error",
"{",
"if",
"obj",
".",
"Type",
"(",
")",
"!=",
"plumbing",
".",
"BlobObject",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"b",
",",
"err",
":=",
"DecodeBlob",
"(",
"obj",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"cb",
"(",
"b",
")",
"\n",
"}",
")",
"\n",
"}"
] | // 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. | [
"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",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/object/blob.go#L131-L144 | train |
src-d/go-git | plumbing/protocol/packp/updreq_decode.go | Decode | func (req *ReferenceUpdateRequest) Decode(r io.Reader) error {
var rc io.ReadCloser
var ok bool
rc, ok = r.(io.ReadCloser)
if !ok {
rc = ioutil.NopCloser(r)
}
d := &updReqDecoder{r: rc, s: pktline.NewScanner(r)}
return d.Decode(req)
} | go | func (req *ReferenceUpdateRequest) Decode(r io.Reader) error {
var rc io.ReadCloser
var ok bool
rc, ok = r.(io.ReadCloser)
if !ok {
rc = ioutil.NopCloser(r)
}
d := &updReqDecoder{r: rc, s: pktline.NewScanner(r)}
return d.Decode(req)
} | [
"func",
"(",
"req",
"*",
"ReferenceUpdateRequest",
")",
"Decode",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"var",
"rc",
"io",
".",
"ReadCloser",
"\n",
"var",
"ok",
"bool",
"\n",
"rc",
",",
"ok",
"=",
"r",
".",
"(",
"io",
".",
"ReadCloser",
")",
"\n",
"if",
"!",
"ok",
"{",
"rc",
"=",
"ioutil",
".",
"NopCloser",
"(",
"r",
")",
"\n",
"}",
"\n\n",
"d",
":=",
"&",
"updReqDecoder",
"{",
"r",
":",
"rc",
",",
"s",
":",
"pktline",
".",
"NewScanner",
"(",
"r",
")",
"}",
"\n",
"return",
"d",
".",
"Decode",
"(",
"req",
")",
"\n",
"}"
] | // Decode reads the next update-request message form the reader and wr | [
"Decode",
"reads",
"the",
"next",
"update",
"-",
"request",
"message",
"form",
"the",
"reader",
"and",
"wr"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/updreq_decode.go#L79-L89 | train |
src-d/go-git | _examples/custom_http/main.go | main | func main() {
CheckArgs("<url>")
url := os.Args[1]
// Create a custom http(s) client with your config
customClient := &http.Client{
// accept any certificate (might be useful for testing)
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
// 15 second timeout
Timeout: 15 * time.Second,
// don't follow redirect
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
}
// Override http(s) default protocol to use our custom client
client.InstallProtocol("https", githttp.NewClient(customClient))
// Clone repository using the new client if the protocol is https://
Info("git clone %s", url)
r, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{URL: url})
CheckIfError(err)
// Retrieve the branch pointed by HEAD
Info("git rev-parse HEAD")
head, err := r.Head()
CheckIfError(err)
fmt.Println(head.Hash())
} | go | func main() {
CheckArgs("<url>")
url := os.Args[1]
// Create a custom http(s) client with your config
customClient := &http.Client{
// accept any certificate (might be useful for testing)
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
// 15 second timeout
Timeout: 15 * time.Second,
// don't follow redirect
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
}
// Override http(s) default protocol to use our custom client
client.InstallProtocol("https", githttp.NewClient(customClient))
// Clone repository using the new client if the protocol is https://
Info("git clone %s", url)
r, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{URL: url})
CheckIfError(err)
// Retrieve the branch pointed by HEAD
Info("git rev-parse HEAD")
head, err := r.Head()
CheckIfError(err)
fmt.Println(head.Hash())
} | [
"func",
"main",
"(",
")",
"{",
"CheckArgs",
"(",
"\"",
"\"",
")",
"\n",
"url",
":=",
"os",
".",
"Args",
"[",
"1",
"]",
"\n\n",
"// Create a custom http(s) client with your config",
"customClient",
":=",
"&",
"http",
".",
"Client",
"{",
"// accept any certificate (might be useful for testing)",
"Transport",
":",
"&",
"http",
".",
"Transport",
"{",
"TLSClientConfig",
":",
"&",
"tls",
".",
"Config",
"{",
"InsecureSkipVerify",
":",
"true",
"}",
",",
"}",
",",
"// 15 second timeout",
"Timeout",
":",
"15",
"*",
"time",
".",
"Second",
",",
"// don't follow redirect",
"CheckRedirect",
":",
"func",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"via",
"[",
"]",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"return",
"http",
".",
"ErrUseLastResponse",
"\n",
"}",
",",
"}",
"\n\n",
"// Override http(s) default protocol to use our custom client",
"client",
".",
"InstallProtocol",
"(",
"\"",
"\"",
",",
"githttp",
".",
"NewClient",
"(",
"customClient",
")",
")",
"\n\n",
"// Clone repository using the new client if the protocol is https://",
"Info",
"(",
"\"",
"\"",
",",
"url",
")",
"\n\n",
"r",
",",
"err",
":=",
"git",
".",
"Clone",
"(",
"memory",
".",
"NewStorage",
"(",
")",
",",
"nil",
",",
"&",
"git",
".",
"CloneOptions",
"{",
"URL",
":",
"url",
"}",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"// Retrieve the branch pointed by HEAD",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"head",
",",
"err",
":=",
"r",
".",
"Head",
"(",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n",
"fmt",
".",
"Println",
"(",
"head",
".",
"Hash",
"(",
")",
")",
"\n",
"}"
] | // Here is an example to configure http client according to our own needs. | [
"Here",
"is",
"an",
"example",
"to",
"configure",
"http",
"client",
"according",
"to",
"our",
"own",
"needs",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/_examples/custom_http/main.go#L18-L53 | train |
src-d/go-git | worktree_status.go | Status | func (w *Worktree) Status() (Status, error) {
var hash plumbing.Hash
ref, err := w.r.Head()
if err != nil && err != plumbing.ErrReferenceNotFound {
return nil, err
}
if err == nil {
hash = ref.Hash()
}
return w.status(hash)
} | go | func (w *Worktree) Status() (Status, error) {
var hash plumbing.Hash
ref, err := w.r.Head()
if err != nil && err != plumbing.ErrReferenceNotFound {
return nil, err
}
if err == nil {
hash = ref.Hash()
}
return w.status(hash)
} | [
"func",
"(",
"w",
"*",
"Worktree",
")",
"Status",
"(",
")",
"(",
"Status",
",",
"error",
")",
"{",
"var",
"hash",
"plumbing",
".",
"Hash",
"\n\n",
"ref",
",",
"err",
":=",
"w",
".",
"r",
".",
"Head",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"plumbing",
".",
"ErrReferenceNotFound",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"hash",
"=",
"ref",
".",
"Hash",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"w",
".",
"status",
"(",
"hash",
")",
"\n",
"}"
] | // Status returns the working tree status. | [
"Status",
"returns",
"the",
"working",
"tree",
"status",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/worktree_status.go#L34-L47 | train |
src-d/go-git | worktree_status.go | diffTreeIsEquals | func diffTreeIsEquals(a, b noder.Hasher) bool {
hashA := a.Hash()
hashB := b.Hash()
if bytes.Equal(hashA, emptyNoderHash) || bytes.Equal(hashB, emptyNoderHash) {
return false
}
return bytes.Equal(hashA, hashB)
} | go | func diffTreeIsEquals(a, b noder.Hasher) bool {
hashA := a.Hash()
hashB := b.Hash()
if bytes.Equal(hashA, emptyNoderHash) || bytes.Equal(hashB, emptyNoderHash) {
return false
}
return bytes.Equal(hashA, hashB)
} | [
"func",
"diffTreeIsEquals",
"(",
"a",
",",
"b",
"noder",
".",
"Hasher",
")",
"bool",
"{",
"hashA",
":=",
"a",
".",
"Hash",
"(",
")",
"\n",
"hashB",
":=",
"b",
".",
"Hash",
"(",
")",
"\n\n",
"if",
"bytes",
".",
"Equal",
"(",
"hashA",
",",
"emptyNoderHash",
")",
"||",
"bytes",
".",
"Equal",
"(",
"hashB",
",",
"emptyNoderHash",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"bytes",
".",
"Equal",
"(",
"hashA",
",",
"hashB",
")",
"\n",
"}"
] | // diffTreeIsEquals is a implementation of noder.Equals, used to compare
// noder.Noder, it compare the content and the length of the hashes.
//
// Since some of the noder.Noder implementations doesn't compute a hash for
// some directories, if any of the hashes is a 24-byte slice of zero values
// the comparison is not done and the hashes are take as different. | [
"diffTreeIsEquals",
"is",
"a",
"implementation",
"of",
"noder",
".",
"Equals",
"used",
"to",
"compare",
"noder",
".",
"Noder",
"it",
"compare",
"the",
"content",
"and",
"the",
"length",
"of",
"the",
"hashes",
".",
"Since",
"some",
"of",
"the",
"noder",
".",
"Noder",
"implementations",
"doesn",
"t",
"compute",
"a",
"hash",
"for",
"some",
"directories",
"if",
"any",
"of",
"the",
"hashes",
"is",
"a",
"24",
"-",
"byte",
"slice",
"of",
"zero",
"values",
"the",
"comparison",
"is",
"not",
"done",
"and",
"the",
"hashes",
"are",
"take",
"as",
"different",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/worktree_status.go#L249-L258 | train |
src-d/go-git | worktree_status.go | Add | func (w *Worktree) Add(path string) (plumbing.Hash, error) {
// TODO(mcuadros): remove plumbing.Hash from signature at v5.
s, err := w.Status()
if err != nil {
return plumbing.ZeroHash, err
}
idx, err := w.r.Storer.Index()
if err != nil {
return plumbing.ZeroHash, err
}
var h plumbing.Hash
var added bool
fi, err := w.Filesystem.Lstat(path)
if err != nil || !fi.IsDir() {
added, h, err = w.doAddFile(idx, s, path)
} else {
added, err = w.doAddDirectory(idx, s, path)
}
if err != nil {
return h, err
}
if !added {
return h, nil
}
return h, w.r.Storer.SetIndex(idx)
} | go | func (w *Worktree) Add(path string) (plumbing.Hash, error) {
// TODO(mcuadros): remove plumbing.Hash from signature at v5.
s, err := w.Status()
if err != nil {
return plumbing.ZeroHash, err
}
idx, err := w.r.Storer.Index()
if err != nil {
return plumbing.ZeroHash, err
}
var h plumbing.Hash
var added bool
fi, err := w.Filesystem.Lstat(path)
if err != nil || !fi.IsDir() {
added, h, err = w.doAddFile(idx, s, path)
} else {
added, err = w.doAddDirectory(idx, s, path)
}
if err != nil {
return h, err
}
if !added {
return h, nil
}
return h, w.r.Storer.SetIndex(idx)
} | [
"func",
"(",
"w",
"*",
"Worktree",
")",
"Add",
"(",
"path",
"string",
")",
"(",
"plumbing",
".",
"Hash",
",",
"error",
")",
"{",
"// TODO(mcuadros): remove plumbing.Hash from signature at v5.",
"s",
",",
"err",
":=",
"w",
".",
"Status",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"idx",
",",
"err",
":=",
"w",
".",
"r",
".",
"Storer",
".",
"Index",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"h",
"plumbing",
".",
"Hash",
"\n",
"var",
"added",
"bool",
"\n\n",
"fi",
",",
"err",
":=",
"w",
".",
"Filesystem",
".",
"Lstat",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"!",
"fi",
".",
"IsDir",
"(",
")",
"{",
"added",
",",
"h",
",",
"err",
"=",
"w",
".",
"doAddFile",
"(",
"idx",
",",
"s",
",",
"path",
")",
"\n",
"}",
"else",
"{",
"added",
",",
"err",
"=",
"w",
".",
"doAddDirectory",
"(",
"idx",
",",
"s",
",",
"path",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"h",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"added",
"{",
"return",
"h",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"h",
",",
"w",
".",
"r",
".",
"Storer",
".",
"SetIndex",
"(",
"idx",
")",
"\n",
"}"
] | // Add adds the file contents of a file in the worktree to the index. if the
// file is already staged in the index no error is returned. If a file deleted
// from the Workspace is given, the file is removed from the index. If a
// directory given, adds the files and all his sub-directories recursively in
// the worktree to the index. If any of the files is already staged in the index
// no error is returned. When path is a file, the blob.Hash is returned. | [
"Add",
"adds",
"the",
"file",
"contents",
"of",
"a",
"file",
"in",
"the",
"worktree",
"to",
"the",
"index",
".",
"if",
"the",
"file",
"is",
"already",
"staged",
"in",
"the",
"index",
"no",
"error",
"is",
"returned",
".",
"If",
"a",
"file",
"deleted",
"from",
"the",
"Workspace",
"is",
"given",
"the",
"file",
"is",
"removed",
"from",
"the",
"index",
".",
"If",
"a",
"directory",
"given",
"adds",
"the",
"files",
"and",
"all",
"his",
"sub",
"-",
"directories",
"recursively",
"in",
"the",
"worktree",
"to",
"the",
"index",
".",
"If",
"any",
"of",
"the",
"files",
"is",
"already",
"staged",
"in",
"the",
"index",
"no",
"error",
"is",
"returned",
".",
"When",
"path",
"is",
"a",
"file",
"the",
"blob",
".",
"Hash",
"is",
"returned",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/worktree_status.go#L266-L297 | train |
src-d/go-git | worktree_status.go | AddGlob | func (w *Worktree) AddGlob(pattern string) error {
files, err := util.Glob(w.Filesystem, pattern)
if err != nil {
return err
}
if len(files) == 0 {
return ErrGlobNoMatches
}
s, err := w.Status()
if err != nil {
return err
}
idx, err := w.r.Storer.Index()
if err != nil {
return err
}
var saveIndex bool
for _, file := range files {
fi, err := w.Filesystem.Lstat(file)
if err != nil {
return err
}
var added bool
if fi.IsDir() {
added, err = w.doAddDirectory(idx, s, file)
} else {
added, _, err = w.doAddFile(idx, s, file)
}
if err != nil {
return err
}
if !saveIndex && added {
saveIndex = true
}
}
if saveIndex {
return w.r.Storer.SetIndex(idx)
}
return nil
} | go | func (w *Worktree) AddGlob(pattern string) error {
files, err := util.Glob(w.Filesystem, pattern)
if err != nil {
return err
}
if len(files) == 0 {
return ErrGlobNoMatches
}
s, err := w.Status()
if err != nil {
return err
}
idx, err := w.r.Storer.Index()
if err != nil {
return err
}
var saveIndex bool
for _, file := range files {
fi, err := w.Filesystem.Lstat(file)
if err != nil {
return err
}
var added bool
if fi.IsDir() {
added, err = w.doAddDirectory(idx, s, file)
} else {
added, _, err = w.doAddFile(idx, s, file)
}
if err != nil {
return err
}
if !saveIndex && added {
saveIndex = true
}
}
if saveIndex {
return w.r.Storer.SetIndex(idx)
}
return nil
} | [
"func",
"(",
"w",
"*",
"Worktree",
")",
"AddGlob",
"(",
"pattern",
"string",
")",
"error",
"{",
"files",
",",
"err",
":=",
"util",
".",
"Glob",
"(",
"w",
".",
"Filesystem",
",",
"pattern",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"files",
")",
"==",
"0",
"{",
"return",
"ErrGlobNoMatches",
"\n",
"}",
"\n\n",
"s",
",",
"err",
":=",
"w",
".",
"Status",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"idx",
",",
"err",
":=",
"w",
".",
"r",
".",
"Storer",
".",
"Index",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"var",
"saveIndex",
"bool",
"\n",
"for",
"_",
",",
"file",
":=",
"range",
"files",
"{",
"fi",
",",
"err",
":=",
"w",
".",
"Filesystem",
".",
"Lstat",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"var",
"added",
"bool",
"\n",
"if",
"fi",
".",
"IsDir",
"(",
")",
"{",
"added",
",",
"err",
"=",
"w",
".",
"doAddDirectory",
"(",
"idx",
",",
"s",
",",
"file",
")",
"\n",
"}",
"else",
"{",
"added",
",",
"_",
",",
"err",
"=",
"w",
".",
"doAddFile",
"(",
"idx",
",",
"s",
",",
"file",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"saveIndex",
"&&",
"added",
"{",
"saveIndex",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"saveIndex",
"{",
"return",
"w",
".",
"r",
".",
"Storer",
".",
"SetIndex",
"(",
"idx",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // AddGlob adds all paths, matching pattern, to the index. If pattern matches a
// directory path, all directory contents are added to the index recursively. No
// error is returned if all matching paths are already staged in index. | [
"AddGlob",
"adds",
"all",
"paths",
"matching",
"pattern",
"to",
"the",
"index",
".",
"If",
"pattern",
"matches",
"a",
"directory",
"path",
"all",
"directory",
"contents",
"are",
"added",
"to",
"the",
"index",
"recursively",
".",
"No",
"error",
"is",
"returned",
"if",
"all",
"matching",
"paths",
"are",
"already",
"staged",
"in",
"index",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/worktree_status.go#L334-L382 | train |
src-d/go-git | worktree_status.go | doAddFile | func (w *Worktree) doAddFile(idx *index.Index, s Status, path string) (added bool, h plumbing.Hash, err error) {
if s.File(path).Worktree == Unmodified {
return false, h, nil
}
h, err = w.copyFileToStorage(path)
if err != nil {
if os.IsNotExist(err) {
added = true
h, err = w.deleteFromIndex(idx, path)
}
return
}
if err := w.addOrUpdateFileToIndex(idx, path, h); err != nil {
return false, h, err
}
return true, h, err
} | go | func (w *Worktree) doAddFile(idx *index.Index, s Status, path string) (added bool, h plumbing.Hash, err error) {
if s.File(path).Worktree == Unmodified {
return false, h, nil
}
h, err = w.copyFileToStorage(path)
if err != nil {
if os.IsNotExist(err) {
added = true
h, err = w.deleteFromIndex(idx, path)
}
return
}
if err := w.addOrUpdateFileToIndex(idx, path, h); err != nil {
return false, h, err
}
return true, h, err
} | [
"func",
"(",
"w",
"*",
"Worktree",
")",
"doAddFile",
"(",
"idx",
"*",
"index",
".",
"Index",
",",
"s",
"Status",
",",
"path",
"string",
")",
"(",
"added",
"bool",
",",
"h",
"plumbing",
".",
"Hash",
",",
"err",
"error",
")",
"{",
"if",
"s",
".",
"File",
"(",
"path",
")",
".",
"Worktree",
"==",
"Unmodified",
"{",
"return",
"false",
",",
"h",
",",
"nil",
"\n",
"}",
"\n\n",
"h",
",",
"err",
"=",
"w",
".",
"copyFileToStorage",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"added",
"=",
"true",
"\n",
"h",
",",
"err",
"=",
"w",
".",
"deleteFromIndex",
"(",
"idx",
",",
"path",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"w",
".",
"addOrUpdateFileToIndex",
"(",
"idx",
",",
"path",
",",
"h",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"h",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"true",
",",
"h",
",",
"err",
"\n",
"}"
] | // doAddFile create a new blob from path and update the index, added is true if
// the file added is different from the index. | [
"doAddFile",
"create",
"a",
"new",
"blob",
"from",
"path",
"and",
"update",
"the",
"index",
"added",
"is",
"true",
"if",
"the",
"file",
"added",
"is",
"different",
"from",
"the",
"index",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/worktree_status.go#L386-L406 | train |
src-d/go-git | worktree_status.go | Remove | func (w *Worktree) Remove(path string) (plumbing.Hash, error) {
// TODO(mcuadros): remove plumbing.Hash from signature at v5.
idx, err := w.r.Storer.Index()
if err != nil {
return plumbing.ZeroHash, err
}
var h plumbing.Hash
fi, err := w.Filesystem.Lstat(path)
if err != nil || !fi.IsDir() {
h, err = w.doRemoveFile(idx, path)
} else {
_, err = w.doRemoveDirectory(idx, path)
}
if err != nil {
return h, err
}
return h, w.r.Storer.SetIndex(idx)
} | go | func (w *Worktree) Remove(path string) (plumbing.Hash, error) {
// TODO(mcuadros): remove plumbing.Hash from signature at v5.
idx, err := w.r.Storer.Index()
if err != nil {
return plumbing.ZeroHash, err
}
var h plumbing.Hash
fi, err := w.Filesystem.Lstat(path)
if err != nil || !fi.IsDir() {
h, err = w.doRemoveFile(idx, path)
} else {
_, err = w.doRemoveDirectory(idx, path)
}
if err != nil {
return h, err
}
return h, w.r.Storer.SetIndex(idx)
} | [
"func",
"(",
"w",
"*",
"Worktree",
")",
"Remove",
"(",
"path",
"string",
")",
"(",
"plumbing",
".",
"Hash",
",",
"error",
")",
"{",
"// TODO(mcuadros): remove plumbing.Hash from signature at v5.",
"idx",
",",
"err",
":=",
"w",
".",
"r",
".",
"Storer",
".",
"Index",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"h",
"plumbing",
".",
"Hash",
"\n\n",
"fi",
",",
"err",
":=",
"w",
".",
"Filesystem",
".",
"Lstat",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"!",
"fi",
".",
"IsDir",
"(",
")",
"{",
"h",
",",
"err",
"=",
"w",
".",
"doRemoveFile",
"(",
"idx",
",",
"path",
")",
"\n",
"}",
"else",
"{",
"_",
",",
"err",
"=",
"w",
".",
"doRemoveDirectory",
"(",
"idx",
",",
"path",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"h",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"h",
",",
"w",
".",
"r",
".",
"Storer",
".",
"SetIndex",
"(",
"idx",
")",
"\n",
"}"
] | // Remove removes files from the working tree and from the index. | [
"Remove",
"removes",
"files",
"from",
"the",
"working",
"tree",
"and",
"from",
"the",
"index",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/worktree_status.go#L502-L522 | train |
src-d/go-git | worktree_status.go | RemoveGlob | func (w *Worktree) RemoveGlob(pattern string) error {
idx, err := w.r.Storer.Index()
if err != nil {
return err
}
entries, err := idx.Glob(pattern)
if err != nil {
return err
}
for _, e := range entries {
file := filepath.FromSlash(e.Name)
if _, err := w.Filesystem.Lstat(file); err != nil && !os.IsNotExist(err) {
return err
}
if _, err := w.doRemoveFile(idx, file); err != nil {
return err
}
dir, _ := filepath.Split(file)
if err := w.removeEmptyDirectory(dir); err != nil {
return err
}
}
return w.r.Storer.SetIndex(idx)
} | go | func (w *Worktree) RemoveGlob(pattern string) error {
idx, err := w.r.Storer.Index()
if err != nil {
return err
}
entries, err := idx.Glob(pattern)
if err != nil {
return err
}
for _, e := range entries {
file := filepath.FromSlash(e.Name)
if _, err := w.Filesystem.Lstat(file); err != nil && !os.IsNotExist(err) {
return err
}
if _, err := w.doRemoveFile(idx, file); err != nil {
return err
}
dir, _ := filepath.Split(file)
if err := w.removeEmptyDirectory(dir); err != nil {
return err
}
}
return w.r.Storer.SetIndex(idx)
} | [
"func",
"(",
"w",
"*",
"Worktree",
")",
"RemoveGlob",
"(",
"pattern",
"string",
")",
"error",
"{",
"idx",
",",
"err",
":=",
"w",
".",
"r",
".",
"Storer",
".",
"Index",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"entries",
",",
"err",
":=",
"idx",
".",
"Glob",
"(",
"pattern",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"e",
":=",
"range",
"entries",
"{",
"file",
":=",
"filepath",
".",
"FromSlash",
"(",
"e",
".",
"Name",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"w",
".",
"Filesystem",
".",
"Lstat",
"(",
"file",
")",
";",
"err",
"!=",
"nil",
"&&",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"w",
".",
"doRemoveFile",
"(",
"idx",
",",
"file",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"dir",
",",
"_",
":=",
"filepath",
".",
"Split",
"(",
"file",
")",
"\n",
"if",
"err",
":=",
"w",
".",
"removeEmptyDirectory",
"(",
"dir",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"w",
".",
"r",
".",
"Storer",
".",
"SetIndex",
"(",
"idx",
")",
"\n",
"}"
] | // RemoveGlob removes all paths, matching pattern, from the index. If pattern
// matches a directory path, all directory contents are removed from the index
// recursively. | [
"RemoveGlob",
"removes",
"all",
"paths",
"matching",
"pattern",
"from",
"the",
"index",
".",
"If",
"pattern",
"matches",
"a",
"directory",
"path",
"all",
"directory",
"contents",
"are",
"removed",
"from",
"the",
"index",
"recursively",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/worktree_status.go#L599-L627 | train |
src-d/go-git | worktree_status.go | Move | func (w *Worktree) Move(from, to string) (plumbing.Hash, error) {
// TODO(mcuadros): support directories and/or implement support for glob
if _, err := w.Filesystem.Lstat(from); err != nil {
return plumbing.ZeroHash, err
}
if _, err := w.Filesystem.Lstat(to); err == nil {
return plumbing.ZeroHash, ErrDestinationExists
}
idx, err := w.r.Storer.Index()
if err != nil {
return plumbing.ZeroHash, err
}
hash, err := w.deleteFromIndex(idx, from)
if err != nil {
return plumbing.ZeroHash, err
}
if err := w.Filesystem.Rename(from, to); err != nil {
return hash, err
}
if err := w.addOrUpdateFileToIndex(idx, to, hash); err != nil {
return hash, err
}
return hash, w.r.Storer.SetIndex(idx)
} | go | func (w *Worktree) Move(from, to string) (plumbing.Hash, error) {
// TODO(mcuadros): support directories and/or implement support for glob
if _, err := w.Filesystem.Lstat(from); err != nil {
return plumbing.ZeroHash, err
}
if _, err := w.Filesystem.Lstat(to); err == nil {
return plumbing.ZeroHash, ErrDestinationExists
}
idx, err := w.r.Storer.Index()
if err != nil {
return plumbing.ZeroHash, err
}
hash, err := w.deleteFromIndex(idx, from)
if err != nil {
return plumbing.ZeroHash, err
}
if err := w.Filesystem.Rename(from, to); err != nil {
return hash, err
}
if err := w.addOrUpdateFileToIndex(idx, to, hash); err != nil {
return hash, err
}
return hash, w.r.Storer.SetIndex(idx)
} | [
"func",
"(",
"w",
"*",
"Worktree",
")",
"Move",
"(",
"from",
",",
"to",
"string",
")",
"(",
"plumbing",
".",
"Hash",
",",
"error",
")",
"{",
"// TODO(mcuadros): support directories and/or implement support for glob",
"if",
"_",
",",
"err",
":=",
"w",
".",
"Filesystem",
".",
"Lstat",
"(",
"from",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"w",
".",
"Filesystem",
".",
"Lstat",
"(",
"to",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"ErrDestinationExists",
"\n",
"}",
"\n\n",
"idx",
",",
"err",
":=",
"w",
".",
"r",
".",
"Storer",
".",
"Index",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"hash",
",",
"err",
":=",
"w",
".",
"deleteFromIndex",
"(",
"idx",
",",
"from",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"w",
".",
"Filesystem",
".",
"Rename",
"(",
"from",
",",
"to",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"hash",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"w",
".",
"addOrUpdateFileToIndex",
"(",
"idx",
",",
"to",
",",
"hash",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"hash",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"hash",
",",
"w",
".",
"r",
".",
"Storer",
".",
"SetIndex",
"(",
"idx",
")",
"\n",
"}"
] | // Move moves or rename a file in the worktree and the index, directories are
// not supported. | [
"Move",
"moves",
"or",
"rename",
"a",
"file",
"in",
"the",
"worktree",
"and",
"the",
"index",
"directories",
"are",
"not",
"supported",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/worktree_status.go#L631-L660 | train |
src-d/go-git | plumbing/format/packfile/parser.go | NewParser | func NewParser(scanner *Scanner, ob ...Observer) (*Parser, error) {
return NewParserWithStorage(scanner, nil, ob...)
} | go | func NewParser(scanner *Scanner, ob ...Observer) (*Parser, error) {
return NewParserWithStorage(scanner, nil, ob...)
} | [
"func",
"NewParser",
"(",
"scanner",
"*",
"Scanner",
",",
"ob",
"...",
"Observer",
")",
"(",
"*",
"Parser",
",",
"error",
")",
"{",
"return",
"NewParserWithStorage",
"(",
"scanner",
",",
"nil",
",",
"ob",
"...",
")",
"\n",
"}"
] | // NewParser creates a new Parser. The Scanner source must be seekable.
// If it's not, NewParserWithStorage should be used instead. | [
"NewParser",
"creates",
"a",
"new",
"Parser",
".",
"The",
"Scanner",
"source",
"must",
"be",
"seekable",
".",
"If",
"it",
"s",
"not",
"NewParserWithStorage",
"should",
"be",
"used",
"instead",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/parser.go#L59-L61 | train |
src-d/go-git | plumbing/format/packfile/parser.go | NewParserWithStorage | func NewParserWithStorage(
scanner *Scanner,
storage storer.EncodedObjectStorer,
ob ...Observer,
) (*Parser, error) {
if !scanner.IsSeekable && storage == nil {
return nil, ErrNotSeekableSource
}
var deltas map[int64][]byte
if !scanner.IsSeekable {
deltas = make(map[int64][]byte)
}
return &Parser{
storage: storage,
scanner: scanner,
ob: ob,
count: 0,
cache: cache.NewBufferLRUDefault(),
deltas: deltas,
}, nil
} | go | func NewParserWithStorage(
scanner *Scanner,
storage storer.EncodedObjectStorer,
ob ...Observer,
) (*Parser, error) {
if !scanner.IsSeekable && storage == nil {
return nil, ErrNotSeekableSource
}
var deltas map[int64][]byte
if !scanner.IsSeekable {
deltas = make(map[int64][]byte)
}
return &Parser{
storage: storage,
scanner: scanner,
ob: ob,
count: 0,
cache: cache.NewBufferLRUDefault(),
deltas: deltas,
}, nil
} | [
"func",
"NewParserWithStorage",
"(",
"scanner",
"*",
"Scanner",
",",
"storage",
"storer",
".",
"EncodedObjectStorer",
",",
"ob",
"...",
"Observer",
",",
")",
"(",
"*",
"Parser",
",",
"error",
")",
"{",
"if",
"!",
"scanner",
".",
"IsSeekable",
"&&",
"storage",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrNotSeekableSource",
"\n",
"}",
"\n\n",
"var",
"deltas",
"map",
"[",
"int64",
"]",
"[",
"]",
"byte",
"\n",
"if",
"!",
"scanner",
".",
"IsSeekable",
"{",
"deltas",
"=",
"make",
"(",
"map",
"[",
"int64",
"]",
"[",
"]",
"byte",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"Parser",
"{",
"storage",
":",
"storage",
",",
"scanner",
":",
"scanner",
",",
"ob",
":",
"ob",
",",
"count",
":",
"0",
",",
"cache",
":",
"cache",
".",
"NewBufferLRUDefault",
"(",
")",
",",
"deltas",
":",
"deltas",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewParserWithStorage creates a new Parser. The scanner source must either
// be seekable or a storage must be provided. | [
"NewParserWithStorage",
"creates",
"a",
"new",
"Parser",
".",
"The",
"scanner",
"source",
"must",
"either",
"be",
"seekable",
"or",
"a",
"storage",
"must",
"be",
"provided",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/parser.go#L65-L87 | train |
src-d/go-git | plumbing/format/packfile/parser.go | Parse | func (p *Parser) Parse() (plumbing.Hash, error) {
if err := p.init(); err != nil {
return plumbing.ZeroHash, err
}
if err := p.indexObjects(); err != nil {
return plumbing.ZeroHash, err
}
var err error
p.checksum, err = p.scanner.Checksum()
if err != nil && err != io.EOF {
return plumbing.ZeroHash, err
}
if err := p.resolveDeltas(); err != nil {
return plumbing.ZeroHash, err
}
if err := p.onFooter(p.checksum); err != nil {
return plumbing.ZeroHash, err
}
return p.checksum, nil
} | go | func (p *Parser) Parse() (plumbing.Hash, error) {
if err := p.init(); err != nil {
return plumbing.ZeroHash, err
}
if err := p.indexObjects(); err != nil {
return plumbing.ZeroHash, err
}
var err error
p.checksum, err = p.scanner.Checksum()
if err != nil && err != io.EOF {
return plumbing.ZeroHash, err
}
if err := p.resolveDeltas(); err != nil {
return plumbing.ZeroHash, err
}
if err := p.onFooter(p.checksum); err != nil {
return plumbing.ZeroHash, err
}
return p.checksum, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"Parse",
"(",
")",
"(",
"plumbing",
".",
"Hash",
",",
"error",
")",
"{",
"if",
"err",
":=",
"p",
".",
"init",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"p",
".",
"indexObjects",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"p",
".",
"checksum",
",",
"err",
"=",
"p",
".",
"scanner",
".",
"Checksum",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"p",
".",
"resolveDeltas",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"p",
".",
"onFooter",
"(",
"p",
".",
"checksum",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"p",
".",
"checksum",
",",
"nil",
"\n",
"}"
] | // Parse start decoding phase of the packfile. | [
"Parse",
"start",
"decoding",
"phase",
"of",
"the",
"packfile",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/parser.go#L132-L156 | train |
src-d/go-git | storage/filesystem/object.go | NewObjectStorage | func NewObjectStorage(dir *dotgit.DotGit, objectCache cache.Object) *ObjectStorage {
return NewObjectStorageWithOptions(dir, objectCache, Options{})
} | go | func NewObjectStorage(dir *dotgit.DotGit, objectCache cache.Object) *ObjectStorage {
return NewObjectStorageWithOptions(dir, objectCache, Options{})
} | [
"func",
"NewObjectStorage",
"(",
"dir",
"*",
"dotgit",
".",
"DotGit",
",",
"objectCache",
"cache",
".",
"Object",
")",
"*",
"ObjectStorage",
"{",
"return",
"NewObjectStorageWithOptions",
"(",
"dir",
",",
"objectCache",
",",
"Options",
"{",
"}",
")",
"\n",
"}"
] | // NewObjectStorage creates a new ObjectStorage with the given .git directory and cache. | [
"NewObjectStorage",
"creates",
"a",
"new",
"ObjectStorage",
"with",
"the",
"given",
".",
"git",
"directory",
"and",
"cache",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/object.go#L36-L38 | train |
src-d/go-git | storage/filesystem/object.go | NewObjectStorageWithOptions | func NewObjectStorageWithOptions(dir *dotgit.DotGit, objectCache cache.Object, ops Options) *ObjectStorage {
return &ObjectStorage{
options: ops,
objectCache: objectCache,
dir: dir,
}
} | go | func NewObjectStorageWithOptions(dir *dotgit.DotGit, objectCache cache.Object, ops Options) *ObjectStorage {
return &ObjectStorage{
options: ops,
objectCache: objectCache,
dir: dir,
}
} | [
"func",
"NewObjectStorageWithOptions",
"(",
"dir",
"*",
"dotgit",
".",
"DotGit",
",",
"objectCache",
"cache",
".",
"Object",
",",
"ops",
"Options",
")",
"*",
"ObjectStorage",
"{",
"return",
"&",
"ObjectStorage",
"{",
"options",
":",
"ops",
",",
"objectCache",
":",
"objectCache",
",",
"dir",
":",
"dir",
",",
"}",
"\n",
"}"
] | // NewObjectStorageWithOptions creates a new ObjectStorage with the given .git directory, cache and extra options | [
"NewObjectStorageWithOptions",
"creates",
"a",
"new",
"ObjectStorage",
"with",
"the",
"given",
".",
"git",
"directory",
"cache",
"and",
"extra",
"options"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/object.go#L41-L47 | train |
src-d/go-git | storage/filesystem/object.go | SetEncodedObject | func (s *ObjectStorage) SetEncodedObject(o plumbing.EncodedObject) (h plumbing.Hash, err error) {
if o.Type() == plumbing.OFSDeltaObject || o.Type() == plumbing.REFDeltaObject {
return plumbing.ZeroHash, plumbing.ErrInvalidType
}
ow, err := s.dir.NewObject()
if err != nil {
return plumbing.ZeroHash, err
}
defer ioutil.CheckClose(ow, &err)
or, err := o.Reader()
if err != nil {
return plumbing.ZeroHash, err
}
defer ioutil.CheckClose(or, &err)
if err = ow.WriteHeader(o.Type(), o.Size()); err != nil {
return plumbing.ZeroHash, err
}
if _, err = io.Copy(ow, or); err != nil {
return plumbing.ZeroHash, err
}
return o.Hash(), err
} | go | func (s *ObjectStorage) SetEncodedObject(o plumbing.EncodedObject) (h plumbing.Hash, err error) {
if o.Type() == plumbing.OFSDeltaObject || o.Type() == plumbing.REFDeltaObject {
return plumbing.ZeroHash, plumbing.ErrInvalidType
}
ow, err := s.dir.NewObject()
if err != nil {
return plumbing.ZeroHash, err
}
defer ioutil.CheckClose(ow, &err)
or, err := o.Reader()
if err != nil {
return plumbing.ZeroHash, err
}
defer ioutil.CheckClose(or, &err)
if err = ow.WriteHeader(o.Type(), o.Size()); err != nil {
return plumbing.ZeroHash, err
}
if _, err = io.Copy(ow, or); err != nil {
return plumbing.ZeroHash, err
}
return o.Hash(), err
} | [
"func",
"(",
"s",
"*",
"ObjectStorage",
")",
"SetEncodedObject",
"(",
"o",
"plumbing",
".",
"EncodedObject",
")",
"(",
"h",
"plumbing",
".",
"Hash",
",",
"err",
"error",
")",
"{",
"if",
"o",
".",
"Type",
"(",
")",
"==",
"plumbing",
".",
"OFSDeltaObject",
"||",
"o",
".",
"Type",
"(",
")",
"==",
"plumbing",
".",
"REFDeltaObject",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"plumbing",
".",
"ErrInvalidType",
"\n",
"}",
"\n\n",
"ow",
",",
"err",
":=",
"s",
".",
"dir",
".",
"NewObject",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"defer",
"ioutil",
".",
"CheckClose",
"(",
"ow",
",",
"&",
"err",
")",
"\n\n",
"or",
",",
"err",
":=",
"o",
".",
"Reader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"defer",
"ioutil",
".",
"CheckClose",
"(",
"or",
",",
"&",
"err",
")",
"\n\n",
"if",
"err",
"=",
"ow",
".",
"WriteHeader",
"(",
"o",
".",
"Type",
"(",
")",
",",
"o",
".",
"Size",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"ow",
",",
"or",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"plumbing",
".",
"ZeroHash",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"o",
".",
"Hash",
"(",
")",
",",
"err",
"\n",
"}"
] | // SetEncodedObject adds a new object to the storage. | [
"SetEncodedObject",
"adds",
"a",
"new",
"object",
"to",
"the",
"storage",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/object.go#L117-L145 | train |
src-d/go-git | storage/filesystem/object.go | HasEncodedObject | func (s *ObjectStorage) HasEncodedObject(h plumbing.Hash) (err error) {
// Check unpacked objects
f, err := s.dir.Object(h)
if err != nil {
if !os.IsNotExist(err) {
return err
}
// Fall through to check packed objects.
} else {
defer ioutil.CheckClose(f, &err)
return nil
}
// Check packed objects.
if err := s.requireIndex(); err != nil {
return err
}
_, _, offset := s.findObjectInPackfile(h)
if offset == -1 {
return plumbing.ErrObjectNotFound
}
return nil
} | go | func (s *ObjectStorage) HasEncodedObject(h plumbing.Hash) (err error) {
// Check unpacked objects
f, err := s.dir.Object(h)
if err != nil {
if !os.IsNotExist(err) {
return err
}
// Fall through to check packed objects.
} else {
defer ioutil.CheckClose(f, &err)
return nil
}
// Check packed objects.
if err := s.requireIndex(); err != nil {
return err
}
_, _, offset := s.findObjectInPackfile(h)
if offset == -1 {
return plumbing.ErrObjectNotFound
}
return nil
} | [
"func",
"(",
"s",
"*",
"ObjectStorage",
")",
"HasEncodedObject",
"(",
"h",
"plumbing",
".",
"Hash",
")",
"(",
"err",
"error",
")",
"{",
"// Check unpacked objects",
"f",
",",
"err",
":=",
"s",
".",
"dir",
".",
"Object",
"(",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"err",
"\n",
"}",
"\n",
"// Fall through to check packed objects.",
"}",
"else",
"{",
"defer",
"ioutil",
".",
"CheckClose",
"(",
"f",
",",
"&",
"err",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Check packed objects.",
"if",
"err",
":=",
"s",
".",
"requireIndex",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"_",
",",
"offset",
":=",
"s",
".",
"findObjectInPackfile",
"(",
"h",
")",
"\n",
"if",
"offset",
"==",
"-",
"1",
"{",
"return",
"plumbing",
".",
"ErrObjectNotFound",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // HasEncodedObject returns nil if the object exists, without actually
// reading the object data from storage. | [
"HasEncodedObject",
"returns",
"nil",
"if",
"the",
"object",
"exists",
"without",
"actually",
"reading",
"the",
"object",
"data",
"from",
"storage",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/object.go#L149-L171 | train |
src-d/go-git | storage/filesystem/object.go | EncodedObjectSize | func (s *ObjectStorage) EncodedObjectSize(h plumbing.Hash) (
size int64, err error) {
size, err = s.encodedObjectSizeFromUnpacked(h)
if err != nil && err != plumbing.ErrObjectNotFound {
return 0, err
} else if err == nil {
return size, nil
}
return s.encodedObjectSizeFromPackfile(h)
} | go | func (s *ObjectStorage) EncodedObjectSize(h plumbing.Hash) (
size int64, err error) {
size, err = s.encodedObjectSizeFromUnpacked(h)
if err != nil && err != plumbing.ErrObjectNotFound {
return 0, err
} else if err == nil {
return size, nil
}
return s.encodedObjectSizeFromPackfile(h)
} | [
"func",
"(",
"s",
"*",
"ObjectStorage",
")",
"EncodedObjectSize",
"(",
"h",
"plumbing",
".",
"Hash",
")",
"(",
"size",
"int64",
",",
"err",
"error",
")",
"{",
"size",
",",
"err",
"=",
"s",
".",
"encodedObjectSizeFromUnpacked",
"(",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"plumbing",
".",
"ErrObjectNotFound",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"err",
"==",
"nil",
"{",
"return",
"size",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"encodedObjectSizeFromPackfile",
"(",
"h",
")",
"\n",
"}"
] | // EncodedObjectSize returns the plaintext size of the given object,
// without actually reading the full object data from storage. | [
"EncodedObjectSize",
"returns",
"the",
"plaintext",
"size",
"of",
"the",
"given",
"object",
"without",
"actually",
"reading",
"the",
"full",
"object",
"data",
"from",
"storage",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/object.go#L297-L307 | train |
src-d/go-git | storage/filesystem/object.go | EncodedObject | func (s *ObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
var obj plumbing.EncodedObject
var err error
if s.index != nil {
obj, err = s.getFromPackfile(h, false)
if err == plumbing.ErrObjectNotFound {
obj, err = s.getFromUnpacked(h)
}
} else {
obj, err = s.getFromUnpacked(h)
if err == plumbing.ErrObjectNotFound {
obj, err = s.getFromPackfile(h, false)
}
}
// If the error is still object not found, check if it's a shared object
// repository.
if err == plumbing.ErrObjectNotFound {
dotgits, e := s.dir.Alternates()
if e == nil {
// Create a new object storage with the DotGit(s) and check for the
// required hash object. Skip when not found.
for _, dg := range dotgits {
o := NewObjectStorage(dg, s.objectCache)
enobj, enerr := o.EncodedObject(t, h)
if enerr != nil {
continue
}
return enobj, nil
}
}
}
if err != nil {
return nil, err
}
if plumbing.AnyObject != t && obj.Type() != t {
return nil, plumbing.ErrObjectNotFound
}
return obj, nil
} | go | func (s *ObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
var obj plumbing.EncodedObject
var err error
if s.index != nil {
obj, err = s.getFromPackfile(h, false)
if err == plumbing.ErrObjectNotFound {
obj, err = s.getFromUnpacked(h)
}
} else {
obj, err = s.getFromUnpacked(h)
if err == plumbing.ErrObjectNotFound {
obj, err = s.getFromPackfile(h, false)
}
}
// If the error is still object not found, check if it's a shared object
// repository.
if err == plumbing.ErrObjectNotFound {
dotgits, e := s.dir.Alternates()
if e == nil {
// Create a new object storage with the DotGit(s) and check for the
// required hash object. Skip when not found.
for _, dg := range dotgits {
o := NewObjectStorage(dg, s.objectCache)
enobj, enerr := o.EncodedObject(t, h)
if enerr != nil {
continue
}
return enobj, nil
}
}
}
if err != nil {
return nil, err
}
if plumbing.AnyObject != t && obj.Type() != t {
return nil, plumbing.ErrObjectNotFound
}
return obj, nil
} | [
"func",
"(",
"s",
"*",
"ObjectStorage",
")",
"EncodedObject",
"(",
"t",
"plumbing",
".",
"ObjectType",
",",
"h",
"plumbing",
".",
"Hash",
")",
"(",
"plumbing",
".",
"EncodedObject",
",",
"error",
")",
"{",
"var",
"obj",
"plumbing",
".",
"EncodedObject",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"s",
".",
"index",
"!=",
"nil",
"{",
"obj",
",",
"err",
"=",
"s",
".",
"getFromPackfile",
"(",
"h",
",",
"false",
")",
"\n",
"if",
"err",
"==",
"plumbing",
".",
"ErrObjectNotFound",
"{",
"obj",
",",
"err",
"=",
"s",
".",
"getFromUnpacked",
"(",
"h",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"obj",
",",
"err",
"=",
"s",
".",
"getFromUnpacked",
"(",
"h",
")",
"\n",
"if",
"err",
"==",
"plumbing",
".",
"ErrObjectNotFound",
"{",
"obj",
",",
"err",
"=",
"s",
".",
"getFromPackfile",
"(",
"h",
",",
"false",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If the error is still object not found, check if it's a shared object",
"// repository.",
"if",
"err",
"==",
"plumbing",
".",
"ErrObjectNotFound",
"{",
"dotgits",
",",
"e",
":=",
"s",
".",
"dir",
".",
"Alternates",
"(",
")",
"\n",
"if",
"e",
"==",
"nil",
"{",
"// Create a new object storage with the DotGit(s) and check for the",
"// required hash object. Skip when not found.",
"for",
"_",
",",
"dg",
":=",
"range",
"dotgits",
"{",
"o",
":=",
"NewObjectStorage",
"(",
"dg",
",",
"s",
".",
"objectCache",
")",
"\n",
"enobj",
",",
"enerr",
":=",
"o",
".",
"EncodedObject",
"(",
"t",
",",
"h",
")",
"\n",
"if",
"enerr",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"return",
"enobj",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"plumbing",
".",
"AnyObject",
"!=",
"t",
"&&",
"obj",
".",
"Type",
"(",
")",
"!=",
"t",
"{",
"return",
"nil",
",",
"plumbing",
".",
"ErrObjectNotFound",
"\n",
"}",
"\n\n",
"return",
"obj",
",",
"nil",
"\n",
"}"
] | // EncodedObject returns the object with the given hash, by searching for it in
// the packfile and the git object directories. | [
"EncodedObject",
"returns",
"the",
"object",
"with",
"the",
"given",
"hash",
"by",
"searching",
"for",
"it",
"in",
"the",
"packfile",
"and",
"the",
"git",
"object",
"directories",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/object.go#L311-L354 | train |
src-d/go-git | storage/filesystem/object.go | DeltaObject | func (s *ObjectStorage) DeltaObject(t plumbing.ObjectType,
h plumbing.Hash) (plumbing.EncodedObject, error) {
obj, err := s.getFromUnpacked(h)
if err == plumbing.ErrObjectNotFound {
obj, err = s.getFromPackfile(h, true)
}
if err != nil {
return nil, err
}
if plumbing.AnyObject != t && obj.Type() != t {
return nil, plumbing.ErrObjectNotFound
}
return obj, nil
} | go | func (s *ObjectStorage) DeltaObject(t plumbing.ObjectType,
h plumbing.Hash) (plumbing.EncodedObject, error) {
obj, err := s.getFromUnpacked(h)
if err == plumbing.ErrObjectNotFound {
obj, err = s.getFromPackfile(h, true)
}
if err != nil {
return nil, err
}
if plumbing.AnyObject != t && obj.Type() != t {
return nil, plumbing.ErrObjectNotFound
}
return obj, nil
} | [
"func",
"(",
"s",
"*",
"ObjectStorage",
")",
"DeltaObject",
"(",
"t",
"plumbing",
".",
"ObjectType",
",",
"h",
"plumbing",
".",
"Hash",
")",
"(",
"plumbing",
".",
"EncodedObject",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"s",
".",
"getFromUnpacked",
"(",
"h",
")",
"\n",
"if",
"err",
"==",
"plumbing",
".",
"ErrObjectNotFound",
"{",
"obj",
",",
"err",
"=",
"s",
".",
"getFromPackfile",
"(",
"h",
",",
"true",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"plumbing",
".",
"AnyObject",
"!=",
"t",
"&&",
"obj",
".",
"Type",
"(",
")",
"!=",
"t",
"{",
"return",
"nil",
",",
"plumbing",
".",
"ErrObjectNotFound",
"\n",
"}",
"\n\n",
"return",
"obj",
",",
"nil",
"\n",
"}"
] | // DeltaObject returns the object with the given hash, by searching for
// it in the packfile and the git object directories. | [
"DeltaObject",
"returns",
"the",
"object",
"with",
"the",
"given",
"hash",
"by",
"searching",
"for",
"it",
"in",
"the",
"packfile",
"and",
"the",
"git",
"object",
"directories",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/object.go#L358-L374 | train |
src-d/go-git | storage/filesystem/object.go | getFromPackfile | func (s *ObjectStorage) getFromPackfile(h plumbing.Hash, canBeDelta bool) (
plumbing.EncodedObject, error) {
if err := s.requireIndex(); err != nil {
return nil, err
}
pack, hash, offset := s.findObjectInPackfile(h)
if offset == -1 {
return nil, plumbing.ErrObjectNotFound
}
idx := s.index[pack]
p, err := s.packfile(idx, pack)
if err != nil {
return nil, err
}
if !s.options.KeepDescriptors && s.options.MaxOpenDescriptors == 0 {
defer ioutil.CheckClose(p, &err)
}
if canBeDelta {
return s.decodeDeltaObjectAt(p, offset, hash)
}
return s.decodeObjectAt(p, offset)
} | go | func (s *ObjectStorage) getFromPackfile(h plumbing.Hash, canBeDelta bool) (
plumbing.EncodedObject, error) {
if err := s.requireIndex(); err != nil {
return nil, err
}
pack, hash, offset := s.findObjectInPackfile(h)
if offset == -1 {
return nil, plumbing.ErrObjectNotFound
}
idx := s.index[pack]
p, err := s.packfile(idx, pack)
if err != nil {
return nil, err
}
if !s.options.KeepDescriptors && s.options.MaxOpenDescriptors == 0 {
defer ioutil.CheckClose(p, &err)
}
if canBeDelta {
return s.decodeDeltaObjectAt(p, offset, hash)
}
return s.decodeObjectAt(p, offset)
} | [
"func",
"(",
"s",
"*",
"ObjectStorage",
")",
"getFromPackfile",
"(",
"h",
"plumbing",
".",
"Hash",
",",
"canBeDelta",
"bool",
")",
"(",
"plumbing",
".",
"EncodedObject",
",",
"error",
")",
"{",
"if",
"err",
":=",
"s",
".",
"requireIndex",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"pack",
",",
"hash",
",",
"offset",
":=",
"s",
".",
"findObjectInPackfile",
"(",
"h",
")",
"\n",
"if",
"offset",
"==",
"-",
"1",
"{",
"return",
"nil",
",",
"plumbing",
".",
"ErrObjectNotFound",
"\n",
"}",
"\n\n",
"idx",
":=",
"s",
".",
"index",
"[",
"pack",
"]",
"\n",
"p",
",",
"err",
":=",
"s",
".",
"packfile",
"(",
"idx",
",",
"pack",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"s",
".",
"options",
".",
"KeepDescriptors",
"&&",
"s",
".",
"options",
".",
"MaxOpenDescriptors",
"==",
"0",
"{",
"defer",
"ioutil",
".",
"CheckClose",
"(",
"p",
",",
"&",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"canBeDelta",
"{",
"return",
"s",
".",
"decodeDeltaObjectAt",
"(",
"p",
",",
"offset",
",",
"hash",
")",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"decodeObjectAt",
"(",
"p",
",",
"offset",
")",
"\n",
"}"
] | // Get returns the object with the given hash, by searching for it in
// the packfile. | [
"Get",
"returns",
"the",
"object",
"with",
"the",
"given",
"hash",
"by",
"searching",
"for",
"it",
"in",
"the",
"packfile",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/object.go#L419-L446 | train |
src-d/go-git | storage/filesystem/object.go | IterEncodedObjects | func (s *ObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (storer.EncodedObjectIter, error) {
objects, err := s.dir.Objects()
if err != nil {
return nil, err
}
seen := make(map[plumbing.Hash]struct{})
var iters []storer.EncodedObjectIter
if len(objects) != 0 {
iters = append(iters, &objectsIter{s: s, t: t, h: objects})
seen = hashListAsMap(objects)
}
packi, err := s.buildPackfileIters(t, seen)
if err != nil {
return nil, err
}
iters = append(iters, packi)
return storer.NewMultiEncodedObjectIter(iters), nil
} | go | func (s *ObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (storer.EncodedObjectIter, error) {
objects, err := s.dir.Objects()
if err != nil {
return nil, err
}
seen := make(map[plumbing.Hash]struct{})
var iters []storer.EncodedObjectIter
if len(objects) != 0 {
iters = append(iters, &objectsIter{s: s, t: t, h: objects})
seen = hashListAsMap(objects)
}
packi, err := s.buildPackfileIters(t, seen)
if err != nil {
return nil, err
}
iters = append(iters, packi)
return storer.NewMultiEncodedObjectIter(iters), nil
} | [
"func",
"(",
"s",
"*",
"ObjectStorage",
")",
"IterEncodedObjects",
"(",
"t",
"plumbing",
".",
"ObjectType",
")",
"(",
"storer",
".",
"EncodedObjectIter",
",",
"error",
")",
"{",
"objects",
",",
"err",
":=",
"s",
".",
"dir",
".",
"Objects",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"seen",
":=",
"make",
"(",
"map",
"[",
"plumbing",
".",
"Hash",
"]",
"struct",
"{",
"}",
")",
"\n",
"var",
"iters",
"[",
"]",
"storer",
".",
"EncodedObjectIter",
"\n",
"if",
"len",
"(",
"objects",
")",
"!=",
"0",
"{",
"iters",
"=",
"append",
"(",
"iters",
",",
"&",
"objectsIter",
"{",
"s",
":",
"s",
",",
"t",
":",
"t",
",",
"h",
":",
"objects",
"}",
")",
"\n",
"seen",
"=",
"hashListAsMap",
"(",
"objects",
")",
"\n",
"}",
"\n\n",
"packi",
",",
"err",
":=",
"s",
".",
"buildPackfileIters",
"(",
"t",
",",
"seen",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"iters",
"=",
"append",
"(",
"iters",
",",
"packi",
")",
"\n",
"return",
"storer",
".",
"NewMultiEncodedObjectIter",
"(",
"iters",
")",
",",
"nil",
"\n",
"}"
] | // IterEncodedObjects returns an iterator for all the objects in the packfile
// with the given type. | [
"IterEncodedObjects",
"returns",
"an",
"iterator",
"for",
"all",
"the",
"objects",
"in",
"the",
"packfile",
"with",
"the",
"given",
"type",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/object.go#L521-L541 | train |
src-d/go-git | storage/filesystem/object.go | NewPackfileIter | func NewPackfileIter(
fs billy.Filesystem,
f billy.File,
idxFile billy.File,
t plumbing.ObjectType,
keepPack bool,
) (storer.EncodedObjectIter, error) {
idx := idxfile.NewMemoryIndex()
if err := idxfile.NewDecoder(idxFile).Decode(idx); err != nil {
return nil, err
}
if err := idxFile.Close(); err != nil {
return nil, err
}
seen := make(map[plumbing.Hash]struct{})
return newPackfileIter(fs, f, t, seen, idx, nil, keepPack)
} | go | func NewPackfileIter(
fs billy.Filesystem,
f billy.File,
idxFile billy.File,
t plumbing.ObjectType,
keepPack bool,
) (storer.EncodedObjectIter, error) {
idx := idxfile.NewMemoryIndex()
if err := idxfile.NewDecoder(idxFile).Decode(idx); err != nil {
return nil, err
}
if err := idxFile.Close(); err != nil {
return nil, err
}
seen := make(map[plumbing.Hash]struct{})
return newPackfileIter(fs, f, t, seen, idx, nil, keepPack)
} | [
"func",
"NewPackfileIter",
"(",
"fs",
"billy",
".",
"Filesystem",
",",
"f",
"billy",
".",
"File",
",",
"idxFile",
"billy",
".",
"File",
",",
"t",
"plumbing",
".",
"ObjectType",
",",
"keepPack",
"bool",
",",
")",
"(",
"storer",
".",
"EncodedObjectIter",
",",
"error",
")",
"{",
"idx",
":=",
"idxfile",
".",
"NewMemoryIndex",
"(",
")",
"\n",
"if",
"err",
":=",
"idxfile",
".",
"NewDecoder",
"(",
"idxFile",
")",
".",
"Decode",
"(",
"idx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"idxFile",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"seen",
":=",
"make",
"(",
"map",
"[",
"plumbing",
".",
"Hash",
"]",
"struct",
"{",
"}",
")",
"\n",
"return",
"newPackfileIter",
"(",
"fs",
",",
"f",
",",
"t",
",",
"seen",
",",
"idx",
",",
"nil",
",",
"keepPack",
")",
"\n",
"}"
] | // NewPackfileIter returns a new EncodedObjectIter for the provided packfile
// and object type. Packfile and index file will be closed after they're
// used. If keepPack is true the packfile won't be closed after the iteration
// finished. | [
"NewPackfileIter",
"returns",
"a",
"new",
"EncodedObjectIter",
"for",
"the",
"provided",
"packfile",
"and",
"object",
"type",
".",
"Packfile",
"and",
"index",
"file",
"will",
"be",
"closed",
"after",
"they",
"re",
"used",
".",
"If",
"keepPack",
"is",
"true",
"the",
"packfile",
"won",
"t",
"be",
"closed",
"after",
"the",
"iteration",
"finished",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/object.go#L648-L666 | train |
src-d/go-git | plumbing/format/idxfile/decoder.go | Decode | func (d *Decoder) Decode(idx *MemoryIndex) error {
if err := validateHeader(d); err != nil {
return err
}
flow := []func(*MemoryIndex, io.Reader) error{
readVersion,
readFanout,
readObjectNames,
readCRC32,
readOffsets,
readChecksums,
}
for _, f := range flow {
if err := f(idx, d); err != nil {
return err
}
}
return nil
} | go | func (d *Decoder) Decode(idx *MemoryIndex) error {
if err := validateHeader(d); err != nil {
return err
}
flow := []func(*MemoryIndex, io.Reader) error{
readVersion,
readFanout,
readObjectNames,
readCRC32,
readOffsets,
readChecksums,
}
for _, f := range flow {
if err := f(idx, d); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"d",
"*",
"Decoder",
")",
"Decode",
"(",
"idx",
"*",
"MemoryIndex",
")",
"error",
"{",
"if",
"err",
":=",
"validateHeader",
"(",
"d",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"flow",
":=",
"[",
"]",
"func",
"(",
"*",
"MemoryIndex",
",",
"io",
".",
"Reader",
")",
"error",
"{",
"readVersion",
",",
"readFanout",
",",
"readObjectNames",
",",
"readCRC32",
",",
"readOffsets",
",",
"readChecksums",
",",
"}",
"\n\n",
"for",
"_",
",",
"f",
":=",
"range",
"flow",
"{",
"if",
"err",
":=",
"f",
"(",
"idx",
",",
"d",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Decode reads from the stream and decode the content into the MemoryIndex struct. | [
"Decode",
"reads",
"from",
"the",
"stream",
"and",
"decode",
"the",
"content",
"into",
"the",
"MemoryIndex",
"struct",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/idxfile/decoder.go#L36-L57 | train |
src-d/go-git | storage/filesystem/storage.go | NewStorage | func NewStorage(fs billy.Filesystem, cache cache.Object) *Storage {
return NewStorageWithOptions(fs, cache, Options{})
} | go | func NewStorage(fs billy.Filesystem, cache cache.Object) *Storage {
return NewStorageWithOptions(fs, cache, Options{})
} | [
"func",
"NewStorage",
"(",
"fs",
"billy",
".",
"Filesystem",
",",
"cache",
"cache",
".",
"Object",
")",
"*",
"Storage",
"{",
"return",
"NewStorageWithOptions",
"(",
"fs",
",",
"cache",
",",
"Options",
"{",
"}",
")",
"\n",
"}"
] | // NewStorage returns a new Storage backed by a given `fs.Filesystem` and cache. | [
"NewStorage",
"returns",
"a",
"new",
"Storage",
"backed",
"by",
"a",
"given",
"fs",
".",
"Filesystem",
"and",
"cache",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/storage.go#L40-L42 | train |
src-d/go-git | storage/filesystem/storage.go | NewStorageWithOptions | func NewStorageWithOptions(fs billy.Filesystem, cache cache.Object, ops Options) *Storage {
dirOps := dotgit.Options{
ExclusiveAccess: ops.ExclusiveAccess,
}
dir := dotgit.NewWithOptions(fs, dirOps)
return &Storage{
fs: fs,
dir: dir,
ObjectStorage: *NewObjectStorageWithOptions(dir, cache, ops),
ReferenceStorage: ReferenceStorage{dir: dir},
IndexStorage: IndexStorage{dir: dir},
ShallowStorage: ShallowStorage{dir: dir},
ConfigStorage: ConfigStorage{dir: dir},
ModuleStorage: ModuleStorage{dir: dir},
}
} | go | func NewStorageWithOptions(fs billy.Filesystem, cache cache.Object, ops Options) *Storage {
dirOps := dotgit.Options{
ExclusiveAccess: ops.ExclusiveAccess,
}
dir := dotgit.NewWithOptions(fs, dirOps)
return &Storage{
fs: fs,
dir: dir,
ObjectStorage: *NewObjectStorageWithOptions(dir, cache, ops),
ReferenceStorage: ReferenceStorage{dir: dir},
IndexStorage: IndexStorage{dir: dir},
ShallowStorage: ShallowStorage{dir: dir},
ConfigStorage: ConfigStorage{dir: dir},
ModuleStorage: ModuleStorage{dir: dir},
}
} | [
"func",
"NewStorageWithOptions",
"(",
"fs",
"billy",
".",
"Filesystem",
",",
"cache",
"cache",
".",
"Object",
",",
"ops",
"Options",
")",
"*",
"Storage",
"{",
"dirOps",
":=",
"dotgit",
".",
"Options",
"{",
"ExclusiveAccess",
":",
"ops",
".",
"ExclusiveAccess",
",",
"}",
"\n",
"dir",
":=",
"dotgit",
".",
"NewWithOptions",
"(",
"fs",
",",
"dirOps",
")",
"\n\n",
"return",
"&",
"Storage",
"{",
"fs",
":",
"fs",
",",
"dir",
":",
"dir",
",",
"ObjectStorage",
":",
"*",
"NewObjectStorageWithOptions",
"(",
"dir",
",",
"cache",
",",
"ops",
")",
",",
"ReferenceStorage",
":",
"ReferenceStorage",
"{",
"dir",
":",
"dir",
"}",
",",
"IndexStorage",
":",
"IndexStorage",
"{",
"dir",
":",
"dir",
"}",
",",
"ShallowStorage",
":",
"ShallowStorage",
"{",
"dir",
":",
"dir",
"}",
",",
"ConfigStorage",
":",
"ConfigStorage",
"{",
"dir",
":",
"dir",
"}",
",",
"ModuleStorage",
":",
"ModuleStorage",
"{",
"dir",
":",
"dir",
"}",
",",
"}",
"\n",
"}"
] | // NewStorageWithOptions returns a new Storage with extra options,
// backed by a given `fs.Filesystem` and cache. | [
"NewStorageWithOptions",
"returns",
"a",
"new",
"Storage",
"with",
"extra",
"options",
"backed",
"by",
"a",
"given",
"fs",
".",
"Filesystem",
"and",
"cache",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/storage.go#L46-L63 | train |
src-d/go-git | plumbing/format/idxfile/encoder.go | Encode | func (e *Encoder) Encode(idx *MemoryIndex) (int, error) {
flow := []func(*MemoryIndex) (int, error){
e.encodeHeader,
e.encodeFanout,
e.encodeHashes,
e.encodeCRC32,
e.encodeOffsets,
e.encodeChecksums,
}
sz := 0
for _, f := range flow {
i, err := f(idx)
sz += i
if err != nil {
return sz, err
}
}
return sz, nil
} | go | func (e *Encoder) Encode(idx *MemoryIndex) (int, error) {
flow := []func(*MemoryIndex) (int, error){
e.encodeHeader,
e.encodeFanout,
e.encodeHashes,
e.encodeCRC32,
e.encodeOffsets,
e.encodeChecksums,
}
sz := 0
for _, f := range flow {
i, err := f(idx)
sz += i
if err != nil {
return sz, err
}
}
return sz, nil
} | [
"func",
"(",
"e",
"*",
"Encoder",
")",
"Encode",
"(",
"idx",
"*",
"MemoryIndex",
")",
"(",
"int",
",",
"error",
")",
"{",
"flow",
":=",
"[",
"]",
"func",
"(",
"*",
"MemoryIndex",
")",
"(",
"int",
",",
"error",
")",
"{",
"e",
".",
"encodeHeader",
",",
"e",
".",
"encodeFanout",
",",
"e",
".",
"encodeHashes",
",",
"e",
".",
"encodeCRC32",
",",
"e",
".",
"encodeOffsets",
",",
"e",
".",
"encodeChecksums",
",",
"}",
"\n\n",
"sz",
":=",
"0",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"flow",
"{",
"i",
",",
"err",
":=",
"f",
"(",
"idx",
")",
"\n",
"sz",
"+=",
"i",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"sz",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"sz",
",",
"nil",
"\n",
"}"
] | // Encode encodes an MemoryIndex to the encoder writer. | [
"Encode",
"encodes",
"an",
"MemoryIndex",
"to",
"the",
"encoder",
"writer",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/idxfile/encoder.go#L25-L46 | train |
src-d/go-git | plumbing/transport/server/loader.go | Load | func (l *fsLoader) Load(ep *transport.Endpoint) (storer.Storer, error) {
fs, err := l.base.Chroot(ep.Path)
if err != nil {
return nil, err
}
if _, err := fs.Stat("config"); err != nil {
return nil, transport.ErrRepositoryNotFound
}
return filesystem.NewStorage(fs, cache.NewObjectLRUDefault()), nil
} | go | func (l *fsLoader) Load(ep *transport.Endpoint) (storer.Storer, error) {
fs, err := l.base.Chroot(ep.Path)
if err != nil {
return nil, err
}
if _, err := fs.Stat("config"); err != nil {
return nil, transport.ErrRepositoryNotFound
}
return filesystem.NewStorage(fs, cache.NewObjectLRUDefault()), nil
} | [
"func",
"(",
"l",
"*",
"fsLoader",
")",
"Load",
"(",
"ep",
"*",
"transport",
".",
"Endpoint",
")",
"(",
"storer",
".",
"Storer",
",",
"error",
")",
"{",
"fs",
",",
"err",
":=",
"l",
".",
"base",
".",
"Chroot",
"(",
"ep",
".",
"Path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"fs",
".",
"Stat",
"(",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"transport",
".",
"ErrRepositoryNotFound",
"\n",
"}",
"\n\n",
"return",
"filesystem",
".",
"NewStorage",
"(",
"fs",
",",
"cache",
".",
"NewObjectLRUDefault",
"(",
")",
")",
",",
"nil",
"\n",
"}"
] | // Load looks up the endpoint's path in the base file system and returns a
// storer for it. Returns transport.ErrRepositoryNotFound if a repository does
// not exist in the given path. | [
"Load",
"looks",
"up",
"the",
"endpoint",
"s",
"path",
"in",
"the",
"base",
"file",
"system",
"and",
"returns",
"a",
"storer",
"for",
"it",
".",
"Returns",
"transport",
".",
"ErrRepositoryNotFound",
"if",
"a",
"repository",
"does",
"not",
"exist",
"in",
"the",
"given",
"path",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/server/loader.go#L37-L48 | train |
src-d/go-git | plumbing/transport/server/loader.go | Load | func (l MapLoader) Load(ep *transport.Endpoint) (storer.Storer, error) {
s, ok := l[ep.String()]
if !ok {
return nil, transport.ErrRepositoryNotFound
}
return s, nil
} | go | func (l MapLoader) Load(ep *transport.Endpoint) (storer.Storer, error) {
s, ok := l[ep.String()]
if !ok {
return nil, transport.ErrRepositoryNotFound
}
return s, nil
} | [
"func",
"(",
"l",
"MapLoader",
")",
"Load",
"(",
"ep",
"*",
"transport",
".",
"Endpoint",
")",
"(",
"storer",
".",
"Storer",
",",
"error",
")",
"{",
"s",
",",
"ok",
":=",
"l",
"[",
"ep",
".",
"String",
"(",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"transport",
".",
"ErrRepositoryNotFound",
"\n",
"}",
"\n\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] | // Load returns a storer.Storer for given a transport.Endpoint by looking it up
// in the map. Returns transport.ErrRepositoryNotFound if the endpoint does not
// exist. | [
"Load",
"returns",
"a",
"storer",
".",
"Storer",
"for",
"given",
"a",
"transport",
".",
"Endpoint",
"by",
"looking",
"it",
"up",
"in",
"the",
"map",
".",
"Returns",
"transport",
".",
"ErrRepositoryNotFound",
"if",
"the",
"endpoint",
"does",
"not",
"exist",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/server/loader.go#L57-L64 | train |
src-d/go-git | config/modules.go | NewModules | func NewModules() *Modules {
return &Modules{
Submodules: make(map[string]*Submodule),
raw: format.New(),
}
} | go | func NewModules() *Modules {
return &Modules{
Submodules: make(map[string]*Submodule),
raw: format.New(),
}
} | [
"func",
"NewModules",
"(",
")",
"*",
"Modules",
"{",
"return",
"&",
"Modules",
"{",
"Submodules",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Submodule",
")",
",",
"raw",
":",
"format",
".",
"New",
"(",
")",
",",
"}",
"\n",
"}"
] | // NewModules returns a new empty Modules | [
"NewModules",
"returns",
"a",
"new",
"empty",
"Modules"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/config/modules.go#L32-L37 | train |
src-d/go-git | config/modules.go | Marshal | func (m *Modules) Marshal() ([]byte, error) {
s := m.raw.Section(submoduleSection)
s.Subsections = make(format.Subsections, len(m.Submodules))
var i int
for _, r := range m.Submodules {
s.Subsections[i] = r.marshal()
i++
}
buf := bytes.NewBuffer(nil)
if err := format.NewEncoder(buf).Encode(m.raw); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | func (m *Modules) Marshal() ([]byte, error) {
s := m.raw.Section(submoduleSection)
s.Subsections = make(format.Subsections, len(m.Submodules))
var i int
for _, r := range m.Submodules {
s.Subsections[i] = r.marshal()
i++
}
buf := bytes.NewBuffer(nil)
if err := format.NewEncoder(buf).Encode(m.raw); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | [
"func",
"(",
"m",
"*",
"Modules",
")",
"Marshal",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"s",
":=",
"m",
".",
"raw",
".",
"Section",
"(",
"submoduleSection",
")",
"\n",
"s",
".",
"Subsections",
"=",
"make",
"(",
"format",
".",
"Subsections",
",",
"len",
"(",
"m",
".",
"Submodules",
")",
")",
"\n\n",
"var",
"i",
"int",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"m",
".",
"Submodules",
"{",
"s",
".",
"Subsections",
"[",
"i",
"]",
"=",
"r",
".",
"marshal",
"(",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n\n",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"nil",
")",
"\n",
"if",
"err",
":=",
"format",
".",
"NewEncoder",
"(",
"buf",
")",
".",
"Encode",
"(",
"m",
".",
"raw",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"buf",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
] | // Marshal returns Modules encoded as a git-config file. | [
"Marshal",
"returns",
"Modules",
"encoded",
"as",
"a",
"git",
"-",
"config",
"file",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/config/modules.go#L59-L75 | train |
src-d/go-git | _examples/commit/main.go | main | func main() {
CheckArgs("<directory>")
directory := os.Args[1]
// Opens an already existing repository.
r, err := git.PlainOpen(directory)
CheckIfError(err)
w, err := r.Worktree()
CheckIfError(err)
// ... we need a file to commit so let's create a new file inside of the
// worktree of the project using the go standard library.
Info("echo \"hello world!\" > example-git-file")
filename := filepath.Join(directory, "example-git-file")
err = ioutil.WriteFile(filename, []byte("hello world!"), 0644)
CheckIfError(err)
// Adds the new file to the staging area.
Info("git add example-git-file")
_, err = w.Add("example-git-file")
CheckIfError(err)
// We can verify the current status of the worktree using the method Status.
Info("git status --porcelain")
status, err := w.Status()
CheckIfError(err)
fmt.Println(status)
// Commits the current staging area to the repository, with the new file
// just created. We should provide the object.Signature of Author of the
// commit.
Info("git commit -m \"example go-git commit\"")
commit, err := w.Commit("example go-git commit", &git.CommitOptions{
Author: &object.Signature{
Name: "John Doe",
Email: "[email protected]",
When: time.Now(),
},
})
CheckIfError(err)
// Prints the current HEAD to verify that all worked well.
Info("git show -s")
obj, err := r.CommitObject(commit)
CheckIfError(err)
fmt.Println(obj)
} | go | func main() {
CheckArgs("<directory>")
directory := os.Args[1]
// Opens an already existing repository.
r, err := git.PlainOpen(directory)
CheckIfError(err)
w, err := r.Worktree()
CheckIfError(err)
// ... we need a file to commit so let's create a new file inside of the
// worktree of the project using the go standard library.
Info("echo \"hello world!\" > example-git-file")
filename := filepath.Join(directory, "example-git-file")
err = ioutil.WriteFile(filename, []byte("hello world!"), 0644)
CheckIfError(err)
// Adds the new file to the staging area.
Info("git add example-git-file")
_, err = w.Add("example-git-file")
CheckIfError(err)
// We can verify the current status of the worktree using the method Status.
Info("git status --porcelain")
status, err := w.Status()
CheckIfError(err)
fmt.Println(status)
// Commits the current staging area to the repository, with the new file
// just created. We should provide the object.Signature of Author of the
// commit.
Info("git commit -m \"example go-git commit\"")
commit, err := w.Commit("example go-git commit", &git.CommitOptions{
Author: &object.Signature{
Name: "John Doe",
Email: "[email protected]",
When: time.Now(),
},
})
CheckIfError(err)
// Prints the current HEAD to verify that all worked well.
Info("git show -s")
obj, err := r.CommitObject(commit)
CheckIfError(err)
fmt.Println(obj)
} | [
"func",
"main",
"(",
")",
"{",
"CheckArgs",
"(",
"\"",
"\"",
")",
"\n",
"directory",
":=",
"os",
".",
"Args",
"[",
"1",
"]",
"\n\n",
"// Opens an already existing repository.",
"r",
",",
"err",
":=",
"git",
".",
"PlainOpen",
"(",
"directory",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"w",
",",
"err",
":=",
"r",
".",
"Worktree",
"(",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"// ... we need a file to commit so let's create a new file inside of the",
"// worktree of the project using the go standard library.",
"Info",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
")",
"\n",
"filename",
":=",
"filepath",
".",
"Join",
"(",
"directory",
",",
"\"",
"\"",
")",
"\n",
"err",
"=",
"ioutil",
".",
"WriteFile",
"(",
"filename",
",",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"0644",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"// Adds the new file to the staging area.",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"err",
"=",
"w",
".",
"Add",
"(",
"\"",
"\"",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"// We can verify the current status of the worktree using the method Status.",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"status",
",",
"err",
":=",
"w",
".",
"Status",
"(",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"fmt",
".",
"Println",
"(",
"status",
")",
"\n\n",
"// Commits the current staging area to the repository, with the new file",
"// just created. We should provide the object.Signature of Author of the",
"// commit.",
"Info",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
")",
"\n",
"commit",
",",
"err",
":=",
"w",
".",
"Commit",
"(",
"\"",
"\"",
",",
"&",
"git",
".",
"CommitOptions",
"{",
"Author",
":",
"&",
"object",
".",
"Signature",
"{",
"Name",
":",
"\"",
"\"",
",",
"Email",
":",
"\"",
"\"",
",",
"When",
":",
"time",
".",
"Now",
"(",
")",
",",
"}",
",",
"}",
")",
"\n\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"// Prints the current HEAD to verify that all worked well.",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"obj",
",",
"err",
":=",
"r",
".",
"CommitObject",
"(",
"commit",
")",
"\n",
"CheckIfError",
"(",
"err",
")",
"\n\n",
"fmt",
".",
"Println",
"(",
"obj",
")",
"\n",
"}"
] | // Basic example of how to commit changes to the current branch to an existing
// repository. | [
"Basic",
"example",
"of",
"how",
"to",
"commit",
"changes",
"to",
"the",
"current",
"branch",
"to",
"an",
"existing",
"repository",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/_examples/commit/main.go#L17-L67 | train |
src-d/go-git | storage/transactional/storage.go | NewStorage | func NewStorage(base, temporal storage.Storer) Storage {
st := &basic{
s: base,
temporal: temporal,
ObjectStorage: NewObjectStorage(base, temporal),
ReferenceStorage: NewReferenceStorage(base, temporal),
IndexStorage: NewIndexStorage(base, temporal),
ShallowStorage: NewShallowStorage(base, temporal),
ConfigStorage: NewConfigStorage(base, temporal),
}
pw, ok := temporal.(storer.PackfileWriter)
if ok {
return &packageWriter{
basic: st,
pw: pw,
}
}
return st
} | go | func NewStorage(base, temporal storage.Storer) Storage {
st := &basic{
s: base,
temporal: temporal,
ObjectStorage: NewObjectStorage(base, temporal),
ReferenceStorage: NewReferenceStorage(base, temporal),
IndexStorage: NewIndexStorage(base, temporal),
ShallowStorage: NewShallowStorage(base, temporal),
ConfigStorage: NewConfigStorage(base, temporal),
}
pw, ok := temporal.(storer.PackfileWriter)
if ok {
return &packageWriter{
basic: st,
pw: pw,
}
}
return st
} | [
"func",
"NewStorage",
"(",
"base",
",",
"temporal",
"storage",
".",
"Storer",
")",
"Storage",
"{",
"st",
":=",
"&",
"basic",
"{",
"s",
":",
"base",
",",
"temporal",
":",
"temporal",
",",
"ObjectStorage",
":",
"NewObjectStorage",
"(",
"base",
",",
"temporal",
")",
",",
"ReferenceStorage",
":",
"NewReferenceStorage",
"(",
"base",
",",
"temporal",
")",
",",
"IndexStorage",
":",
"NewIndexStorage",
"(",
"base",
",",
"temporal",
")",
",",
"ShallowStorage",
":",
"NewShallowStorage",
"(",
"base",
",",
"temporal",
")",
",",
"ConfigStorage",
":",
"NewConfigStorage",
"(",
"base",
",",
"temporal",
")",
",",
"}",
"\n\n",
"pw",
",",
"ok",
":=",
"temporal",
".",
"(",
"storer",
".",
"PackfileWriter",
")",
"\n",
"if",
"ok",
"{",
"return",
"&",
"packageWriter",
"{",
"basic",
":",
"st",
",",
"pw",
":",
"pw",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"st",
"\n",
"}"
] | // NewStorage returns a new Storage based on two repositories, base is the base
// repository where the read operations are read and temporal is were all
// the write operations are stored. | [
"NewStorage",
"returns",
"a",
"new",
"Storage",
"based",
"on",
"two",
"repositories",
"base",
"is",
"the",
"base",
"repository",
"where",
"the",
"read",
"operations",
"are",
"read",
"and",
"temporal",
"is",
"were",
"all",
"the",
"write",
"operations",
"are",
"stored",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/storage.go#L42-L63 | train |
src-d/go-git | storage/transactional/storage.go | Module | func (s *basic) Module(name string) (storage.Storer, error) {
base, err := s.s.Module(name)
if err != nil {
return nil, err
}
temporal, err := s.temporal.Module(name)
if err != nil {
return nil, err
}
return NewStorage(base, temporal), nil
} | go | func (s *basic) Module(name string) (storage.Storer, error) {
base, err := s.s.Module(name)
if err != nil {
return nil, err
}
temporal, err := s.temporal.Module(name)
if err != nil {
return nil, err
}
return NewStorage(base, temporal), nil
} | [
"func",
"(",
"s",
"*",
"basic",
")",
"Module",
"(",
"name",
"string",
")",
"(",
"storage",
".",
"Storer",
",",
"error",
")",
"{",
"base",
",",
"err",
":=",
"s",
".",
"s",
".",
"Module",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"temporal",
",",
"err",
":=",
"s",
".",
"temporal",
".",
"Module",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewStorage",
"(",
"base",
",",
"temporal",
")",
",",
"nil",
"\n",
"}"
] | // Module it honors the storage.ModuleStorer interface. | [
"Module",
"it",
"honors",
"the",
"storage",
".",
"ModuleStorer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/storage.go#L66-L78 | train |
src-d/go-git | storage/transactional/storage.go | Commit | func (s *basic) Commit() error {
for _, c := range []interface{ Commit() error }{
s.ObjectStorage,
s.ReferenceStorage,
s.IndexStorage,
s.ShallowStorage,
s.ConfigStorage,
} {
if err := c.Commit(); err != nil {
return err
}
}
return nil
} | go | func (s *basic) Commit() error {
for _, c := range []interface{ Commit() error }{
s.ObjectStorage,
s.ReferenceStorage,
s.IndexStorage,
s.ShallowStorage,
s.ConfigStorage,
} {
if err := c.Commit(); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"s",
"*",
"basic",
")",
"Commit",
"(",
")",
"error",
"{",
"for",
"_",
",",
"c",
":=",
"range",
"[",
"]",
"interface",
"{",
"Commit",
"(",
")",
"error",
"}",
"{",
"s",
".",
"ObjectStorage",
",",
"s",
".",
"ReferenceStorage",
",",
"s",
".",
"IndexStorage",
",",
"s",
".",
"ShallowStorage",
",",
"s",
".",
"ConfigStorage",
",",
"}",
"{",
"if",
"err",
":=",
"c",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Commit it copies the content of the temporal storage into the base storage. | [
"Commit",
"it",
"copies",
"the",
"content",
"of",
"the",
"temporal",
"storage",
"into",
"the",
"base",
"storage",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/storage.go#L81-L95 | train |
src-d/go-git | plumbing/protocol/packp/sideband/demux.go | NewDemuxer | func NewDemuxer(t Type, r io.Reader) *Demuxer {
max := MaxPackedSize64k
if t == Sideband {
max = MaxPackedSize
}
return &Demuxer{
t: t,
r: r,
max: max,
s: pktline.NewScanner(r),
}
} | go | func NewDemuxer(t Type, r io.Reader) *Demuxer {
max := MaxPackedSize64k
if t == Sideband {
max = MaxPackedSize
}
return &Demuxer{
t: t,
r: r,
max: max,
s: pktline.NewScanner(r),
}
} | [
"func",
"NewDemuxer",
"(",
"t",
"Type",
",",
"r",
"io",
".",
"Reader",
")",
"*",
"Demuxer",
"{",
"max",
":=",
"MaxPackedSize64k",
"\n",
"if",
"t",
"==",
"Sideband",
"{",
"max",
"=",
"MaxPackedSize",
"\n",
"}",
"\n\n",
"return",
"&",
"Demuxer",
"{",
"t",
":",
"t",
",",
"r",
":",
"r",
",",
"max",
":",
"max",
",",
"s",
":",
"pktline",
".",
"NewScanner",
"(",
"r",
")",
",",
"}",
"\n",
"}"
] | // NewDemuxer returns a new Demuxer for the given t and read from r | [
"NewDemuxer",
"returns",
"a",
"new",
"Demuxer",
"for",
"the",
"given",
"t",
"and",
"read",
"from",
"r"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/sideband/demux.go#L46-L58 | train |
src-d/go-git | plumbing/object/difftree.go | DiffTree | func DiffTree(a, b *Tree) (Changes, error) {
return DiffTreeContext(context.Background(), a, b)
} | go | func DiffTree(a, b *Tree) (Changes, error) {
return DiffTreeContext(context.Background(), a, b)
} | [
"func",
"DiffTree",
"(",
"a",
",",
"b",
"*",
"Tree",
")",
"(",
"Changes",
",",
"error",
")",
"{",
"return",
"DiffTreeContext",
"(",
"context",
".",
"Background",
"(",
")",
",",
"a",
",",
"b",
")",
"\n",
"}"
] | // DiffTree compares the content and mode of the blobs found via two
// tree objects. | [
"DiffTree",
"compares",
"the",
"content",
"and",
"mode",
"of",
"the",
"blobs",
"found",
"via",
"two",
"tree",
"objects",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/object/difftree.go#L13-L15 | train |
src-d/go-git | plumbing/object/difftree.go | DiffTreeContext | func DiffTreeContext(ctx context.Context, a, b *Tree) (Changes, error) {
from := NewTreeRootNode(a)
to := NewTreeRootNode(b)
hashEqual := func(a, b noder.Hasher) bool {
return bytes.Equal(a.Hash(), b.Hash())
}
merkletrieChanges, err := merkletrie.DiffTreeContext(ctx, from, to, hashEqual)
if err != nil {
if err == merkletrie.ErrCanceled {
return nil, ErrCanceled
}
return nil, err
}
return newChanges(merkletrieChanges)
} | go | func DiffTreeContext(ctx context.Context, a, b *Tree) (Changes, error) {
from := NewTreeRootNode(a)
to := NewTreeRootNode(b)
hashEqual := func(a, b noder.Hasher) bool {
return bytes.Equal(a.Hash(), b.Hash())
}
merkletrieChanges, err := merkletrie.DiffTreeContext(ctx, from, to, hashEqual)
if err != nil {
if err == merkletrie.ErrCanceled {
return nil, ErrCanceled
}
return nil, err
}
return newChanges(merkletrieChanges)
} | [
"func",
"DiffTreeContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"a",
",",
"b",
"*",
"Tree",
")",
"(",
"Changes",
",",
"error",
")",
"{",
"from",
":=",
"NewTreeRootNode",
"(",
"a",
")",
"\n",
"to",
":=",
"NewTreeRootNode",
"(",
"b",
")",
"\n\n",
"hashEqual",
":=",
"func",
"(",
"a",
",",
"b",
"noder",
".",
"Hasher",
")",
"bool",
"{",
"return",
"bytes",
".",
"Equal",
"(",
"a",
".",
"Hash",
"(",
")",
",",
"b",
".",
"Hash",
"(",
")",
")",
"\n",
"}",
"\n\n",
"merkletrieChanges",
",",
"err",
":=",
"merkletrie",
".",
"DiffTreeContext",
"(",
"ctx",
",",
"from",
",",
"to",
",",
"hashEqual",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"merkletrie",
".",
"ErrCanceled",
"{",
"return",
"nil",
",",
"ErrCanceled",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"newChanges",
"(",
"merkletrieChanges",
")",
"\n",
"}"
] | // 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 | [
"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"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/object/difftree.go#L20-L37 | train |
src-d/go-git | plumbing/cache/object_lru.go | Put | func (c *ObjectLRU) Put(obj plumbing.EncodedObject) {
c.mut.Lock()
defer c.mut.Unlock()
if c.cache == nil {
c.actualSize = 0
c.cache = make(map[interface{}]*list.Element, 1000)
c.ll = list.New()
}
objSize := FileSize(obj.Size())
key := obj.Hash()
if ee, ok := c.cache[key]; ok {
oldObj := ee.Value.(plumbing.EncodedObject)
// in this case objSize is a delta: new size - old size
objSize -= FileSize(oldObj.Size())
c.ll.MoveToFront(ee)
ee.Value = obj
} else {
if objSize > c.MaxSize {
return
}
ee := c.ll.PushFront(obj)
c.cache[key] = ee
}
c.actualSize += objSize
for c.actualSize > c.MaxSize {
last := c.ll.Back()
if last == nil {
c.actualSize = 0
break
}
lastObj := last.Value.(plumbing.EncodedObject)
lastSize := FileSize(lastObj.Size())
c.ll.Remove(last)
delete(c.cache, lastObj.Hash())
c.actualSize -= lastSize
}
} | go | func (c *ObjectLRU) Put(obj plumbing.EncodedObject) {
c.mut.Lock()
defer c.mut.Unlock()
if c.cache == nil {
c.actualSize = 0
c.cache = make(map[interface{}]*list.Element, 1000)
c.ll = list.New()
}
objSize := FileSize(obj.Size())
key := obj.Hash()
if ee, ok := c.cache[key]; ok {
oldObj := ee.Value.(plumbing.EncodedObject)
// in this case objSize is a delta: new size - old size
objSize -= FileSize(oldObj.Size())
c.ll.MoveToFront(ee)
ee.Value = obj
} else {
if objSize > c.MaxSize {
return
}
ee := c.ll.PushFront(obj)
c.cache[key] = ee
}
c.actualSize += objSize
for c.actualSize > c.MaxSize {
last := c.ll.Back()
if last == nil {
c.actualSize = 0
break
}
lastObj := last.Value.(plumbing.EncodedObject)
lastSize := FileSize(lastObj.Size())
c.ll.Remove(last)
delete(c.cache, lastObj.Hash())
c.actualSize -= lastSize
}
} | [
"func",
"(",
"c",
"*",
"ObjectLRU",
")",
"Put",
"(",
"obj",
"plumbing",
".",
"EncodedObject",
")",
"{",
"c",
".",
"mut",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mut",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"c",
".",
"cache",
"==",
"nil",
"{",
"c",
".",
"actualSize",
"=",
"0",
"\n",
"c",
".",
"cache",
"=",
"make",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"*",
"list",
".",
"Element",
",",
"1000",
")",
"\n",
"c",
".",
"ll",
"=",
"list",
".",
"New",
"(",
")",
"\n",
"}",
"\n\n",
"objSize",
":=",
"FileSize",
"(",
"obj",
".",
"Size",
"(",
")",
")",
"\n",
"key",
":=",
"obj",
".",
"Hash",
"(",
")",
"\n",
"if",
"ee",
",",
"ok",
":=",
"c",
".",
"cache",
"[",
"key",
"]",
";",
"ok",
"{",
"oldObj",
":=",
"ee",
".",
"Value",
".",
"(",
"plumbing",
".",
"EncodedObject",
")",
"\n",
"// in this case objSize is a delta: new size - old size",
"objSize",
"-=",
"FileSize",
"(",
"oldObj",
".",
"Size",
"(",
")",
")",
"\n",
"c",
".",
"ll",
".",
"MoveToFront",
"(",
"ee",
")",
"\n",
"ee",
".",
"Value",
"=",
"obj",
"\n",
"}",
"else",
"{",
"if",
"objSize",
">",
"c",
".",
"MaxSize",
"{",
"return",
"\n",
"}",
"\n",
"ee",
":=",
"c",
".",
"ll",
".",
"PushFront",
"(",
"obj",
")",
"\n",
"c",
".",
"cache",
"[",
"key",
"]",
"=",
"ee",
"\n",
"}",
"\n\n",
"c",
".",
"actualSize",
"+=",
"objSize",
"\n",
"for",
"c",
".",
"actualSize",
">",
"c",
".",
"MaxSize",
"{",
"last",
":=",
"c",
".",
"ll",
".",
"Back",
"(",
")",
"\n",
"if",
"last",
"==",
"nil",
"{",
"c",
".",
"actualSize",
"=",
"0",
"\n",
"break",
"\n",
"}",
"\n\n",
"lastObj",
":=",
"last",
".",
"Value",
".",
"(",
"plumbing",
".",
"EncodedObject",
")",
"\n",
"lastSize",
":=",
"FileSize",
"(",
"lastObj",
".",
"Size",
"(",
")",
")",
"\n\n",
"c",
".",
"ll",
".",
"Remove",
"(",
"last",
")",
"\n",
"delete",
"(",
"c",
".",
"cache",
",",
"lastObj",
".",
"Hash",
"(",
")",
")",
"\n",
"c",
".",
"actualSize",
"-=",
"lastSize",
"\n",
"}",
"\n",
"}"
] | // Put puts an object into the cache. If the object is already in the cache, it
// will be marked as used. Otherwise, it will be inserted. A single object might
// be evicted to make room for the new object. | [
"Put",
"puts",
"an",
"object",
"into",
"the",
"cache",
".",
"If",
"the",
"object",
"is",
"already",
"in",
"the",
"cache",
"it",
"will",
"be",
"marked",
"as",
"used",
".",
"Otherwise",
"it",
"will",
"be",
"inserted",
".",
"A",
"single",
"object",
"might",
"be",
"evicted",
"to",
"make",
"room",
"for",
"the",
"new",
"object",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/cache/object_lru.go#L35-L76 | train |
src-d/go-git | utils/merkletrie/internal/fsnoder/dir.go | newDir | func newDir(name string, children []noder.Noder) (*dir, error) {
cloned := make([]noder.Noder, len(children))
_ = copy(cloned, children)
sort.Sort(byName(cloned))
if hasChildrenWithNoName(cloned) {
return nil, fmt.Errorf("non-root inner nodes cannot have empty names")
}
if hasDuplicatedNames(cloned) {
return nil, fmt.Errorf("children cannot have duplicated names")
}
return &dir{
name: name,
children: cloned,
}, nil
} | go | func newDir(name string, children []noder.Noder) (*dir, error) {
cloned := make([]noder.Noder, len(children))
_ = copy(cloned, children)
sort.Sort(byName(cloned))
if hasChildrenWithNoName(cloned) {
return nil, fmt.Errorf("non-root inner nodes cannot have empty names")
}
if hasDuplicatedNames(cloned) {
return nil, fmt.Errorf("children cannot have duplicated names")
}
return &dir{
name: name,
children: cloned,
}, nil
} | [
"func",
"newDir",
"(",
"name",
"string",
",",
"children",
"[",
"]",
"noder",
".",
"Noder",
")",
"(",
"*",
"dir",
",",
"error",
")",
"{",
"cloned",
":=",
"make",
"(",
"[",
"]",
"noder",
".",
"Noder",
",",
"len",
"(",
"children",
")",
")",
"\n",
"_",
"=",
"copy",
"(",
"cloned",
",",
"children",
")",
"\n",
"sort",
".",
"Sort",
"(",
"byName",
"(",
"cloned",
")",
")",
"\n\n",
"if",
"hasChildrenWithNoName",
"(",
"cloned",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"hasDuplicatedNames",
"(",
"cloned",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"dir",
"{",
"name",
":",
"name",
",",
"children",
":",
"cloned",
",",
"}",
",",
"nil",
"\n",
"}"
] | // copies the children slice, so nobody can modify the order of its
// elements from the outside. | [
"copies",
"the",
"children",
"slice",
"so",
"nobody",
"can",
"modify",
"the",
"order",
"of",
"its",
"elements",
"from",
"the",
"outside",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/internal/fsnoder/dir.go#L30-L47 | train |
src-d/go-git | utils/merkletrie/internal/fsnoder/dir.go | calculateHash | func (d *dir) calculateHash() {
h := fnv.New64a()
h.Write([]byte("dir "))
for _, c := range d.children {
h.Write([]byte(c.Name()))
h.Write([]byte(" "))
h.Write(c.Hash())
}
d.hash = h.Sum([]byte{})
} | go | func (d *dir) calculateHash() {
h := fnv.New64a()
h.Write([]byte("dir "))
for _, c := range d.children {
h.Write([]byte(c.Name()))
h.Write([]byte(" "))
h.Write(c.Hash())
}
d.hash = h.Sum([]byte{})
} | [
"func",
"(",
"d",
"*",
"dir",
")",
"calculateHash",
"(",
")",
"{",
"h",
":=",
"fnv",
".",
"New64a",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
")",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"d",
".",
"children",
"{",
"h",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"c",
".",
"Name",
"(",
")",
")",
")",
"\n",
"h",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
")",
"\n",
"h",
".",
"Write",
"(",
"c",
".",
"Hash",
"(",
")",
")",
"\n",
"}",
"\n",
"d",
".",
"hash",
"=",
"h",
".",
"Sum",
"(",
"[",
"]",
"byte",
"{",
"}",
")",
"\n",
"}"
] | // hash is calculated as the hash of "dir " plus the concatenation, for
// each child, of its name, a space and its hash. Children are sorted
// alphabetically before calculating the hash, so the result is unique. | [
"hash",
"is",
"calculated",
"as",
"the",
"hash",
"of",
"dir",
"plus",
"the",
"concatenation",
"for",
"each",
"child",
"of",
"its",
"name",
"a",
"space",
"and",
"its",
"hash",
".",
"Children",
"are",
"sorted",
"alphabetically",
"before",
"calculating",
"the",
"hash",
"so",
"the",
"result",
"is",
"unique",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/internal/fsnoder/dir.go#L84-L93 | train |
src-d/go-git | utils/merkletrie/internal/fsnoder/dir.go | Children | func (d *dir) Children() ([]noder.Noder, error) {
clon := make([]noder.Noder, len(d.children))
_ = copy(clon, d.children)
return clon, nil
} | go | func (d *dir) Children() ([]noder.Noder, error) {
clon := make([]noder.Noder, len(d.children))
_ = copy(clon, d.children)
return clon, nil
} | [
"func",
"(",
"d",
"*",
"dir",
")",
"Children",
"(",
")",
"(",
"[",
"]",
"noder",
".",
"Noder",
",",
"error",
")",
"{",
"clon",
":=",
"make",
"(",
"[",
"]",
"noder",
".",
"Noder",
",",
"len",
"(",
"d",
".",
"children",
")",
")",
"\n",
"_",
"=",
"copy",
"(",
"clon",
",",
"d",
".",
"children",
")",
"\n",
"return",
"clon",
",",
"nil",
"\n",
"}"
] | // returns a copy so nobody can alter the order of its elements from the
// outside. | [
"returns",
"a",
"copy",
"so",
"nobody",
"can",
"alter",
"the",
"order",
"of",
"its",
"elements",
"from",
"the",
"outside",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/internal/fsnoder/dir.go#L105-L109 | train |
src-d/go-git | utils/merkletrie/internal/fsnoder/dir.go | String | func (d *dir) String() string {
var buf bytes.Buffer
buf.WriteString(d.name)
buf.WriteRune(dirStartMark)
for i, c := range d.children {
if i != 0 {
buf.WriteRune(dirElementSep)
}
buf.WriteString(c.String())
}
buf.WriteRune(dirEndMark)
return buf.String()
} | go | func (d *dir) String() string {
var buf bytes.Buffer
buf.WriteString(d.name)
buf.WriteRune(dirStartMark)
for i, c := range d.children {
if i != 0 {
buf.WriteRune(dirElementSep)
}
buf.WriteString(c.String())
}
buf.WriteRune(dirEndMark)
return buf.String()
} | [
"func",
"(",
"d",
"*",
"dir",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n\n",
"buf",
".",
"WriteString",
"(",
"d",
".",
"name",
")",
"\n",
"buf",
".",
"WriteRune",
"(",
"dirStartMark",
")",
"\n\n",
"for",
"i",
",",
"c",
":=",
"range",
"d",
".",
"children",
"{",
"if",
"i",
"!=",
"0",
"{",
"buf",
".",
"WriteRune",
"(",
"dirElementSep",
")",
"\n",
"}",
"\n",
"buf",
".",
"WriteString",
"(",
"c",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"buf",
".",
"WriteRune",
"(",
"dirEndMark",
")",
"\n\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // The string generated by this method is unique for each tree, as the
// children of each node are sorted alphabetically by name when
// generating the string. | [
"The",
"string",
"generated",
"by",
"this",
"method",
"is",
"unique",
"for",
"each",
"tree",
"as",
"the",
"children",
"of",
"each",
"node",
"are",
"sorted",
"alphabetically",
"by",
"name",
"when",
"generating",
"the",
"string",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/internal/fsnoder/dir.go#L124-L140 | train |
src-d/go-git | plumbing/protocol/packp/sideband/muxer.go | NewMuxer | func NewMuxer(t Type, w io.Writer) *Muxer {
max := MaxPackedSize64k
if t == Sideband {
max = MaxPackedSize
}
return &Muxer{
max: max - chLen,
e: pktline.NewEncoder(w),
}
} | go | func NewMuxer(t Type, w io.Writer) *Muxer {
max := MaxPackedSize64k
if t == Sideband {
max = MaxPackedSize
}
return &Muxer{
max: max - chLen,
e: pktline.NewEncoder(w),
}
} | [
"func",
"NewMuxer",
"(",
"t",
"Type",
",",
"w",
"io",
".",
"Writer",
")",
"*",
"Muxer",
"{",
"max",
":=",
"MaxPackedSize64k",
"\n",
"if",
"t",
"==",
"Sideband",
"{",
"max",
"=",
"MaxPackedSize",
"\n",
"}",
"\n\n",
"return",
"&",
"Muxer",
"{",
"max",
":",
"max",
"-",
"chLen",
",",
"e",
":",
"pktline",
".",
"NewEncoder",
"(",
"w",
")",
",",
"}",
"\n",
"}"
] | // NewMuxer returns a new Muxer for the given t that writes on w.
//
// If t is equal to `Sideband` the max pack size is set to MaxPackedSize, in any
// other value is given, max pack is set to MaxPackedSize64k, that is the
// maximum length of a line in pktline format. | [
"NewMuxer",
"returns",
"a",
"new",
"Muxer",
"for",
"the",
"given",
"t",
"that",
"writes",
"on",
"w",
".",
"If",
"t",
"is",
"equal",
"to",
"Sideband",
"the",
"max",
"pack",
"size",
"is",
"set",
"to",
"MaxPackedSize",
"in",
"any",
"other",
"value",
"is",
"given",
"max",
"pack",
"is",
"set",
"to",
"MaxPackedSize64k",
"that",
"is",
"the",
"maximum",
"length",
"of",
"a",
"line",
"in",
"pktline",
"format",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/sideband/muxer.go#L23-L33 | train |
src-d/go-git | plumbing/protocol/packp/sideband/muxer.go | Write | func (m *Muxer) Write(p []byte) (int, error) {
return m.WriteChannel(PackData, p)
} | go | func (m *Muxer) Write(p []byte) (int, error) {
return m.WriteChannel(PackData, p)
} | [
"func",
"(",
"m",
"*",
"Muxer",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"m",
".",
"WriteChannel",
"(",
"PackData",
",",
"p",
")",
"\n",
"}"
] | // Write writes p in the PackData channel | [
"Write",
"writes",
"p",
"in",
"the",
"PackData",
"channel"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/sideband/muxer.go#L36-L38 | train |
src-d/go-git | plumbing/protocol/packp/sideband/muxer.go | WriteChannel | func (m *Muxer) WriteChannel(t Channel, p []byte) (int, error) {
wrote := 0
size := len(p)
for wrote < size {
n, err := m.doWrite(t, p[wrote:])
wrote += n
if err != nil {
return wrote, err
}
}
return wrote, nil
} | go | func (m *Muxer) WriteChannel(t Channel, p []byte) (int, error) {
wrote := 0
size := len(p)
for wrote < size {
n, err := m.doWrite(t, p[wrote:])
wrote += n
if err != nil {
return wrote, err
}
}
return wrote, nil
} | [
"func",
"(",
"m",
"*",
"Muxer",
")",
"WriteChannel",
"(",
"t",
"Channel",
",",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"wrote",
":=",
"0",
"\n",
"size",
":=",
"len",
"(",
"p",
")",
"\n",
"for",
"wrote",
"<",
"size",
"{",
"n",
",",
"err",
":=",
"m",
".",
"doWrite",
"(",
"t",
",",
"p",
"[",
"wrote",
":",
"]",
")",
"\n",
"wrote",
"+=",
"n",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"wrote",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"wrote",
",",
"nil",
"\n",
"}"
] | // WriteChannel writes p in the given channel. This method can be used with any
// channel, but is recommend use it only for the ProgressMessage and
// ErrorMessage channels and use Write for the PackData channel | [
"WriteChannel",
"writes",
"p",
"in",
"the",
"given",
"channel",
".",
"This",
"method",
"can",
"be",
"used",
"with",
"any",
"channel",
"but",
"is",
"recommend",
"use",
"it",
"only",
"for",
"the",
"ProgressMessage",
"and",
"ErrorMessage",
"channels",
"and",
"use",
"Write",
"for",
"the",
"PackData",
"channel"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/sideband/muxer.go#L43-L56 | train |
src-d/go-git | plumbing/format/config/encoder.go | Encode | func (e *Encoder) Encode(cfg *Config) error {
for _, s := range cfg.Sections {
if err := e.encodeSection(s); err != nil {
return err
}
}
return nil
} | go | func (e *Encoder) Encode(cfg *Config) error {
for _, s := range cfg.Sections {
if err := e.encodeSection(s); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"e",
"*",
"Encoder",
")",
"Encode",
"(",
"cfg",
"*",
"Config",
")",
"error",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"cfg",
".",
"Sections",
"{",
"if",
"err",
":=",
"e",
".",
"encodeSection",
"(",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Encode writes the config in git config format to the stream of the encoder. | [
"Encode",
"writes",
"the",
"config",
"in",
"git",
"config",
"format",
"to",
"the",
"stream",
"of",
"the",
"encoder",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/encoder.go#L20-L28 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.