id int32 0 167k | 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 list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
160,900 | src-d/go-git | plumbing/memory.go | Reader | func (o *MemoryObject) Reader() (io.ReadCloser, error) {
return ioutil.NopCloser(bytes.NewBuffer(o.cont)), nil
} | go | func (o *MemoryObject) Reader() (io.ReadCloser, error) {
return ioutil.NopCloser(bytes.NewBuffer(o.cont)), nil
} | [
"func",
"(",
"o",
"*",
"MemoryObject",
")",
"Reader",
"(",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"return",
"ioutil",
".",
"NopCloser",
"(",
"bytes",
".",
"NewBuffer",
"(",
"o",
".",
"cont",
")",
")",
",",
"nil",
"\n",
"}"
] | // Reader returns a ObjectReader used to read the object's content. | [
"Reader",
"returns",
"a",
"ObjectReader",
"used",
"to",
"read",
"the",
"object",
"s",
"content",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/memory.go#L43-L45 |
160,901 | src-d/go-git | config/config.go | NewConfig | func NewConfig() *Config {
config := &Config{
Remotes: make(map[string]*RemoteConfig),
Submodules: make(map[string]*Submodule),
Branches: make(map[string]*Branch),
Raw: format.New(),
}
config.Pack.Window = DefaultPackWindow
return config
} | go | func NewConfig() *Config {
config := &Config{
Remotes: make(map[string]*RemoteConfig),
Submodules: make(map[string]*Submodule),
Branches: make(map[string]*Branch),
Raw: format.New(),
}
config.Pack.Window = DefaultPackWindow
return config
} | [
"func",
"NewConfig",
"(",
")",
"*",
"Config",
"{",
"config",
":=",
"&",
"Config",
"{",
"Remotes",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"RemoteConfig",
")",
",",
"Submodules",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Submodule",... | // NewConfig returns a new empty Config. | [
"NewConfig",
"returns",
"a",
"new",
"empty",
"Config",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/config/config.go#L72-L83 |
160,902 | src-d/go-git | config/config.go | Marshal | func (c *Config) Marshal() ([]byte, error) {
c.marshalCore()
c.marshalPack()
c.marshalRemotes()
c.marshalSubmodules()
c.marshalBranches()
buf := bytes.NewBuffer(nil)
if err := format.NewEncoder(buf).Encode(c.Raw); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | func (c *Config) Marshal() ([]byte, error) {
c.marshalCore()
c.marshalPack()
c.marshalRemotes()
c.marshalSubmodules()
c.marshalBranches()
buf := bytes.NewBuffer(nil)
if err := format.NewEncoder(buf).Encode(c.Raw); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Marshal",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"c",
".",
"marshalCore",
"(",
")",
"\n",
"c",
".",
"marshalPack",
"(",
")",
"\n",
"c",
".",
"marshalRemotes",
"(",
")",
"\n",
"c",
".",
... | // Marshal returns Config encoded as a git-config file. | [
"Marshal",
"returns",
"Config",
"encoded",
"as",
"a",
"git",
"-",
"config",
"file",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/config/config.go#L220-L233 |
160,903 | src-d/go-git | _examples/checkout/main.go | main | func main() {
CheckArgs("<url>", "<directory>", "<commit>")
url, directory, commit := os.Args[1], os.Args[2], os.Args[3]
// 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)
// ... retrieving the commit being pointed by HEAD
Info("git show-ref --head HEAD")
ref, err := r.Head()
CheckIfError(err)
fmt.Println(ref.Hash())
w, err := r.Worktree()
CheckIfError(err)
// ... checking out to commit
Info("git checkout %s", commit)
err = w.Checkout(&git.CheckoutOptions{
Hash: plumbing.NewHash(commit),
})
CheckIfError(err)
// ... retrieving the commit being pointed by HEAD, it shows that the
// repository is pointing to the giving commit in detached mode
Info("git show-ref --head HEAD")
ref, err = r.Head()
CheckIfError(err)
fmt.Println(ref.Hash())
} | go | func main() {
CheckArgs("<url>", "<directory>", "<commit>")
url, directory, commit := os.Args[1], os.Args[2], os.Args[3]
// 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)
// ... retrieving the commit being pointed by HEAD
Info("git show-ref --head HEAD")
ref, err := r.Head()
CheckIfError(err)
fmt.Println(ref.Hash())
w, err := r.Worktree()
CheckIfError(err)
// ... checking out to commit
Info("git checkout %s", commit)
err = w.Checkout(&git.CheckoutOptions{
Hash: plumbing.NewHash(commit),
})
CheckIfError(err)
// ... retrieving the commit being pointed by HEAD, it shows that the
// repository is pointing to the giving commit in detached mode
Info("git show-ref --head HEAD")
ref, err = r.Head()
CheckIfError(err)
fmt.Println(ref.Hash())
} | [
"func",
"main",
"(",
")",
"{",
"CheckArgs",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"url",
",",
"directory",
",",
"commit",
":=",
"os",
".",
"Args",
"[",
"1",
"]",
",",
"os",
".",
"Args",
"[",
"2",
"]",
",",
"os",
".",... | // Basic example of how to checkout a specific commit. | [
"Basic",
"example",
"of",
"how",
"to",
"checkout",
"a",
"specific",
"commit",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/_examples/checkout/main.go#L13-L47 |
160,904 | src-d/go-git | plumbing/format/objfile/reader.go | NewReader | func NewReader(r io.Reader) (*Reader, error) {
zlib, err := zlib.NewReader(r)
if err != nil {
return nil, packfile.ErrZLib.AddDetails(err.Error())
}
return &Reader{
zlib: zlib,
}, nil
} | go | func NewReader(r io.Reader) (*Reader, error) {
zlib, err := zlib.NewReader(r)
if err != nil {
return nil, packfile.ErrZLib.AddDetails(err.Error())
}
return &Reader{
zlib: zlib,
}, nil
} | [
"func",
"NewReader",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"Reader",
",",
"error",
")",
"{",
"zlib",
",",
"err",
":=",
"zlib",
".",
"NewReader",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"packfile",
".",
... | // NewReader returns a new Reader reading from r. | [
"NewReader",
"returns",
"a",
"new",
"Reader",
"reading",
"from",
"r",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/objfile/reader.go#L29-L38 |
160,905 | src-d/go-git | plumbing/format/objfile/reader.go | Header | func (r *Reader) Header() (t plumbing.ObjectType, size int64, err error) {
var raw []byte
raw, err = r.readUntil(' ')
if err != nil {
return
}
t, err = plumbing.ParseObjectType(string(raw))
if err != nil {
return
}
raw, err = r.readUntil(0)
if err != nil {
return
}
size, err = strconv.ParseInt(string(raw), 10, 64)
if err != nil {
err = ErrHeader
return
}
defer r.prepareForRead(t, size)
return
} | go | func (r *Reader) Header() (t plumbing.ObjectType, size int64, err error) {
var raw []byte
raw, err = r.readUntil(' ')
if err != nil {
return
}
t, err = plumbing.ParseObjectType(string(raw))
if err != nil {
return
}
raw, err = r.readUntil(0)
if err != nil {
return
}
size, err = strconv.ParseInt(string(raw), 10, 64)
if err != nil {
err = ErrHeader
return
}
defer r.prepareForRead(t, size)
return
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"Header",
"(",
")",
"(",
"t",
"plumbing",
".",
"ObjectType",
",",
"size",
"int64",
",",
"err",
"error",
")",
"{",
"var",
"raw",
"[",
"]",
"byte",
"\n",
"raw",
",",
"err",
"=",
"r",
".",
"readUntil",
"(",
"'... | // Header reads the type and the size of object, and prepares the reader for read | [
"Header",
"reads",
"the",
"type",
"and",
"the",
"size",
"of",
"object",
"and",
"prepares",
"the",
"reader",
"for",
"read"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/objfile/reader.go#L41-L66 |
160,906 | src-d/go-git | plumbing/format/objfile/reader.go | readUntil | func (r *Reader) readUntil(delim byte) ([]byte, error) {
var buf [1]byte
value := make([]byte, 0, 16)
for {
if n, err := r.zlib.Read(buf[:]); err != nil && (err != io.EOF || n == 0) {
if err == io.EOF {
return nil, ErrHeader
}
return nil, err
}
if buf[0] == delim {
return value, nil
}
value = append(value, buf[0])
}
} | go | func (r *Reader) readUntil(delim byte) ([]byte, error) {
var buf [1]byte
value := make([]byte, 0, 16)
for {
if n, err := r.zlib.Read(buf[:]); err != nil && (err != io.EOF || n == 0) {
if err == io.EOF {
return nil, ErrHeader
}
return nil, err
}
if buf[0] == delim {
return value, nil
}
value = append(value, buf[0])
}
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"readUntil",
"(",
"delim",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"buf",
"[",
"1",
"]",
"byte",
"\n",
"value",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"16",
")",
... | // readSlice reads one byte at a time from r until it encounters delim or an
// error. | [
"readSlice",
"reads",
"one",
"byte",
"at",
"a",
"time",
"from",
"r",
"until",
"it",
"encounters",
"delim",
"or",
"an",
"error",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/objfile/reader.go#L70-L87 |
160,907 | src-d/go-git | plumbing/format/gitattributes/matcher.go | NewMatcher | func NewMatcher(stack []MatchAttribute) Matcher {
m := &matcher{stack: stack}
m.init()
return m
} | go | func NewMatcher(stack []MatchAttribute) Matcher {
m := &matcher{stack: stack}
m.init()
return m
} | [
"func",
"NewMatcher",
"(",
"stack",
"[",
"]",
"MatchAttribute",
")",
"Matcher",
"{",
"m",
":=",
"&",
"matcher",
"{",
"stack",
":",
"stack",
"}",
"\n",
"m",
".",
"init",
"(",
")",
"\n\n",
"return",
"m",
"\n",
"}"
] | // NewMatcher constructs a new matcher. Patterns must be given in the order of
// increasing priority. That is the most generic settings files first, then the
// content of the repo .gitattributes, then content of .gitattributes down the
// path. | [
"NewMatcher",
"constructs",
"a",
"new",
"matcher",
".",
"Patterns",
"must",
"be",
"given",
"in",
"the",
"order",
"of",
"increasing",
"priority",
".",
"That",
"is",
"the",
"most",
"generic",
"settings",
"files",
"first",
"then",
"the",
"content",
"of",
"the",... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/gitattributes/matcher.go#L15-L20 |
160,908 | src-d/go-git | plumbing/format/gitattributes/matcher.go | Match | func (m *matcher) Match(path []string, attributes []string) (results map[string]Attribute, matched bool) {
results = make(map[string]Attribute, len(attributes))
n := len(m.stack)
for i := n - 1; i >= 0; i-- {
if len(attributes) > 0 && len(attributes) == len(results) {
return
}
pattern := m.stack[i].Pattern
if pattern == nil {
continue
}
if match := pattern.Match(path); match {
matched = true
for _, attr := range m.stack[i].Attributes {
if attr.IsSet() {
m.expandMacro(attr.Name(), results)
}
results[attr.Name()] = attr
}
}
}
return
} | go | func (m *matcher) Match(path []string, attributes []string) (results map[string]Attribute, matched bool) {
results = make(map[string]Attribute, len(attributes))
n := len(m.stack)
for i := n - 1; i >= 0; i-- {
if len(attributes) > 0 && len(attributes) == len(results) {
return
}
pattern := m.stack[i].Pattern
if pattern == nil {
continue
}
if match := pattern.Match(path); match {
matched = true
for _, attr := range m.stack[i].Attributes {
if attr.IsSet() {
m.expandMacro(attr.Name(), results)
}
results[attr.Name()] = attr
}
}
}
return
} | [
"func",
"(",
"m",
"*",
"matcher",
")",
"Match",
"(",
"path",
"[",
"]",
"string",
",",
"attributes",
"[",
"]",
"string",
")",
"(",
"results",
"map",
"[",
"string",
"]",
"Attribute",
",",
"matched",
"bool",
")",
"{",
"results",
"=",
"make",
"(",
"map... | // Match matches path against the patterns in gitattributes files and returns
// the attributes associated with the path.
//
// Specific attributes can be specified otherwise all attributes are returned.
//
// Matched is true if any path was matched to a rule, even if the results map
// is empty. | [
"Match",
"matches",
"path",
"against",
"the",
"patterns",
"in",
"gitattributes",
"files",
"and",
"returns",
"the",
"attributes",
"associated",
"with",
"the",
"path",
".",
"Specific",
"attributes",
"can",
"be",
"specified",
"otherwise",
"all",
"attributes",
"are",
... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/gitattributes/matcher.go#L44-L69 |
160,909 | src-d/go-git | plumbing/format/commitgraph/memory.go | GetIndexByHash | func (mi *MemoryIndex) GetIndexByHash(h plumbing.Hash) (int, error) {
i, ok := mi.indexMap[h]
if ok {
return i, nil
}
return 0, plumbing.ErrObjectNotFound
} | go | func (mi *MemoryIndex) GetIndexByHash(h plumbing.Hash) (int, error) {
i, ok := mi.indexMap[h]
if ok {
return i, nil
}
return 0, plumbing.ErrObjectNotFound
} | [
"func",
"(",
"mi",
"*",
"MemoryIndex",
")",
"GetIndexByHash",
"(",
"h",
"plumbing",
".",
"Hash",
")",
"(",
"int",
",",
"error",
")",
"{",
"i",
",",
"ok",
":=",
"mi",
".",
"indexMap",
"[",
"h",
"]",
"\n",
"if",
"ok",
"{",
"return",
"i",
",",
"ni... | // GetIndexByHash gets the index in the commit graph from commit hash, if available | [
"GetIndexByHash",
"gets",
"the",
"index",
"in",
"the",
"commit",
"graph",
"from",
"commit",
"hash",
"if",
"available"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/commitgraph/memory.go#L20-L27 |
160,910 | src-d/go-git | plumbing/format/commitgraph/memory.go | GetCommitDataByIndex | func (mi *MemoryIndex) GetCommitDataByIndex(i int) (*CommitData, error) {
if int(i) >= len(mi.commitData) {
return nil, plumbing.ErrObjectNotFound
}
commitData := mi.commitData[i]
// Map parent hashes to parent indexes
if commitData.ParentIndexes == nil {
parentIndexes := make([]int, len(commitData.ParentHashes))
for i, parentHash := range commitData.ParentHashes {
var err error
if parentIndexes[i], err = mi.GetIndexByHash(parentHash); err != nil {
return nil, err
}
}
commitData.ParentIndexes = parentIndexes
}
return commitData, nil
} | go | func (mi *MemoryIndex) GetCommitDataByIndex(i int) (*CommitData, error) {
if int(i) >= len(mi.commitData) {
return nil, plumbing.ErrObjectNotFound
}
commitData := mi.commitData[i]
// Map parent hashes to parent indexes
if commitData.ParentIndexes == nil {
parentIndexes := make([]int, len(commitData.ParentHashes))
for i, parentHash := range commitData.ParentHashes {
var err error
if parentIndexes[i], err = mi.GetIndexByHash(parentHash); err != nil {
return nil, err
}
}
commitData.ParentIndexes = parentIndexes
}
return commitData, nil
} | [
"func",
"(",
"mi",
"*",
"MemoryIndex",
")",
"GetCommitDataByIndex",
"(",
"i",
"int",
")",
"(",
"*",
"CommitData",
",",
"error",
")",
"{",
"if",
"int",
"(",
"i",
")",
">=",
"len",
"(",
"mi",
".",
"commitData",
")",
"{",
"return",
"nil",
",",
"plumbi... | // GetCommitDataByIndex gets the commit node from the commit graph using index
// obtained from child node, if available | [
"GetCommitDataByIndex",
"gets",
"the",
"commit",
"node",
"from",
"the",
"commit",
"graph",
"using",
"index",
"obtained",
"from",
"child",
"node",
"if",
"available"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/commitgraph/memory.go#L31-L51 |
160,911 | src-d/go-git | plumbing/format/commitgraph/memory.go | Add | func (mi *MemoryIndex) Add(hash plumbing.Hash, commitData *CommitData) {
// The parent indexes are calculated lazily in GetNodeByIndex
// which allows adding nodes out of order as long as all parents
// are eventually resolved
commitData.ParentIndexes = nil
mi.indexMap[hash] = len(mi.commitData)
mi.commitData = append(mi.commitData, commitData)
} | go | func (mi *MemoryIndex) Add(hash plumbing.Hash, commitData *CommitData) {
// The parent indexes are calculated lazily in GetNodeByIndex
// which allows adding nodes out of order as long as all parents
// are eventually resolved
commitData.ParentIndexes = nil
mi.indexMap[hash] = len(mi.commitData)
mi.commitData = append(mi.commitData, commitData)
} | [
"func",
"(",
"mi",
"*",
"MemoryIndex",
")",
"Add",
"(",
"hash",
"plumbing",
".",
"Hash",
",",
"commitData",
"*",
"CommitData",
")",
"{",
"// The parent indexes are calculated lazily in GetNodeByIndex\r",
"// which allows adding nodes out of order as long as all parents\r",
"/... | // Add adds new node to the memory index | [
"Add",
"adds",
"new",
"node",
"to",
"the",
"memory",
"index"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/commitgraph/memory.go#L63-L70 |
160,912 | src-d/go-git | _examples/clone/main.go | main | func main() {
CheckArgs("<url>", "<directory>")
url := os.Args[1]
directory := os.Args[2]
// Clone the given repository to the given directory
Info("git clone %s %s --recursive", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,
})
CheckIfError(err)
// ... retrieving the branch being pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieving the commit object
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
} | go | func main() {
CheckArgs("<url>", "<directory>")
url := os.Args[1]
directory := os.Args[2]
// Clone the given repository to the given directory
Info("git clone %s %s --recursive", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,
})
CheckIfError(err)
// ... retrieving the branch being pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieving the commit object
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
} | [
"func",
"main",
"(",
")",
"{",
"CheckArgs",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"url",
":=",
"os",
".",
"Args",
"[",
"1",
"]",
"\n",
"directory",
":=",
"os",
".",
"Args",
"[",
"2",
"]",
"\n\n",
"// Clone the given repository to the given direc... | // Basic example of how to clone a repository using clone options. | [
"Basic",
"example",
"of",
"how",
"to",
"clone",
"a",
"repository",
"using",
"clone",
"options",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/_examples/clone/main.go#L12-L35 |
160,913 | src-d/go-git | plumbing/hash.go | ComputeHash | func ComputeHash(t ObjectType, content []byte) Hash {
h := NewHasher(t, int64(len(content)))
h.Write(content)
return h.Sum()
} | go | func ComputeHash(t ObjectType, content []byte) Hash {
h := NewHasher(t, int64(len(content)))
h.Write(content)
return h.Sum()
} | [
"func",
"ComputeHash",
"(",
"t",
"ObjectType",
",",
"content",
"[",
"]",
"byte",
")",
"Hash",
"{",
"h",
":=",
"NewHasher",
"(",
"t",
",",
"int64",
"(",
"len",
"(",
"content",
")",
")",
")",
"\n",
"h",
".",
"Write",
"(",
"content",
")",
"\n",
"ret... | // ComputeHash compute the hash for a given ObjectType and content | [
"ComputeHash",
"compute",
"the",
"hash",
"for",
"a",
"given",
"ObjectType",
"and",
"content"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/hash.go#L19-L23 |
160,914 | src-d/go-git | plumbing/hash.go | NewHash | func NewHash(s string) Hash {
b, _ := hex.DecodeString(s)
var h Hash
copy(h[:], b)
return h
} | go | func NewHash(s string) Hash {
b, _ := hex.DecodeString(s)
var h Hash
copy(h[:], b)
return h
} | [
"func",
"NewHash",
"(",
"s",
"string",
")",
"Hash",
"{",
"b",
",",
"_",
":=",
"hex",
".",
"DecodeString",
"(",
"s",
")",
"\n\n",
"var",
"h",
"Hash",
"\n",
"copy",
"(",
"h",
"[",
":",
"]",
",",
"b",
")",
"\n\n",
"return",
"h",
"\n",
"}"
] | // NewHash return a new Hash from a hexadecimal hash representation | [
"NewHash",
"return",
"a",
"new",
"Hash",
"from",
"a",
"hexadecimal",
"hash",
"representation"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/hash.go#L26-L33 |
160,915 | src-d/go-git | plumbing/transport/ssh/auth_method.go | NewPublicKeysFromFile | func NewPublicKeysFromFile(user, pemFile, password string) (*PublicKeys, error) {
bytes, err := ioutil.ReadFile(pemFile)
if err != nil {
return nil, err
}
return NewPublicKeys(user, bytes, password)
} | go | func NewPublicKeysFromFile(user, pemFile, password string) (*PublicKeys, error) {
bytes, err := ioutil.ReadFile(pemFile)
if err != nil {
return nil, err
}
return NewPublicKeys(user, bytes, password)
} | [
"func",
"NewPublicKeysFromFile",
"(",
"user",
",",
"pemFile",
",",
"password",
"string",
")",
"(",
"*",
"PublicKeys",
",",
"error",
")",
"{",
"bytes",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"pemFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{"... | // NewPublicKeysFromFile returns a PublicKeys from a file containing a PEM
// encoded private key. An encryption password should be given if the pemBytes
// contains a password encrypted PEM block otherwise password should be empty. | [
"NewPublicKeysFromFile",
"returns",
"a",
"PublicKeys",
"from",
"a",
"file",
"containing",
"a",
"PEM",
"encoded",
"private",
"key",
".",
"An",
"encryption",
"password",
"should",
"be",
"given",
"if",
"the",
"pemBytes",
"contains",
"a",
"password",
"encrypted",
"P... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/ssh/auth_method.go#L151-L158 |
160,916 | src-d/go-git | plumbing/transport/ssh/auth_method.go | NewSSHAgentAuth | func NewSSHAgentAuth(u string) (*PublicKeysCallback, error) {
var err error
if u == "" {
u, err = username()
if err != nil {
return nil, err
}
}
a, _, err := sshagent.New()
if err != nil {
return nil, fmt.Errorf("error creating SSH agent: %q", err)
}
return &PublicKeysCallback{
User: u,
Callback: a.Signers,
}, nil
} | go | func NewSSHAgentAuth(u string) (*PublicKeysCallback, error) {
var err error
if u == "" {
u, err = username()
if err != nil {
return nil, err
}
}
a, _, err := sshagent.New()
if err != nil {
return nil, fmt.Errorf("error creating SSH agent: %q", err)
}
return &PublicKeysCallback{
User: u,
Callback: a.Signers,
}, nil
} | [
"func",
"NewSSHAgentAuth",
"(",
"u",
"string",
")",
"(",
"*",
"PublicKeysCallback",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"u",
"==",
"\"",
"\"",
"{",
"u",
",",
"err",
"=",
"username",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // NewSSHAgentAuth returns a PublicKeysCallback based on a SSH agent, it opens
// a pipe with the SSH agent and uses the pipe as the implementer of the public
// key callback function. | [
"NewSSHAgentAuth",
"returns",
"a",
"PublicKeysCallback",
"based",
"on",
"a",
"SSH",
"agent",
"it",
"opens",
"a",
"pipe",
"with",
"the",
"SSH",
"agent",
"and",
"uses",
"the",
"pipe",
"as",
"the",
"implementer",
"of",
"the",
"public",
"key",
"callback",
"funct... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/ssh/auth_method.go#L201-L219 |
160,917 | src-d/go-git | plumbing/transport/ssh/auth_method.go | SetHostKeyCallback | func (m *HostKeyCallbackHelper) SetHostKeyCallback(cfg *ssh.ClientConfig) (*ssh.ClientConfig, error) {
var err error
if m.HostKeyCallback == nil {
if m.HostKeyCallback, err = NewKnownHostsCallback(); err != nil {
return cfg, err
}
}
cfg.HostKeyCallback = m.HostKeyCallback
return cfg, nil
} | go | func (m *HostKeyCallbackHelper) SetHostKeyCallback(cfg *ssh.ClientConfig) (*ssh.ClientConfig, error) {
var err error
if m.HostKeyCallback == nil {
if m.HostKeyCallback, err = NewKnownHostsCallback(); err != nil {
return cfg, err
}
}
cfg.HostKeyCallback = m.HostKeyCallback
return cfg, nil
} | [
"func",
"(",
"m",
"*",
"HostKeyCallbackHelper",
")",
"SetHostKeyCallback",
"(",
"cfg",
"*",
"ssh",
".",
"ClientConfig",
")",
"(",
"*",
"ssh",
".",
"ClientConfig",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"m",
".",
"HostKeyCallback",
"==... | // SetHostKeyCallback sets the field HostKeyCallback in the given cfg. If
// HostKeyCallback is empty a default callback is created using
// NewKnownHostsCallback. | [
"SetHostKeyCallback",
"sets",
"the",
"field",
"HostKeyCallback",
"in",
"the",
"given",
"cfg",
".",
"If",
"HostKeyCallback",
"is",
"empty",
"a",
"default",
"callback",
"is",
"created",
"using",
"NewKnownHostsCallback",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/ssh/auth_method.go#L312-L322 |
160,918 | src-d/go-git | utils/merkletrie/doubleiter.go | newDoubleIter | func newDoubleIter(from, to noder.Noder, hashEqual noder.Equal) (
*doubleIter, error) {
var ii doubleIter
var err error
if ii.from.iter, err = NewIter(from); err != nil {
return nil, fmt.Errorf("from: %s", err)
}
if ii.from.current, err = ii.from.iter.Next(); turnEOFIntoNil(err) != nil {
return nil, fmt.Errorf("from: %s", err)
}
if ii.to.iter, err = NewIter(to); err != nil {
return nil, fmt.Errorf("to: %s", err)
}
if ii.to.current, err = ii.to.iter.Next(); turnEOFIntoNil(err) != nil {
return nil, fmt.Errorf("to: %s", err)
}
ii.hashEqual = hashEqual
return &ii, nil
} | go | func newDoubleIter(from, to noder.Noder, hashEqual noder.Equal) (
*doubleIter, error) {
var ii doubleIter
var err error
if ii.from.iter, err = NewIter(from); err != nil {
return nil, fmt.Errorf("from: %s", err)
}
if ii.from.current, err = ii.from.iter.Next(); turnEOFIntoNil(err) != nil {
return nil, fmt.Errorf("from: %s", err)
}
if ii.to.iter, err = NewIter(to); err != nil {
return nil, fmt.Errorf("to: %s", err)
}
if ii.to.current, err = ii.to.iter.Next(); turnEOFIntoNil(err) != nil {
return nil, fmt.Errorf("to: %s", err)
}
ii.hashEqual = hashEqual
return &ii, nil
} | [
"func",
"newDoubleIter",
"(",
"from",
",",
"to",
"noder",
".",
"Noder",
",",
"hashEqual",
"noder",
".",
"Equal",
")",
"(",
"*",
"doubleIter",
",",
"error",
")",
"{",
"var",
"ii",
"doubleIter",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"ii",
".",
"fr... | // NewdoubleIter returns a new doubleIter for the merkletries "from" and
// "to". The hashEqual callback function will be used by the doubleIter
// to compare the hash of the noders in the merkletries. The doubleIter
// will be initialized to the first elements in each merkletrie if any. | [
"NewdoubleIter",
"returns",
"a",
"new",
"doubleIter",
"for",
"the",
"merkletries",
"from",
"and",
"to",
".",
"The",
"hashEqual",
"callback",
"function",
"will",
"be",
"used",
"by",
"the",
"doubleIter",
"to",
"compare",
"the",
"hash",
"of",
"the",
"noders",
"... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/doubleiter.go#L38-L60 |
160,919 | src-d/go-git | utils/merkletrie/doubleiter.go | nextBoth | func (d *doubleIter) nextBoth() error {
if err := d.nextFrom(); err != nil {
return err
}
if err := d.nextTo(); err != nil {
return err
}
return nil
} | go | func (d *doubleIter) nextBoth() error {
if err := d.nextFrom(); err != nil {
return err
}
if err := d.nextTo(); err != nil {
return err
}
return nil
} | [
"func",
"(",
"d",
"*",
"doubleIter",
")",
"nextBoth",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"d",
".",
"nextFrom",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"d",
".",
"nextTo",
"(",
")",
... | // NextBoth makes d advance to the next noder in both merkletries. If
// any of them is a directory, it skips its contents. | [
"NextBoth",
"makes",
"d",
"advance",
"to",
"the",
"next",
"noder",
"in",
"both",
"merkletries",
".",
"If",
"any",
"of",
"them",
"is",
"a",
"directory",
"it",
"skips",
"its",
"contents",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/doubleiter.go#L71-L80 |
160,920 | src-d/go-git | utils/merkletrie/doubleiter.go | nextFrom | func (d *doubleIter) nextFrom() (err error) {
d.from.current, err = d.from.iter.Next()
return turnEOFIntoNil(err)
} | go | func (d *doubleIter) nextFrom() (err error) {
d.from.current, err = d.from.iter.Next()
return turnEOFIntoNil(err)
} | [
"func",
"(",
"d",
"*",
"doubleIter",
")",
"nextFrom",
"(",
")",
"(",
"err",
"error",
")",
"{",
"d",
".",
"from",
".",
"current",
",",
"err",
"=",
"d",
".",
"from",
".",
"iter",
".",
"Next",
"(",
")",
"\n",
"return",
"turnEOFIntoNil",
"(",
"err",
... | // NextFrom makes d advance to the next noder in the "from" merkletrie,
// skipping its contents if it is a directory. | [
"NextFrom",
"makes",
"d",
"advance",
"to",
"the",
"next",
"noder",
"in",
"the",
"from",
"merkletrie",
"skipping",
"its",
"contents",
"if",
"it",
"is",
"a",
"directory",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/doubleiter.go#L84-L87 |
160,921 | src-d/go-git | utils/merkletrie/doubleiter.go | nextTo | func (d *doubleIter) nextTo() (err error) {
d.to.current, err = d.to.iter.Next()
return turnEOFIntoNil(err)
} | go | func (d *doubleIter) nextTo() (err error) {
d.to.current, err = d.to.iter.Next()
return turnEOFIntoNil(err)
} | [
"func",
"(",
"d",
"*",
"doubleIter",
")",
"nextTo",
"(",
")",
"(",
"err",
"error",
")",
"{",
"d",
".",
"to",
".",
"current",
",",
"err",
"=",
"d",
".",
"to",
".",
"iter",
".",
"Next",
"(",
")",
"\n",
"return",
"turnEOFIntoNil",
"(",
"err",
")",... | // NextTo makes d advance to the next noder in the "to" merkletrie,
// skipping its contents if it is a directory. | [
"NextTo",
"makes",
"d",
"advance",
"to",
"the",
"next",
"noder",
"in",
"the",
"to",
"merkletrie",
"skipping",
"its",
"contents",
"if",
"it",
"is",
"a",
"directory",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/doubleiter.go#L91-L94 |
160,922 | src-d/go-git | utils/merkletrie/doubleiter.go | stepBoth | func (d *doubleIter) stepBoth() (err error) {
if d.from.current, err = d.from.iter.Step(); turnEOFIntoNil(err) != nil {
return err
}
if d.to.current, err = d.to.iter.Step(); turnEOFIntoNil(err) != nil {
return err
}
return nil
} | go | func (d *doubleIter) stepBoth() (err error) {
if d.from.current, err = d.from.iter.Step(); turnEOFIntoNil(err) != nil {
return err
}
if d.to.current, err = d.to.iter.Step(); turnEOFIntoNil(err) != nil {
return err
}
return nil
} | [
"func",
"(",
"d",
"*",
"doubleIter",
")",
"stepBoth",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"d",
".",
"from",
".",
"current",
",",
"err",
"=",
"d",
".",
"from",
".",
"iter",
".",
"Step",
"(",
")",
";",
"turnEOFIntoNil",
"(",
"err",
")"... | // StepBoth makes d advance to the next noder in both merkletries,
// getting deeper into directories if that is the case. | [
"StepBoth",
"makes",
"d",
"advance",
"to",
"the",
"next",
"noder",
"in",
"both",
"merkletries",
"getting",
"deeper",
"into",
"directories",
"if",
"that",
"is",
"the",
"case",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/doubleiter.go#L98-L106 |
160,923 | src-d/go-git | utils/merkletrie/doubleiter.go | remaining | func (d *doubleIter) remaining() remaining {
if d.from.current == nil && d.to.current == nil {
return noMoreNoders
}
if d.from.current == nil && d.to.current != nil {
return onlyToRemains
}
if d.from.current != nil && d.to.current == nil {
return onlyFromRemains
}
return bothHaveNodes
} | go | func (d *doubleIter) remaining() remaining {
if d.from.current == nil && d.to.current == nil {
return noMoreNoders
}
if d.from.current == nil && d.to.current != nil {
return onlyToRemains
}
if d.from.current != nil && d.to.current == nil {
return onlyFromRemains
}
return bothHaveNodes
} | [
"func",
"(",
"d",
"*",
"doubleIter",
")",
"remaining",
"(",
")",
"remaining",
"{",
"if",
"d",
".",
"from",
".",
"current",
"==",
"nil",
"&&",
"d",
".",
"to",
".",
"current",
"==",
"nil",
"{",
"return",
"noMoreNoders",
"\n",
"}",
"\n\n",
"if",
"d",
... | // Remaining returns if there are no more noders in the tree, if both
// have noders or if one of them doesn't. | [
"Remaining",
"returns",
"if",
"there",
"are",
"no",
"more",
"noders",
"in",
"the",
"tree",
"if",
"both",
"have",
"noders",
"or",
"if",
"one",
"of",
"them",
"doesn",
"t",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/doubleiter.go#L110-L124 |
160,924 | src-d/go-git | utils/merkletrie/doubleiter.go | compare | func (d *doubleIter) compare() (s comparison, err error) {
s.sameHash = d.hashEqual(d.from.current, d.to.current)
fromIsDir := d.from.current.IsDir()
toIsDir := d.to.current.IsDir()
s.bothAreDirs = fromIsDir && toIsDir
s.bothAreFiles = !fromIsDir && !toIsDir
s.fileAndDir = !s.bothAreDirs && !s.bothAreFiles
fromNumChildren, err := d.from.current.NumChildren()
if err != nil {
return comparison{}, fmt.Errorf("from: %s", err)
}
toNumChildren, err := d.to.current.NumChildren()
if err != nil {
return comparison{}, fmt.Errorf("to: %s", err)
}
s.fromIsEmptyDir = fromIsDir && fromNumChildren == 0
s.toIsEmptyDir = toIsDir && toNumChildren == 0
return
} | go | func (d *doubleIter) compare() (s comparison, err error) {
s.sameHash = d.hashEqual(d.from.current, d.to.current)
fromIsDir := d.from.current.IsDir()
toIsDir := d.to.current.IsDir()
s.bothAreDirs = fromIsDir && toIsDir
s.bothAreFiles = !fromIsDir && !toIsDir
s.fileAndDir = !s.bothAreDirs && !s.bothAreFiles
fromNumChildren, err := d.from.current.NumChildren()
if err != nil {
return comparison{}, fmt.Errorf("from: %s", err)
}
toNumChildren, err := d.to.current.NumChildren()
if err != nil {
return comparison{}, fmt.Errorf("to: %s", err)
}
s.fromIsEmptyDir = fromIsDir && fromNumChildren == 0
s.toIsEmptyDir = toIsDir && toNumChildren == 0
return
} | [
"func",
"(",
"d",
"*",
"doubleIter",
")",
"compare",
"(",
")",
"(",
"s",
"comparison",
",",
"err",
"error",
")",
"{",
"s",
".",
"sameHash",
"=",
"d",
".",
"hashEqual",
"(",
"d",
".",
"from",
".",
"current",
",",
"d",
".",
"to",
".",
"current",
... | // Compare returns the comparison between the current elements in the
// merkletries. | [
"Compare",
"returns",
"the",
"comparison",
"between",
"the",
"current",
"elements",
"in",
"the",
"merkletries",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/doubleiter.go#L139-L163 |
160,925 | src-d/go-git | plumbing/protocol/packp/report_status.go | Error | func (s *ReportStatus) Error() error {
if s.UnpackStatus != ok {
return fmt.Errorf("unpack error: %s", s.UnpackStatus)
}
for _, s := range s.CommandStatuses {
if err := s.Error(); err != nil {
return err
}
}
return nil
} | go | func (s *ReportStatus) Error() error {
if s.UnpackStatus != ok {
return fmt.Errorf("unpack error: %s", s.UnpackStatus)
}
for _, s := range s.CommandStatuses {
if err := s.Error(); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"s",
"*",
"ReportStatus",
")",
"Error",
"(",
")",
"error",
"{",
"if",
"s",
".",
"UnpackStatus",
"!=",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"UnpackStatus",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",... | // Error returns the first error if any. | [
"Error",
"returns",
"the",
"first",
"error",
"if",
"any",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/report_status.go#L30-L42 |
160,926 | src-d/go-git | plumbing/protocol/packp/report_status.go | Encode | func (s *ReportStatus) Encode(w io.Writer) error {
e := pktline.NewEncoder(w)
if err := e.Encodef("unpack %s\n", s.UnpackStatus); err != nil {
return err
}
for _, cs := range s.CommandStatuses {
if err := cs.encode(w); err != nil {
return err
}
}
return e.Flush()
} | go | func (s *ReportStatus) Encode(w io.Writer) error {
e := pktline.NewEncoder(w)
if err := e.Encodef("unpack %s\n", s.UnpackStatus); err != nil {
return err
}
for _, cs := range s.CommandStatuses {
if err := cs.encode(w); err != nil {
return err
}
}
return e.Flush()
} | [
"func",
"(",
"s",
"*",
"ReportStatus",
")",
"Encode",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"e",
":=",
"pktline",
".",
"NewEncoder",
"(",
"w",
")",
"\n",
"if",
"err",
":=",
"e",
".",
"Encodef",
"(",
"\"",
"\\n",
"\"",
",",
"s",
".",... | // Encode writes the report status to a writer. | [
"Encode",
"writes",
"the",
"report",
"status",
"to",
"a",
"writer",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/report_status.go#L45-L58 |
160,927 | src-d/go-git | plumbing/protocol/packp/report_status.go | Decode | func (s *ReportStatus) Decode(r io.Reader) error {
scan := pktline.NewScanner(r)
if err := s.scanFirstLine(scan); err != nil {
return err
}
if err := s.decodeReportStatus(scan.Bytes()); err != nil {
return err
}
flushed := false
for scan.Scan() {
b := scan.Bytes()
if isFlush(b) {
flushed = true
break
}
if err := s.decodeCommandStatus(b); err != nil {
return err
}
}
if !flushed {
return fmt.Errorf("missing flush")
}
return scan.Err()
} | go | func (s *ReportStatus) Decode(r io.Reader) error {
scan := pktline.NewScanner(r)
if err := s.scanFirstLine(scan); err != nil {
return err
}
if err := s.decodeReportStatus(scan.Bytes()); err != nil {
return err
}
flushed := false
for scan.Scan() {
b := scan.Bytes()
if isFlush(b) {
flushed = true
break
}
if err := s.decodeCommandStatus(b); err != nil {
return err
}
}
if !flushed {
return fmt.Errorf("missing flush")
}
return scan.Err()
} | [
"func",
"(",
"s",
"*",
"ReportStatus",
")",
"Decode",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"scan",
":=",
"pktline",
".",
"NewScanner",
"(",
"r",
")",
"\n",
"if",
"err",
":=",
"s",
".",
"scanFirstLine",
"(",
"scan",
")",
";",
"err",
"... | // Decode reads from the given reader and decodes a report-status message. It
// does not read more input than what is needed to fill the report status. | [
"Decode",
"reads",
"from",
"the",
"given",
"reader",
"and",
"decodes",
"a",
"report",
"-",
"status",
"message",
".",
"It",
"does",
"not",
"read",
"more",
"input",
"than",
"what",
"is",
"needed",
"to",
"fill",
"the",
"report",
"status",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/report_status.go#L62-L90 |
160,928 | src-d/go-git | plumbing/protocol/packp/report_status.go | Error | func (s *CommandStatus) Error() error {
if s.Status == ok {
return nil
}
return fmt.Errorf("command error on %s: %s",
s.ReferenceName.String(), s.Status)
} | go | func (s *CommandStatus) Error() error {
if s.Status == ok {
return nil
}
return fmt.Errorf("command error on %s: %s",
s.ReferenceName.String(), s.Status)
} | [
"func",
"(",
"s",
"*",
"CommandStatus",
")",
"Error",
"(",
")",
"error",
"{",
"if",
"s",
".",
"Status",
"==",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"ReferenceName",
".",
"St... | // Error returns the error, if any. | [
"Error",
"returns",
"the",
"error",
"if",
"any",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/protocol/packp/report_status.go#L149-L156 |
160,929 | src-d/go-git | plumbing/format/gitattributes/attributes.go | ReadAttributes | func ReadAttributes(r io.Reader, domain []string, allowMacro bool) (attributes []MatchAttribute, err error) {
data, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
for _, line := range strings.Split(string(data), eol) {
attribute, err := ParseAttributesLine(line, domain, allowMacro)
if err != nil {
return attributes, err
}
if len(attribute.Name) == 0 {
continue
}
attributes = append(attributes, attribute)
}
return attributes, nil
} | go | func ReadAttributes(r io.Reader, domain []string, allowMacro bool) (attributes []MatchAttribute, err error) {
data, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
for _, line := range strings.Split(string(data), eol) {
attribute, err := ParseAttributesLine(line, domain, allowMacro)
if err != nil {
return attributes, err
}
if len(attribute.Name) == 0 {
continue
}
attributes = append(attributes, attribute)
}
return attributes, nil
} | [
"func",
"ReadAttributes",
"(",
"r",
"io",
".",
"Reader",
",",
"domain",
"[",
"]",
"string",
",",
"allowMacro",
"bool",
")",
"(",
"attributes",
"[",
"]",
"MatchAttribute",
",",
"err",
"error",
")",
"{",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadAll"... | // ReadAttributes reads patterns and attributes from the gitattributes format. | [
"ReadAttributes",
"reads",
"patterns",
"and",
"attributes",
"from",
"the",
"gitattributes",
"format",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/gitattributes/attributes.go#L91-L110 |
160,930 | src-d/go-git | plumbing/format/gitattributes/attributes.go | ParseAttributesLine | func ParseAttributesLine(line string, domain []string, allowMacro bool) (m MatchAttribute, err error) {
line = strings.TrimSpace(line)
if strings.HasPrefix(line, commentPrefix) || len(line) == 0 {
return
}
name, unquoted := unquote(line)
attrs := strings.Fields(unquoted)
if len(name) == 0 {
name = attrs[0]
attrs = attrs[1:]
}
var macro bool
macro, name, err = checkMacro(name, allowMacro)
if err != nil {
return
}
m.Name = name
m.Attributes = make([]Attribute, 0, len(attrs))
for _, attrName := range attrs {
attr := attribute{
name: attrName,
state: attributeSet,
}
// ! and - prefixes
state := attributeState(attr.name[0])
if state == attributeUnspecified || state == attributeUnset {
attr.state = state
attr.name = attr.name[1:]
}
kv := strings.SplitN(attrName, "=", 2)
if len(kv) == 2 {
attr.name = kv[0]
attr.value = kv[1]
attr.state = attributeSetValue
}
if !validAttributeName(attr.name) {
return m, ErrInvalidAttributeName
}
m.Attributes = append(m.Attributes, attr)
}
if !macro {
m.Pattern = ParsePattern(name, domain)
}
return
} | go | func ParseAttributesLine(line string, domain []string, allowMacro bool) (m MatchAttribute, err error) {
line = strings.TrimSpace(line)
if strings.HasPrefix(line, commentPrefix) || len(line) == 0 {
return
}
name, unquoted := unquote(line)
attrs := strings.Fields(unquoted)
if len(name) == 0 {
name = attrs[0]
attrs = attrs[1:]
}
var macro bool
macro, name, err = checkMacro(name, allowMacro)
if err != nil {
return
}
m.Name = name
m.Attributes = make([]Attribute, 0, len(attrs))
for _, attrName := range attrs {
attr := attribute{
name: attrName,
state: attributeSet,
}
// ! and - prefixes
state := attributeState(attr.name[0])
if state == attributeUnspecified || state == attributeUnset {
attr.state = state
attr.name = attr.name[1:]
}
kv := strings.SplitN(attrName, "=", 2)
if len(kv) == 2 {
attr.name = kv[0]
attr.value = kv[1]
attr.state = attributeSetValue
}
if !validAttributeName(attr.name) {
return m, ErrInvalidAttributeName
}
m.Attributes = append(m.Attributes, attr)
}
if !macro {
m.Pattern = ParsePattern(name, domain)
}
return
} | [
"func",
"ParseAttributesLine",
"(",
"line",
"string",
",",
"domain",
"[",
"]",
"string",
",",
"allowMacro",
"bool",
")",
"(",
"m",
"MatchAttribute",
",",
"err",
"error",
")",
"{",
"line",
"=",
"strings",
".",
"TrimSpace",
"(",
"line",
")",
"\n\n",
"if",
... | // ParseAttributesLine parses a gitattribute line, extracting path pattern and
// attributes. | [
"ParseAttributesLine",
"parses",
"a",
"gitattribute",
"line",
"extracting",
"path",
"pattern",
"and",
"attributes",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/gitattributes/attributes.go#L114-L167 |
160,931 | src-d/go-git | _examples/pull/main.go | main | func main() {
CheckArgs("<path>")
path := os.Args[1]
// We instance\iate a new repository targeting the given path (the .git folder)
r, err := git.PlainOpen(path)
CheckIfError(err)
// Get the working directory for the repository
w, err := r.Worktree()
CheckIfError(err)
// Pull the latest changes from the origin remote and merge into the current branch
Info("git pull origin")
err = w.Pull(&git.PullOptions{RemoteName: "origin"})
CheckIfError(err)
// Print the latest commit that was just pulled
ref, err := r.Head()
CheckIfError(err)
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
} | go | func main() {
CheckArgs("<path>")
path := os.Args[1]
// We instance\iate a new repository targeting the given path (the .git folder)
r, err := git.PlainOpen(path)
CheckIfError(err)
// Get the working directory for the repository
w, err := r.Worktree()
CheckIfError(err)
// Pull the latest changes from the origin remote and merge into the current branch
Info("git pull origin")
err = w.Pull(&git.PullOptions{RemoteName: "origin"})
CheckIfError(err)
// Print the latest commit that was just pulled
ref, err := r.Head()
CheckIfError(err)
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
} | [
"func",
"main",
"(",
")",
"{",
"CheckArgs",
"(",
"\"",
"\"",
")",
"\n",
"path",
":=",
"os",
".",
"Args",
"[",
"1",
"]",
"\n\n",
"// We instance\\iate a new repository targeting the given path (the .git folder)",
"r",
",",
"err",
":=",
"git",
".",
"PlainOpen",
... | // Pull changes from a remote repository | [
"Pull",
"changes",
"from",
"a",
"remote",
"repository"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/_examples/pull/main.go#L12-L36 |
160,932 | src-d/go-git | plumbing/transport/file/client.go | NewClient | func NewClient(uploadPackBin, receivePackBin string) transport.Transport {
return common.NewClient(&runner{
UploadPackBin: uploadPackBin,
ReceivePackBin: receivePackBin,
})
} | go | func NewClient(uploadPackBin, receivePackBin string) transport.Transport {
return common.NewClient(&runner{
UploadPackBin: uploadPackBin,
ReceivePackBin: receivePackBin,
})
} | [
"func",
"NewClient",
"(",
"uploadPackBin",
",",
"receivePackBin",
"string",
")",
"transport",
".",
"Transport",
"{",
"return",
"common",
".",
"NewClient",
"(",
"&",
"runner",
"{",
"UploadPackBin",
":",
"uploadPackBin",
",",
"ReceivePackBin",
":",
"receivePackBin",... | // NewClient returns a new local client using the given git-upload-pack and
// git-receive-pack binaries. | [
"NewClient",
"returns",
"a",
"new",
"local",
"client",
"using",
"the",
"given",
"git",
"-",
"upload",
"-",
"pack",
"and",
"git",
"-",
"receive",
"-",
"pack",
"binaries",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/file/client.go#L30-L35 |
160,933 | src-d/go-git | plumbing/transport/file/client.go | Close | func (c *command) Close() error {
if c.closed {
return nil
}
defer func() {
c.closed = true
_ = c.stderrCloser.Close()
}()
err := c.cmd.Wait()
if _, ok := err.(*os.PathError); ok {
return nil
}
// When a repository does not exist, the command exits with code 128.
if _, ok := err.(*exec.ExitError); ok {
return nil
}
return err
} | go | func (c *command) Close() error {
if c.closed {
return nil
}
defer func() {
c.closed = true
_ = c.stderrCloser.Close()
}()
err := c.cmd.Wait()
if _, ok := err.(*os.PathError); ok {
return nil
}
// When a repository does not exist, the command exits with code 128.
if _, ok := err.(*exec.ExitError); ok {
return nil
}
return err
} | [
"func",
"(",
"c",
"*",
"command",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"c",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"c",
".",
"closed",
"=",
"true",
"\n",
"_",
"=",
"c",
".",
"stderrCloser"... | // Close waits for the command to exit. | [
"Close",
"waits",
"for",
"the",
"command",
"to",
"exit",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/file/client.go#L134-L156 |
160,934 | src-d/go-git | _examples/progress/main.go | main | func main() {
CheckArgs("<url>", "<directory>")
url := os.Args[1]
directory := os.Args[2]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
_, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
Depth: 1,
// as git does, when you make a clone, pull or some other operations the
// server sends information via the sideband, this information can being
// collected provinding a io.Writer to the CloneOptions options
Progress: os.Stdout,
})
CheckIfError(err)
} | go | func main() {
CheckArgs("<url>", "<directory>")
url := os.Args[1]
directory := os.Args[2]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
_, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
Depth: 1,
// as git does, when you make a clone, pull or some other operations the
// server sends information via the sideband, this information can being
// collected provinding a io.Writer to the CloneOptions options
Progress: os.Stdout,
})
CheckIfError(err)
} | [
"func",
"main",
"(",
")",
"{",
"CheckArgs",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"url",
":=",
"os",
".",
"Args",
"[",
"1",
"]",
"\n",
"directory",
":=",
"os",
".",
"Args",
"[",
"2",
"]",
"\n\n",
"// Clone the given repository to the given direc... | // Example of how to show the progress when you do a basic clone operation. | [
"Example",
"of",
"how",
"to",
"show",
"the",
"progress",
"when",
"you",
"do",
"a",
"basic",
"clone",
"operation",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/_examples/progress/main.go#L11-L30 |
160,935 | src-d/go-git | object_walker.go | walkObjectTree | func (p *objectWalker) walkObjectTree(hash plumbing.Hash) error {
// Check if we have already seen, and mark this object
if p.isSeen(hash) {
return nil
}
p.add(hash)
// Fetch the object.
obj, err := object.GetObject(p.Storer, hash)
if err != nil {
return fmt.Errorf("Getting object %s failed: %v", hash, err)
}
// Walk all children depending on object type.
switch obj := obj.(type) {
case *object.Commit:
err = p.walkObjectTree(obj.TreeHash)
if err != nil {
return err
}
for _, h := range obj.ParentHashes {
err = p.walkObjectTree(h)
if err != nil {
return err
}
}
case *object.Tree:
for i := range obj.Entries {
// Shortcut for blob objects:
// 'or' the lower bits of a mode and check that it
// it matches a filemode.Executable. The type information
// is in the higher bits, but this is the cleanest way
// to handle plain files with different modes.
// Other non-tree objects are somewhat rare, so they
// are not special-cased.
if obj.Entries[i].Mode|0755 == filemode.Executable {
p.add(obj.Entries[i].Hash)
continue
}
// Normal walk for sub-trees (and symlinks etc).
err = p.walkObjectTree(obj.Entries[i].Hash)
if err != nil {
return err
}
}
case *object.Tag:
return p.walkObjectTree(obj.Target)
default:
// Error out on unhandled object types.
return fmt.Errorf("Unknown object %X %s %T\n", obj.ID(), obj.Type(), obj)
}
return nil
} | go | func (p *objectWalker) walkObjectTree(hash plumbing.Hash) error {
// Check if we have already seen, and mark this object
if p.isSeen(hash) {
return nil
}
p.add(hash)
// Fetch the object.
obj, err := object.GetObject(p.Storer, hash)
if err != nil {
return fmt.Errorf("Getting object %s failed: %v", hash, err)
}
// Walk all children depending on object type.
switch obj := obj.(type) {
case *object.Commit:
err = p.walkObjectTree(obj.TreeHash)
if err != nil {
return err
}
for _, h := range obj.ParentHashes {
err = p.walkObjectTree(h)
if err != nil {
return err
}
}
case *object.Tree:
for i := range obj.Entries {
// Shortcut for blob objects:
// 'or' the lower bits of a mode and check that it
// it matches a filemode.Executable. The type information
// is in the higher bits, but this is the cleanest way
// to handle plain files with different modes.
// Other non-tree objects are somewhat rare, so they
// are not special-cased.
if obj.Entries[i].Mode|0755 == filemode.Executable {
p.add(obj.Entries[i].Hash)
continue
}
// Normal walk for sub-trees (and symlinks etc).
err = p.walkObjectTree(obj.Entries[i].Hash)
if err != nil {
return err
}
}
case *object.Tag:
return p.walkObjectTree(obj.Target)
default:
// Error out on unhandled object types.
return fmt.Errorf("Unknown object %X %s %T\n", obj.ID(), obj.Type(), obj)
}
return nil
} | [
"func",
"(",
"p",
"*",
"objectWalker",
")",
"walkObjectTree",
"(",
"hash",
"plumbing",
".",
"Hash",
")",
"error",
"{",
"// Check if we have already seen, and mark this object",
"if",
"p",
".",
"isSeen",
"(",
"hash",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
... | // walkObjectTree walks over all objects and remembers references
// to them in the objectWalker. This is used instead of the revlist
// walks because memory usage is tight with huge repos. | [
"walkObjectTree",
"walks",
"over",
"all",
"objects",
"and",
"remembers",
"references",
"to",
"them",
"in",
"the",
"objectWalker",
".",
"This",
"is",
"used",
"instead",
"of",
"the",
"revlist",
"walks",
"because",
"memory",
"usage",
"is",
"tight",
"with",
"huge"... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/object_walker.go#L54-L104 |
160,936 | src-d/go-git | plumbing/object.go | ParseObjectType | func ParseObjectType(value string) (typ ObjectType, err error) {
switch value {
case "commit":
typ = CommitObject
case "tree":
typ = TreeObject
case "blob":
typ = BlobObject
case "tag":
typ = TagObject
case "ofs-delta":
typ = OFSDeltaObject
case "ref-delta":
typ = REFDeltaObject
default:
err = ErrInvalidType
}
return
} | go | func ParseObjectType(value string) (typ ObjectType, err error) {
switch value {
case "commit":
typ = CommitObject
case "tree":
typ = TreeObject
case "blob":
typ = BlobObject
case "tag":
typ = TagObject
case "ofs-delta":
typ = OFSDeltaObject
case "ref-delta":
typ = REFDeltaObject
default:
err = ErrInvalidType
}
return
} | [
"func",
"ParseObjectType",
"(",
"value",
"string",
")",
"(",
"typ",
"ObjectType",
",",
"err",
"error",
")",
"{",
"switch",
"value",
"{",
"case",
"\"",
"\"",
":",
"typ",
"=",
"CommitObject",
"\n",
"case",
"\"",
"\"",
":",
"typ",
"=",
"TreeObject",
"\n",... | // ParseObjectType parses a string representation of ObjectType. It returns an
// error on parse failure. | [
"ParseObjectType",
"parses",
"a",
"string",
"representation",
"of",
"ObjectType",
".",
"It",
"returns",
"an",
"error",
"on",
"parse",
"failure",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/object.go#L93-L111 |
160,937 | src-d/go-git | plumbing/format/packfile/patch_delta.go | ApplyDelta | func ApplyDelta(target, base plumbing.EncodedObject, delta []byte) error {
r, err := base.Reader()
if err != nil {
return err
}
w, err := target.Writer()
if err != nil {
return err
}
src, err := ioutil.ReadAll(r)
if err != nil {
return err
}
dst, err := PatchDelta(src, delta)
if err != nil {
return err
}
target.SetSize(int64(len(dst)))
_, err = w.Write(dst)
return err
} | go | func ApplyDelta(target, base plumbing.EncodedObject, delta []byte) error {
r, err := base.Reader()
if err != nil {
return err
}
w, err := target.Writer()
if err != nil {
return err
}
src, err := ioutil.ReadAll(r)
if err != nil {
return err
}
dst, err := PatchDelta(src, delta)
if err != nil {
return err
}
target.SetSize(int64(len(dst)))
_, err = w.Write(dst)
return err
} | [
"func",
"ApplyDelta",
"(",
"target",
",",
"base",
"plumbing",
".",
"EncodedObject",
",",
"delta",
"[",
"]",
"byte",
")",
"error",
"{",
"r",
",",
"err",
":=",
"base",
".",
"Reader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n... | // ApplyDelta writes to target the result of applying the modification deltas in delta to base. | [
"ApplyDelta",
"writes",
"to",
"target",
"the",
"result",
"of",
"applying",
"the",
"modification",
"deltas",
"in",
"delta",
"to",
"base",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/patch_delta.go#L18-L43 |
160,938 | src-d/go-git | plumbing/format/packfile/patch_delta.go | decodeLEB128 | func decodeLEB128(input []byte) (uint, []byte) {
var num, sz uint
var b byte
for {
b = input[sz]
num |= (uint(b) & payload) << (sz * 7) // concats 7 bits chunks
sz++
if uint(b)&continuation == 0 || sz == uint(len(input)) {
break
}
}
return num, input[sz:]
} | go | func decodeLEB128(input []byte) (uint, []byte) {
var num, sz uint
var b byte
for {
b = input[sz]
num |= (uint(b) & payload) << (sz * 7) // concats 7 bits chunks
sz++
if uint(b)&continuation == 0 || sz == uint(len(input)) {
break
}
}
return num, input[sz:]
} | [
"func",
"decodeLEB128",
"(",
"input",
"[",
"]",
"byte",
")",
"(",
"uint",
",",
"[",
"]",
"byte",
")",
"{",
"var",
"num",
",",
"sz",
"uint",
"\n",
"var",
"b",
"byte",
"\n",
"for",
"{",
"b",
"=",
"input",
"[",
"sz",
"]",
"\n",
"num",
"|=",
"(",... | // Decodes a number encoded as an unsigned LEB128 at the start of some
// binary data and returns the decoded number and the rest of the
// stream.
//
// This must be called twice on the delta data buffer, first to get the
// expected source buffer size, and again to get the target buffer size. | [
"Decodes",
"a",
"number",
"encoded",
"as",
"an",
"unsigned",
"LEB128",
"at",
"the",
"start",
"of",
"some",
"binary",
"data",
"and",
"returns",
"the",
"decoded",
"number",
"and",
"the",
"rest",
"of",
"the",
"stream",
".",
"This",
"must",
"be",
"called",
"... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/patch_delta.go#L125-L139 |
160,939 | src-d/go-git | plumbing/format/idxfile/writer.go | Index | func (w *Writer) Index() (*MemoryIndex, error) {
w.m.Lock()
defer w.m.Unlock()
if w.index == nil {
return w.createIndex()
}
return w.index, nil
} | go | func (w *Writer) Index() (*MemoryIndex, error) {
w.m.Lock()
defer w.m.Unlock()
if w.index == nil {
return w.createIndex()
}
return w.index, nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Index",
"(",
")",
"(",
"*",
"MemoryIndex",
",",
"error",
")",
"{",
"w",
".",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"w",
".",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"w",
".",
"index",
"==",
"n... | // Index returns a previously created MemoryIndex or creates a new one if
// needed. | [
"Index",
"returns",
"a",
"previously",
"created",
"MemoryIndex",
"or",
"creates",
"a",
"new",
"one",
"if",
"needed",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/idxfile/writer.go#L33-L42 |
160,940 | src-d/go-git | plumbing/format/idxfile/writer.go | Add | func (w *Writer) Add(h plumbing.Hash, pos uint64, crc uint32) {
w.m.Lock()
defer w.m.Unlock()
if w.added == nil {
w.added = make(map[plumbing.Hash]struct{})
}
if _, ok := w.added[h]; !ok {
w.added[h] = struct{}{}
w.objects = append(w.objects, Entry{h, crc, pos})
}
} | go | func (w *Writer) Add(h plumbing.Hash, pos uint64, crc uint32) {
w.m.Lock()
defer w.m.Unlock()
if w.added == nil {
w.added = make(map[plumbing.Hash]struct{})
}
if _, ok := w.added[h]; !ok {
w.added[h] = struct{}{}
w.objects = append(w.objects, Entry{h, crc, pos})
}
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Add",
"(",
"h",
"plumbing",
".",
"Hash",
",",
"pos",
"uint64",
",",
"crc",
"uint32",
")",
"{",
"w",
".",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"w",
".",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
... | // Add appends new object data. | [
"Add",
"appends",
"new",
"object",
"data",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/idxfile/writer.go#L45-L58 |
160,941 | src-d/go-git | plumbing/format/idxfile/writer.go | OnHeader | func (w *Writer) OnHeader(count uint32) error {
w.count = count
w.objects = make(objects, 0, count)
return nil
} | go | func (w *Writer) OnHeader(count uint32) error {
w.count = count
w.objects = make(objects, 0, count)
return nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"OnHeader",
"(",
"count",
"uint32",
")",
"error",
"{",
"w",
".",
"count",
"=",
"count",
"\n",
"w",
".",
"objects",
"=",
"make",
"(",
"objects",
",",
"0",
",",
"count",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // OnHeader implements packfile.Observer interface. | [
"OnHeader",
"implements",
"packfile",
".",
"Observer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/idxfile/writer.go#L65-L69 |
160,942 | src-d/go-git | plumbing/format/idxfile/writer.go | OnInflatedObjectHeader | func (w *Writer) OnInflatedObjectHeader(t plumbing.ObjectType, objSize int64, pos int64) error {
return nil
} | go | func (w *Writer) OnInflatedObjectHeader(t plumbing.ObjectType, objSize int64, pos int64) error {
return nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"OnInflatedObjectHeader",
"(",
"t",
"plumbing",
".",
"ObjectType",
",",
"objSize",
"int64",
",",
"pos",
"int64",
")",
"error",
"{",
"return",
"nil",
"\n",
"}"
] | // OnInflatedObjectHeader implements packfile.Observer interface. | [
"OnInflatedObjectHeader",
"implements",
"packfile",
".",
"Observer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/idxfile/writer.go#L72-L74 |
160,943 | src-d/go-git | plumbing/format/idxfile/writer.go | OnInflatedObjectContent | func (w *Writer) OnInflatedObjectContent(h plumbing.Hash, pos int64, crc uint32, _ []byte) error {
w.Add(h, uint64(pos), crc)
return nil
} | go | func (w *Writer) OnInflatedObjectContent(h plumbing.Hash, pos int64, crc uint32, _ []byte) error {
w.Add(h, uint64(pos), crc)
return nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"OnInflatedObjectContent",
"(",
"h",
"plumbing",
".",
"Hash",
",",
"pos",
"int64",
",",
"crc",
"uint32",
",",
"_",
"[",
"]",
"byte",
")",
"error",
"{",
"w",
".",
"Add",
"(",
"h",
",",
"uint64",
"(",
"pos",
")... | // OnInflatedObjectContent implements packfile.Observer interface. | [
"OnInflatedObjectContent",
"implements",
"packfile",
".",
"Observer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/idxfile/writer.go#L77-L80 |
160,944 | src-d/go-git | plumbing/format/idxfile/writer.go | OnFooter | func (w *Writer) OnFooter(h plumbing.Hash) error {
w.checksum = h
w.finished = true
_, err := w.createIndex()
if err != nil {
return err
}
return nil
} | go | func (w *Writer) OnFooter(h plumbing.Hash) error {
w.checksum = h
w.finished = true
_, err := w.createIndex()
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"OnFooter",
"(",
"h",
"plumbing",
".",
"Hash",
")",
"error",
"{",
"w",
".",
"checksum",
"=",
"h",
"\n",
"w",
".",
"finished",
"=",
"true",
"\n",
"_",
",",
"err",
":=",
"w",
".",
"createIndex",
"(",
")",
"\n... | // OnFooter implements packfile.Observer interface. | [
"OnFooter",
"implements",
"packfile",
".",
"Observer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/idxfile/writer.go#L83-L92 |
160,945 | src-d/go-git | plumbing/format/idxfile/writer.go | createIndex | func (w *Writer) createIndex() (*MemoryIndex, error) {
if !w.finished {
return nil, fmt.Errorf("the index still hasn't finished building")
}
idx := new(MemoryIndex)
w.index = idx
sort.Sort(w.objects)
// unmap all fans by default
for i := range idx.FanoutMapping {
idx.FanoutMapping[i] = noMapping
}
buf := new(bytes.Buffer)
last := -1
bucket := -1
for i, o := range w.objects {
fan := o.Hash[0]
// fill the gaps between fans
for j := last + 1; j < int(fan); j++ {
idx.Fanout[j] = uint32(i)
}
// update the number of objects for this position
idx.Fanout[fan] = uint32(i + 1)
// we move from one bucket to another, update counters and allocate
// memory
if last != int(fan) {
bucket++
idx.FanoutMapping[fan] = bucket
last = int(fan)
idx.Names = append(idx.Names, make([]byte, 0))
idx.Offset32 = append(idx.Offset32, make([]byte, 0))
idx.CRC32 = append(idx.CRC32, make([]byte, 0))
}
idx.Names[bucket] = append(idx.Names[bucket], o.Hash[:]...)
offset := o.Offset
if offset > math.MaxInt32 {
offset = w.addOffset64(offset)
}
buf.Truncate(0)
binary.WriteUint32(buf, uint32(offset))
idx.Offset32[bucket] = append(idx.Offset32[bucket], buf.Bytes()...)
buf.Truncate(0)
binary.WriteUint32(buf, uint32(o.CRC32))
idx.CRC32[bucket] = append(idx.CRC32[bucket], buf.Bytes()...)
}
for j := last + 1; j < 256; j++ {
idx.Fanout[j] = uint32(len(w.objects))
}
idx.Version = VersionSupported
idx.PackfileChecksum = w.checksum
return idx, nil
} | go | func (w *Writer) createIndex() (*MemoryIndex, error) {
if !w.finished {
return nil, fmt.Errorf("the index still hasn't finished building")
}
idx := new(MemoryIndex)
w.index = idx
sort.Sort(w.objects)
// unmap all fans by default
for i := range idx.FanoutMapping {
idx.FanoutMapping[i] = noMapping
}
buf := new(bytes.Buffer)
last := -1
bucket := -1
for i, o := range w.objects {
fan := o.Hash[0]
// fill the gaps between fans
for j := last + 1; j < int(fan); j++ {
idx.Fanout[j] = uint32(i)
}
// update the number of objects for this position
idx.Fanout[fan] = uint32(i + 1)
// we move from one bucket to another, update counters and allocate
// memory
if last != int(fan) {
bucket++
idx.FanoutMapping[fan] = bucket
last = int(fan)
idx.Names = append(idx.Names, make([]byte, 0))
idx.Offset32 = append(idx.Offset32, make([]byte, 0))
idx.CRC32 = append(idx.CRC32, make([]byte, 0))
}
idx.Names[bucket] = append(idx.Names[bucket], o.Hash[:]...)
offset := o.Offset
if offset > math.MaxInt32 {
offset = w.addOffset64(offset)
}
buf.Truncate(0)
binary.WriteUint32(buf, uint32(offset))
idx.Offset32[bucket] = append(idx.Offset32[bucket], buf.Bytes()...)
buf.Truncate(0)
binary.WriteUint32(buf, uint32(o.CRC32))
idx.CRC32[bucket] = append(idx.CRC32[bucket], buf.Bytes()...)
}
for j := last + 1; j < 256; j++ {
idx.Fanout[j] = uint32(len(w.objects))
}
idx.Version = VersionSupported
idx.PackfileChecksum = w.checksum
return idx, nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"createIndex",
"(",
")",
"(",
"*",
"MemoryIndex",
",",
"error",
")",
"{",
"if",
"!",
"w",
".",
"finished",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"idx",
":... | // creatIndex returns a filled MemoryIndex with the information filled by
// the observer callbacks. | [
"creatIndex",
"returns",
"a",
"filled",
"MemoryIndex",
"with",
"the",
"information",
"filled",
"by",
"the",
"observer",
"callbacks",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/idxfile/writer.go#L96-L162 |
160,946 | src-d/go-git | plumbing/format/config/section.go | IsName | func (s *Section) IsName(name string) bool {
return strings.ToLower(s.Name) == strings.ToLower(name)
} | go | func (s *Section) IsName(name string) bool {
return strings.ToLower(s.Name) == strings.ToLower(name)
} | [
"func",
"(",
"s",
"*",
"Section",
")",
"IsName",
"(",
"name",
"string",
")",
"bool",
"{",
"return",
"strings",
".",
"ToLower",
"(",
"s",
".",
"Name",
")",
"==",
"strings",
".",
"ToLower",
"(",
"name",
")",
"\n",
"}"
] | // IsName checks if the name provided is equals to the Section name, case insensitive. | [
"IsName",
"checks",
"if",
"the",
"name",
"provided",
"is",
"equals",
"to",
"the",
"Section",
"name",
"case",
"insensitive",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L63-L65 |
160,947 | src-d/go-git | plumbing/format/config/section.go | Option | func (s *Section) Option(key string) string {
return s.Options.Get(key)
} | go | func (s *Section) Option(key string) string {
return s.Options.Get(key)
} | [
"func",
"(",
"s",
"*",
"Section",
")",
"Option",
"(",
"key",
"string",
")",
"string",
"{",
"return",
"s",
".",
"Options",
".",
"Get",
"(",
"key",
")",
"\n",
"}"
] | // Option return the value for the specified key. Empty string is returned if
// key does not exists. | [
"Option",
"return",
"the",
"value",
"for",
"the",
"specified",
"key",
".",
"Empty",
"string",
"is",
"returned",
"if",
"key",
"does",
"not",
"exists",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L69-L71 |
160,948 | src-d/go-git | plumbing/format/config/section.go | AddOption | func (s *Section) AddOption(key string, value string) *Section {
s.Options = s.Options.withAddedOption(key, value)
return s
} | go | func (s *Section) AddOption(key string, value string) *Section {
s.Options = s.Options.withAddedOption(key, value)
return s
} | [
"func",
"(",
"s",
"*",
"Section",
")",
"AddOption",
"(",
"key",
"string",
",",
"value",
"string",
")",
"*",
"Section",
"{",
"s",
".",
"Options",
"=",
"s",
".",
"Options",
".",
"withAddedOption",
"(",
"key",
",",
"value",
")",
"\n",
"return",
"s",
"... | // AddOption adds a new Option to the Section. The updated Section is returned. | [
"AddOption",
"adds",
"a",
"new",
"Option",
"to",
"the",
"Section",
".",
"The",
"updated",
"Section",
"is",
"returned",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L74-L77 |
160,949 | src-d/go-git | plumbing/format/config/section.go | SetOption | func (s *Section) SetOption(key string, value string) *Section {
s.Options = s.Options.withSettedOption(key, value)
return s
} | go | func (s *Section) SetOption(key string, value string) *Section {
s.Options = s.Options.withSettedOption(key, value)
return s
} | [
"func",
"(",
"s",
"*",
"Section",
")",
"SetOption",
"(",
"key",
"string",
",",
"value",
"string",
")",
"*",
"Section",
"{",
"s",
".",
"Options",
"=",
"s",
".",
"Options",
".",
"withSettedOption",
"(",
"key",
",",
"value",
")",
"\n",
"return",
"s",
... | // SetOption adds a new Option to the Section. If the option already exists, is replaced.
// The updated Section is returned. | [
"SetOption",
"adds",
"a",
"new",
"Option",
"to",
"the",
"Section",
".",
"If",
"the",
"option",
"already",
"exists",
"is",
"replaced",
".",
"The",
"updated",
"Section",
"is",
"returned",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L81-L84 |
160,950 | src-d/go-git | plumbing/format/config/section.go | RemoveOption | func (s *Section) RemoveOption(key string) *Section {
s.Options = s.Options.withoutOption(key)
return s
} | go | func (s *Section) RemoveOption(key string) *Section {
s.Options = s.Options.withoutOption(key)
return s
} | [
"func",
"(",
"s",
"*",
"Section",
")",
"RemoveOption",
"(",
"key",
"string",
")",
"*",
"Section",
"{",
"s",
".",
"Options",
"=",
"s",
".",
"Options",
".",
"withoutOption",
"(",
"key",
")",
"\n",
"return",
"s",
"\n",
"}"
] | // Remove an option with the specified key. The updated Section is returned. | [
"Remove",
"an",
"option",
"with",
"the",
"specified",
"key",
".",
"The",
"updated",
"Section",
"is",
"returned",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L87-L90 |
160,951 | src-d/go-git | plumbing/format/config/section.go | Subsection | func (s *Section) Subsection(name string) *Subsection {
for i := len(s.Subsections) - 1; i >= 0; i-- {
ss := s.Subsections[i]
if ss.IsName(name) {
return ss
}
}
ss := &Subsection{Name: name}
s.Subsections = append(s.Subsections, ss)
return ss
} | go | func (s *Section) Subsection(name string) *Subsection {
for i := len(s.Subsections) - 1; i >= 0; i-- {
ss := s.Subsections[i]
if ss.IsName(name) {
return ss
}
}
ss := &Subsection{Name: name}
s.Subsections = append(s.Subsections, ss)
return ss
} | [
"func",
"(",
"s",
"*",
"Section",
")",
"Subsection",
"(",
"name",
"string",
")",
"*",
"Subsection",
"{",
"for",
"i",
":=",
"len",
"(",
"s",
".",
"Subsections",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"ss",
":=",
"s",
".",
"Su... | // Subsection returns a Subsection from the specified Section. If the
// Subsection does not exists, new one is created and added to Section. | [
"Subsection",
"returns",
"a",
"Subsection",
"from",
"the",
"specified",
"Section",
".",
"If",
"the",
"Subsection",
"does",
"not",
"exists",
"new",
"one",
"is",
"created",
"and",
"added",
"to",
"Section",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L94-L105 |
160,952 | src-d/go-git | plumbing/format/config/section.go | HasSubsection | func (s *Section) HasSubsection(name string) bool {
for _, ss := range s.Subsections {
if ss.IsName(name) {
return true
}
}
return false
} | go | func (s *Section) HasSubsection(name string) bool {
for _, ss := range s.Subsections {
if ss.IsName(name) {
return true
}
}
return false
} | [
"func",
"(",
"s",
"*",
"Section",
")",
"HasSubsection",
"(",
"name",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"ss",
":=",
"range",
"s",
".",
"Subsections",
"{",
"if",
"ss",
".",
"IsName",
"(",
"name",
")",
"{",
"return",
"true",
"\n",
"}",
"\... | // HasSubsection checks if the Section has a Subsection with the specified name. | [
"HasSubsection",
"checks",
"if",
"the",
"Section",
"has",
"a",
"Subsection",
"with",
"the",
"specified",
"name",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L108-L116 |
160,953 | src-d/go-git | plumbing/format/config/section.go | Option | func (s *Subsection) Option(key string) string {
return s.Options.Get(key)
} | go | func (s *Subsection) Option(key string) string {
return s.Options.Get(key)
} | [
"func",
"(",
"s",
"*",
"Subsection",
")",
"Option",
"(",
"key",
"string",
")",
"string",
"{",
"return",
"s",
".",
"Options",
".",
"Get",
"(",
"key",
")",
"\n",
"}"
] | // Option returns an option with the specified key. If the option does not exists,
// empty spring will be returned. | [
"Option",
"returns",
"an",
"option",
"with",
"the",
"specified",
"key",
".",
"If",
"the",
"option",
"does",
"not",
"exists",
"empty",
"spring",
"will",
"be",
"returned",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L125-L127 |
160,954 | src-d/go-git | plumbing/format/config/section.go | AddOption | func (s *Subsection) AddOption(key string, value string) *Subsection {
s.Options = s.Options.withAddedOption(key, value)
return s
} | go | func (s *Subsection) AddOption(key string, value string) *Subsection {
s.Options = s.Options.withAddedOption(key, value)
return s
} | [
"func",
"(",
"s",
"*",
"Subsection",
")",
"AddOption",
"(",
"key",
"string",
",",
"value",
"string",
")",
"*",
"Subsection",
"{",
"s",
".",
"Options",
"=",
"s",
".",
"Options",
".",
"withAddedOption",
"(",
"key",
",",
"value",
")",
"\n",
"return",
"s... | // AddOption adds a new Option to the Subsection. The updated Subsection is returned. | [
"AddOption",
"adds",
"a",
"new",
"Option",
"to",
"the",
"Subsection",
".",
"The",
"updated",
"Subsection",
"is",
"returned",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L130-L133 |
160,955 | src-d/go-git | plumbing/format/config/section.go | SetOption | func (s *Subsection) SetOption(key string, value ...string) *Subsection {
s.Options = s.Options.withSettedOption(key, value...)
return s
} | go | func (s *Subsection) SetOption(key string, value ...string) *Subsection {
s.Options = s.Options.withSettedOption(key, value...)
return s
} | [
"func",
"(",
"s",
"*",
"Subsection",
")",
"SetOption",
"(",
"key",
"string",
",",
"value",
"...",
"string",
")",
"*",
"Subsection",
"{",
"s",
".",
"Options",
"=",
"s",
".",
"Options",
".",
"withSettedOption",
"(",
"key",
",",
"value",
"...",
")",
"\n... | // SetOption adds a new Option to the Subsection. If the option already exists, is replaced.
// The updated Subsection is returned. | [
"SetOption",
"adds",
"a",
"new",
"Option",
"to",
"the",
"Subsection",
".",
"If",
"the",
"option",
"already",
"exists",
"is",
"replaced",
".",
"The",
"updated",
"Subsection",
"is",
"returned",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L137-L140 |
160,956 | src-d/go-git | plumbing/format/config/section.go | RemoveOption | func (s *Subsection) RemoveOption(key string) *Subsection {
s.Options = s.Options.withoutOption(key)
return s
} | go | func (s *Subsection) RemoveOption(key string) *Subsection {
s.Options = s.Options.withoutOption(key)
return s
} | [
"func",
"(",
"s",
"*",
"Subsection",
")",
"RemoveOption",
"(",
"key",
"string",
")",
"*",
"Subsection",
"{",
"s",
".",
"Options",
"=",
"s",
".",
"Options",
".",
"withoutOption",
"(",
"key",
")",
"\n",
"return",
"s",
"\n",
"}"
] | // RemoveOption removes the option with the specified key. The updated Subsection is returned. | [
"RemoveOption",
"removes",
"the",
"option",
"with",
"the",
"specified",
"key",
".",
"The",
"updated",
"Subsection",
"is",
"returned",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/config/section.go#L143-L146 |
160,957 | src-d/go-git | plumbing/format/index/index.go | Add | func (i *Index) Add(path string) *Entry {
e := &Entry{
Name: filepath.ToSlash(path),
}
i.Entries = append(i.Entries, e)
return e
} | go | func (i *Index) Add(path string) *Entry {
e := &Entry{
Name: filepath.ToSlash(path),
}
i.Entries = append(i.Entries, e)
return e
} | [
"func",
"(",
"i",
"*",
"Index",
")",
"Add",
"(",
"path",
"string",
")",
"*",
"Entry",
"{",
"e",
":=",
"&",
"Entry",
"{",
"Name",
":",
"filepath",
".",
"ToSlash",
"(",
"path",
")",
",",
"}",
"\n\n",
"i",
".",
"Entries",
"=",
"append",
"(",
"i",
... | // Add creates a new Entry and returns it. The caller should first check that
// another entry with the same path does not exist. | [
"Add",
"creates",
"a",
"new",
"Entry",
"and",
"returns",
"it",
".",
"The",
"caller",
"should",
"first",
"check",
"that",
"another",
"entry",
"with",
"the",
"same",
"path",
"does",
"not",
"exist",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/index/index.go#L60-L67 |
160,958 | src-d/go-git | plumbing/format/index/index.go | Entry | func (i *Index) Entry(path string) (*Entry, error) {
path = filepath.ToSlash(path)
for _, e := range i.Entries {
if e.Name == path {
return e, nil
}
}
return nil, ErrEntryNotFound
} | go | func (i *Index) Entry(path string) (*Entry, error) {
path = filepath.ToSlash(path)
for _, e := range i.Entries {
if e.Name == path {
return e, nil
}
}
return nil, ErrEntryNotFound
} | [
"func",
"(",
"i",
"*",
"Index",
")",
"Entry",
"(",
"path",
"string",
")",
"(",
"*",
"Entry",
",",
"error",
")",
"{",
"path",
"=",
"filepath",
".",
"ToSlash",
"(",
"path",
")",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"i",
".",
"Entries",
"{",... | // Entry returns the entry that match the given path, if any. | [
"Entry",
"returns",
"the",
"entry",
"that",
"match",
"the",
"given",
"path",
"if",
"any",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/index/index.go#L70-L79 |
160,959 | src-d/go-git | plumbing/format/index/index.go | Remove | func (i *Index) Remove(path string) (*Entry, error) {
path = filepath.ToSlash(path)
for index, e := range i.Entries {
if e.Name == path {
i.Entries = append(i.Entries[:index], i.Entries[index+1:]...)
return e, nil
}
}
return nil, ErrEntryNotFound
} | go | func (i *Index) Remove(path string) (*Entry, error) {
path = filepath.ToSlash(path)
for index, e := range i.Entries {
if e.Name == path {
i.Entries = append(i.Entries[:index], i.Entries[index+1:]...)
return e, nil
}
}
return nil, ErrEntryNotFound
} | [
"func",
"(",
"i",
"*",
"Index",
")",
"Remove",
"(",
"path",
"string",
")",
"(",
"*",
"Entry",
",",
"error",
")",
"{",
"path",
"=",
"filepath",
".",
"ToSlash",
"(",
"path",
")",
"\n",
"for",
"index",
",",
"e",
":=",
"range",
"i",
".",
"Entries",
... | // Remove remove the entry that match the give path and returns deleted entry. | [
"Remove",
"remove",
"the",
"entry",
"that",
"match",
"the",
"give",
"path",
"and",
"returns",
"deleted",
"entry",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/index/index.go#L82-L92 |
160,960 | src-d/go-git | plumbing/format/index/index.go | Glob | func (i *Index) Glob(pattern string) (matches []*Entry, err error) {
pattern = filepath.ToSlash(pattern)
for _, e := range i.Entries {
m, err := match(pattern, e.Name)
if err != nil {
return nil, err
}
if m {
matches = append(matches, e)
}
}
return
} | go | func (i *Index) Glob(pattern string) (matches []*Entry, err error) {
pattern = filepath.ToSlash(pattern)
for _, e := range i.Entries {
m, err := match(pattern, e.Name)
if err != nil {
return nil, err
}
if m {
matches = append(matches, e)
}
}
return
} | [
"func",
"(",
"i",
"*",
"Index",
")",
"Glob",
"(",
"pattern",
"string",
")",
"(",
"matches",
"[",
"]",
"*",
"Entry",
",",
"err",
"error",
")",
"{",
"pattern",
"=",
"filepath",
".",
"ToSlash",
"(",
"pattern",
")",
"\n",
"for",
"_",
",",
"e",
":=",
... | // Glob returns the all entries matching pattern or nil if there is no matching
// entry. The syntax of patterns is the same as in filepath.Glob. | [
"Glob",
"returns",
"the",
"all",
"entries",
"matching",
"pattern",
"or",
"nil",
"if",
"there",
"is",
"no",
"matching",
"entry",
".",
"The",
"syntax",
"of",
"patterns",
"is",
"the",
"same",
"as",
"in",
"filepath",
".",
"Glob",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/index/index.go#L96-L110 |
160,961 | src-d/go-git | utils/merkletrie/iter.go | current | func (iter *Iter) current() (noder.Path, error) {
if topFrame, ok := iter.top(); !ok {
return nil, io.EOF
} else if _, ok := topFrame.First(); !ok {
return nil, io.EOF
}
ret := make(noder.Path, 0, len(iter.base)+len(iter.frameStack))
// concat the base...
ret = append(ret, iter.base...)
// ... and the current node and all its ancestors
for i, f := range iter.frameStack {
t, ok := f.First()
if !ok {
panic(fmt.Sprintf("frame %d is empty", i))
}
ret = append(ret, t)
}
return ret, nil
} | go | func (iter *Iter) current() (noder.Path, error) {
if topFrame, ok := iter.top(); !ok {
return nil, io.EOF
} else if _, ok := topFrame.First(); !ok {
return nil, io.EOF
}
ret := make(noder.Path, 0, len(iter.base)+len(iter.frameStack))
// concat the base...
ret = append(ret, iter.base...)
// ... and the current node and all its ancestors
for i, f := range iter.frameStack {
t, ok := f.First()
if !ok {
panic(fmt.Sprintf("frame %d is empty", i))
}
ret = append(ret, t)
}
return ret, nil
} | [
"func",
"(",
"iter",
"*",
"Iter",
")",
"current",
"(",
")",
"(",
"noder",
".",
"Path",
",",
"error",
")",
"{",
"if",
"topFrame",
",",
"ok",
":=",
"iter",
".",
"top",
"(",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",... | // Returns the path to the current node, adding the base if there was
// one, and a nil error. If there were no noders left, it returns nil
// and io.EOF. If an error occurred, it returns nil and the error. | [
"Returns",
"the",
"path",
"to",
"the",
"current",
"node",
"adding",
"the",
"base",
"if",
"there",
"was",
"one",
"and",
"a",
"nil",
"error",
".",
"If",
"there",
"were",
"no",
"noders",
"left",
"it",
"returns",
"nil",
"and",
"io",
".",
"EOF",
".",
"If"... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/iter.go#L177-L198 |
160,962 | src-d/go-git | utils/merkletrie/iter.go | drop | func (iter *Iter) drop() {
frame, ok := iter.top()
if !ok {
return
}
frame.Drop()
// if the frame is empty, remove it and its parent, recursively
if frame.Len() == 0 {
top := len(iter.frameStack) - 1
iter.frameStack[top] = nil
iter.frameStack = iter.frameStack[:top]
iter.drop()
}
} | go | func (iter *Iter) drop() {
frame, ok := iter.top()
if !ok {
return
}
frame.Drop()
// if the frame is empty, remove it and its parent, recursively
if frame.Len() == 0 {
top := len(iter.frameStack) - 1
iter.frameStack[top] = nil
iter.frameStack = iter.frameStack[:top]
iter.drop()
}
} | [
"func",
"(",
"iter",
"*",
"Iter",
")",
"drop",
"(",
")",
"{",
"frame",
",",
"ok",
":=",
"iter",
".",
"top",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n\n",
"frame",
".",
"Drop",
"(",
")",
"\n",
"// if the frame is empty, remove i... | // removes the current node if any, and all the frames that become empty as a
// consequence of this action. | [
"removes",
"the",
"current",
"node",
"if",
"any",
"and",
"all",
"the",
"frames",
"that",
"become",
"empty",
"as",
"a",
"consequence",
"of",
"this",
"action",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/iter.go#L202-L216 |
160,963 | src-d/go-git | storage/transactional/index.go | NewIndexStorage | func NewIndexStorage(s, temporal storer.IndexStorer) *IndexStorage {
return &IndexStorage{
IndexStorer: s,
temporal: temporal,
}
} | go | func NewIndexStorage(s, temporal storer.IndexStorer) *IndexStorage {
return &IndexStorage{
IndexStorer: s,
temporal: temporal,
}
} | [
"func",
"NewIndexStorage",
"(",
"s",
",",
"temporal",
"storer",
".",
"IndexStorer",
")",
"*",
"IndexStorage",
"{",
"return",
"&",
"IndexStorage",
"{",
"IndexStorer",
":",
"s",
",",
"temporal",
":",
"temporal",
",",
"}",
"\n",
"}"
] | // NewIndexStorage returns a new IndexStorer based on a base storer and a
// temporal storer. | [
"NewIndexStorage",
"returns",
"a",
"new",
"IndexStorer",
"based",
"on",
"a",
"base",
"storer",
"and",
"a",
"temporal",
"storer",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/index.go#L18-L23 |
160,964 | src-d/go-git | storage/transactional/index.go | SetIndex | func (s *IndexStorage) SetIndex(idx *index.Index) (err error) {
if err := s.temporal.SetIndex(idx); err != nil {
return err
}
s.set = true
return nil
} | go | func (s *IndexStorage) SetIndex(idx *index.Index) (err error) {
if err := s.temporal.SetIndex(idx); err != nil {
return err
}
s.set = true
return nil
} | [
"func",
"(",
"s",
"*",
"IndexStorage",
")",
"SetIndex",
"(",
"idx",
"*",
"index",
".",
"Index",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"s",
".",
"temporal",
".",
"SetIndex",
"(",
"idx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",... | // SetIndex honors the storer.IndexStorer interface. | [
"SetIndex",
"honors",
"the",
"storer",
".",
"IndexStorer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/index.go#L26-L33 |
160,965 | src-d/go-git | storage/transactional/index.go | Index | func (s *IndexStorage) Index() (*index.Index, error) {
if !s.set {
return s.IndexStorer.Index()
}
return s.temporal.Index()
} | go | func (s *IndexStorage) Index() (*index.Index, error) {
if !s.set {
return s.IndexStorer.Index()
}
return s.temporal.Index()
} | [
"func",
"(",
"s",
"*",
"IndexStorage",
")",
"Index",
"(",
")",
"(",
"*",
"index",
".",
"Index",
",",
"error",
")",
"{",
"if",
"!",
"s",
".",
"set",
"{",
"return",
"s",
".",
"IndexStorer",
".",
"Index",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"s"... | // Index honors the storer.IndexStorer interface. | [
"Index",
"honors",
"the",
"storer",
".",
"IndexStorer",
"interface",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/index.go#L36-L42 |
160,966 | src-d/go-git | storage/transactional/index.go | Commit | func (s *IndexStorage) Commit() error {
if !s.set {
return nil
}
idx, err := s.temporal.Index()
if err != nil {
return err
}
return s.IndexStorer.SetIndex(idx)
} | go | func (s *IndexStorage) Commit() error {
if !s.set {
return nil
}
idx, err := s.temporal.Index()
if err != nil {
return err
}
return s.IndexStorer.SetIndex(idx)
} | [
"func",
"(",
"s",
"*",
"IndexStorage",
")",
"Commit",
"(",
")",
"error",
"{",
"if",
"!",
"s",
".",
"set",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"idx",
",",
"err",
":=",
"s",
".",
"temporal",
".",
"Index",
"(",
")",
"\n",
"if",
"err",
"!=",
... | // Commit it copies the index from the temporal storage into the base storage. | [
"Commit",
"it",
"copies",
"the",
"index",
"from",
"the",
"temporal",
"storage",
"into",
"the",
"base",
"storage",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/transactional/index.go#L45-L56 |
160,967 | src-d/go-git | plumbing/transport/ssh/common.go | Close | func (c *command) Close() error {
if !c.connected {
return nil
}
c.connected = false
//XXX: If did read the full packfile, then the session might be already
// closed.
_ = c.Session.Close()
return c.client.Close()
} | go | func (c *command) Close() error {
if !c.connected {
return nil
}
c.connected = false
//XXX: If did read the full packfile, then the session might be already
// closed.
_ = c.Session.Close()
return c.client.Close()
} | [
"func",
"(",
"c",
"*",
"command",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"!",
"c",
".",
"connected",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"c",
".",
"connected",
"=",
"false",
"\n\n",
"//XXX: If did read the full packfile, then the session might be alr... | // Close closes the SSH session and connection. | [
"Close",
"closes",
"the",
"SSH",
"session",
"and",
"connection",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/ssh/common.go#L83-L95 |
160,968 | src-d/go-git | plumbing/transport/ssh/common.go | connect | func (c *command) connect() error {
if c.connected {
return transport.ErrAlreadyConnected
}
if c.auth == nil {
if err := c.setAuthFromEndpoint(); err != nil {
return err
}
}
var err error
config, err := c.auth.ClientConfig()
if err != nil {
return err
}
overrideConfig(c.config, config)
c.client, err = dial("tcp", c.getHostWithPort(), config)
if err != nil {
return err
}
c.Session, err = c.client.NewSession()
if err != nil {
_ = c.client.Close()
return err
}
c.connected = true
return nil
} | go | func (c *command) connect() error {
if c.connected {
return transport.ErrAlreadyConnected
}
if c.auth == nil {
if err := c.setAuthFromEndpoint(); err != nil {
return err
}
}
var err error
config, err := c.auth.ClientConfig()
if err != nil {
return err
}
overrideConfig(c.config, config)
c.client, err = dial("tcp", c.getHostWithPort(), config)
if err != nil {
return err
}
c.Session, err = c.client.NewSession()
if err != nil {
_ = c.client.Close()
return err
}
c.connected = true
return nil
} | [
"func",
"(",
"c",
"*",
"command",
")",
"connect",
"(",
")",
"error",
"{",
"if",
"c",
".",
"connected",
"{",
"return",
"transport",
".",
"ErrAlreadyConnected",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"auth",
"==",
"nil",
"{",
"if",
"err",
":=",
"c",
".",... | // connect connects to the SSH server, unless a AuthMethod was set with
// SetAuth method, by default uses an auth method based on PublicKeysCallback,
// it connects to a SSH agent, using the address stored in the SSH_AUTH_SOCK
// environment var. | [
"connect",
"connects",
"to",
"the",
"SSH",
"server",
"unless",
"a",
"AuthMethod",
"was",
"set",
"with",
"SetAuth",
"method",
"by",
"default",
"uses",
"an",
"auth",
"method",
"based",
"on",
"PublicKeysCallback",
"it",
"connects",
"to",
"a",
"SSH",
"agent",
"u... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/transport/ssh/common.go#L101-L133 |
160,969 | src-d/go-git | utils/merkletrie/index/node.go | NewRootNode | func NewRootNode(idx *index.Index) noder.Noder {
const rootNode = ""
m := map[string]*node{rootNode: {isDir: true}}
for _, e := range idx.Entries {
parts := strings.Split(e.Name, string("/"))
var fullpath string
for _, part := range parts {
parent := fullpath
fullpath = path.Join(fullpath, part)
if _, ok := m[fullpath]; ok {
continue
}
n := &node{path: fullpath}
if fullpath == e.Name {
n.entry = e
} else {
n.isDir = true
}
m[n.path] = n
m[parent].children = append(m[parent].children, n)
}
}
return m[rootNode]
} | go | func NewRootNode(idx *index.Index) noder.Noder {
const rootNode = ""
m := map[string]*node{rootNode: {isDir: true}}
for _, e := range idx.Entries {
parts := strings.Split(e.Name, string("/"))
var fullpath string
for _, part := range parts {
parent := fullpath
fullpath = path.Join(fullpath, part)
if _, ok := m[fullpath]; ok {
continue
}
n := &node{path: fullpath}
if fullpath == e.Name {
n.entry = e
} else {
n.isDir = true
}
m[n.path] = n
m[parent].children = append(m[parent].children, n)
}
}
return m[rootNode]
} | [
"func",
"NewRootNode",
"(",
"idx",
"*",
"index",
".",
"Index",
")",
"noder",
".",
"Noder",
"{",
"const",
"rootNode",
"=",
"\"",
"\"",
"\n\n",
"m",
":=",
"map",
"[",
"string",
"]",
"*",
"node",
"{",
"rootNode",
":",
"{",
"isDir",
":",
"true",
"}",
... | // NewRootNode returns the root node of a computed tree from a index.Index, | [
"NewRootNode",
"returns",
"the",
"root",
"node",
"of",
"a",
"computed",
"tree",
"from",
"a",
"index",
".",
"Index"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/index/node.go#L25-L55 |
160,970 | src-d/go-git | utils/merkletrie/index/node.go | Hash | func (n *node) Hash() []byte {
if n.entry == nil {
return make([]byte, 24)
}
return append(n.entry.Hash[:], n.entry.Mode.Bytes()...)
} | go | func (n *node) Hash() []byte {
if n.entry == nil {
return make([]byte, 24)
}
return append(n.entry.Hash[:], n.entry.Mode.Bytes()...)
} | [
"func",
"(",
"n",
"*",
"node",
")",
"Hash",
"(",
")",
"[",
"]",
"byte",
"{",
"if",
"n",
".",
"entry",
"==",
"nil",
"{",
"return",
"make",
"(",
"[",
"]",
"byte",
",",
"24",
")",
"\n",
"}",
"\n\n",
"return",
"append",
"(",
"n",
".",
"entry",
... | // Hash the hash of a filesystem is a 24-byte slice, is the result of
// concatenating the computed plumbing.Hash of the file as a Blob and its
// plumbing.FileMode; that way the difftree algorithm will detect changes in the
// contents of files and also in their mode.
//
// If the node is computed and not based on a index.Entry the hash is equals
// to a 24-bytes slices of zero values. | [
"Hash",
"the",
"hash",
"of",
"a",
"filesystem",
"is",
"a",
"24",
"-",
"byte",
"slice",
"is",
"the",
"result",
"of",
"concatenating",
"the",
"computed",
"plumbing",
".",
"Hash",
"of",
"the",
"file",
"as",
"a",
"Blob",
"and",
"its",
"plumbing",
".",
"Fil... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/utils/merkletrie/index/node.go#L68-L74 |
160,971 | src-d/go-git | plumbing/format/packfile/error.go | Error | func (e *Error) Error() string {
if e.details == "" {
return e.reason
}
return fmt.Sprintf("%s: %s", e.reason, e.details)
} | go | func (e *Error) Error() string {
if e.details == "" {
return e.reason
}
return fmt.Sprintf("%s: %s", e.reason, e.details)
} | [
"func",
"(",
"e",
"*",
"Error",
")",
"Error",
"(",
")",
"string",
"{",
"if",
"e",
".",
"details",
"==",
"\"",
"\"",
"{",
"return",
"e",
".",
"reason",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"reason",... | // Error returns a text representation of the error. | [
"Error",
"returns",
"a",
"text",
"representation",
"of",
"the",
"error",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/error.go#L16-L22 |
160,972 | src-d/go-git | plumbing/format/packfile/error.go | AddDetails | func (e *Error) AddDetails(format string, args ...interface{}) *Error {
return &Error{
reason: e.reason,
details: fmt.Sprintf(format, args...),
}
} | go | func (e *Error) AddDetails(format string, args ...interface{}) *Error {
return &Error{
reason: e.reason,
details: fmt.Sprintf(format, args...),
}
} | [
"func",
"(",
"e",
"*",
"Error",
")",
"AddDetails",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Error",
"{",
"return",
"&",
"Error",
"{",
"reason",
":",
"e",
".",
"reason",
",",
"details",
":",
"fmt",
".",
"Sprintf... | // AddDetails adds details to an error, with additional text. | [
"AddDetails",
"adds",
"details",
"to",
"an",
"error",
"with",
"additional",
"text",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/error.go#L25-L30 |
160,973 | src-d/go-git | plumbing/format/packfile/common.go | UpdateObjectStorage | func UpdateObjectStorage(s storer.Storer, packfile io.Reader) error {
if pw, ok := s.(storer.PackfileWriter); ok {
return WritePackfileToObjectStorage(pw, packfile)
}
p, err := NewParserWithStorage(NewScanner(packfile), s)
if err != nil {
return err
}
_, err = p.Parse()
return err
} | go | func UpdateObjectStorage(s storer.Storer, packfile io.Reader) error {
if pw, ok := s.(storer.PackfileWriter); ok {
return WritePackfileToObjectStorage(pw, packfile)
}
p, err := NewParserWithStorage(NewScanner(packfile), s)
if err != nil {
return err
}
_, err = p.Parse()
return err
} | [
"func",
"UpdateObjectStorage",
"(",
"s",
"storer",
".",
"Storer",
",",
"packfile",
"io",
".",
"Reader",
")",
"error",
"{",
"if",
"pw",
",",
"ok",
":=",
"s",
".",
"(",
"storer",
".",
"PackfileWriter",
")",
";",
"ok",
"{",
"return",
"WritePackfileToObjectS... | // UpdateObjectStorage updates the storer with the objects in the given
// packfile. | [
"UpdateObjectStorage",
"updates",
"the",
"storer",
"with",
"the",
"objects",
"in",
"the",
"given",
"packfile",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/common.go#L29-L41 |
160,974 | src-d/go-git | plumbing/format/packfile/common.go | WritePackfileToObjectStorage | func WritePackfileToObjectStorage(
sw storer.PackfileWriter,
packfile io.Reader,
) (err error) {
w, err := sw.PackfileWriter()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
var n int64
n, err = io.Copy(w, packfile)
if err == nil && n == 0 {
return ErrEmptyPackfile
}
return err
} | go | func WritePackfileToObjectStorage(
sw storer.PackfileWriter,
packfile io.Reader,
) (err error) {
w, err := sw.PackfileWriter()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
var n int64
n, err = io.Copy(w, packfile)
if err == nil && n == 0 {
return ErrEmptyPackfile
}
return err
} | [
"func",
"WritePackfileToObjectStorage",
"(",
"sw",
"storer",
".",
"PackfileWriter",
",",
"packfile",
"io",
".",
"Reader",
",",
")",
"(",
"err",
"error",
")",
"{",
"w",
",",
"err",
":=",
"sw",
".",
"PackfileWriter",
"(",
")",
"\n",
"if",
"err",
"!=",
"n... | // WritePackfileToObjectStorage writes all the packfile objects into the given
// object storage. | [
"WritePackfileToObjectStorage",
"writes",
"all",
"the",
"packfile",
"objects",
"into",
"the",
"given",
"object",
"storage",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/common.go#L45-L63 |
160,975 | src-d/go-git | plumbing/format/packfile/object_pack.go | newObjectToPack | func newObjectToPack(o plumbing.EncodedObject) *ObjectToPack {
return &ObjectToPack{
Object: o,
Original: o,
}
} | go | func newObjectToPack(o plumbing.EncodedObject) *ObjectToPack {
return &ObjectToPack{
Object: o,
Original: o,
}
} | [
"func",
"newObjectToPack",
"(",
"o",
"plumbing",
".",
"EncodedObject",
")",
"*",
"ObjectToPack",
"{",
"return",
"&",
"ObjectToPack",
"{",
"Object",
":",
"o",
",",
"Original",
":",
"o",
",",
"}",
"\n",
"}"
] | // newObjectToPack creates a correct ObjectToPack based on a non-delta object | [
"newObjectToPack",
"creates",
"a",
"correct",
"ObjectToPack",
"based",
"on",
"a",
"non",
"-",
"delta",
"object"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/object_pack.go#L35-L40 |
160,976 | src-d/go-git | plumbing/format/packfile/object_pack.go | BackToOriginal | func (o *ObjectToPack) BackToOriginal() {
if o.IsDelta() && o.Original != nil {
o.Object = o.Original
o.Base = nil
o.Depth = 0
}
} | go | func (o *ObjectToPack) BackToOriginal() {
if o.IsDelta() && o.Original != nil {
o.Object = o.Original
o.Base = nil
o.Depth = 0
}
} | [
"func",
"(",
"o",
"*",
"ObjectToPack",
")",
"BackToOriginal",
"(",
")",
"{",
"if",
"o",
".",
"IsDelta",
"(",
")",
"&&",
"o",
".",
"Original",
"!=",
"nil",
"{",
"o",
".",
"Object",
"=",
"o",
".",
"Original",
"\n",
"o",
".",
"Base",
"=",
"nil",
"... | // BackToOriginal converts that ObjectToPack to a non-deltified object if it was one | [
"BackToOriginal",
"converts",
"that",
"ObjectToPack",
"to",
"a",
"non",
"-",
"deltified",
"object",
"if",
"it",
"was",
"one"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/object_pack.go#L55-L61 |
160,977 | src-d/go-git | plumbing/format/packfile/object_pack.go | SetOriginal | func (o *ObjectToPack) SetOriginal(obj plumbing.EncodedObject) {
o.Original = obj
o.SaveOriginalMetadata()
} | go | func (o *ObjectToPack) SetOriginal(obj plumbing.EncodedObject) {
o.Original = obj
o.SaveOriginalMetadata()
} | [
"func",
"(",
"o",
"*",
"ObjectToPack",
")",
"SetOriginal",
"(",
"obj",
"plumbing",
".",
"EncodedObject",
")",
"{",
"o",
".",
"Original",
"=",
"obj",
"\n",
"o",
".",
"SaveOriginalMetadata",
"(",
")",
"\n",
"}"
] | // SetOriginal sets both Original and saves size, type and hash. If object
// is nil Original is set but previous resolved values are kept | [
"SetOriginal",
"sets",
"both",
"Original",
"and",
"saves",
"size",
"type",
"and",
"hash",
".",
"If",
"object",
"is",
"nil",
"Original",
"is",
"set",
"but",
"previous",
"resolved",
"values",
"are",
"kept"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/object_pack.go#L82-L85 |
160,978 | src-d/go-git | plumbing/format/packfile/object_pack.go | SaveOriginalMetadata | func (o *ObjectToPack) SaveOriginalMetadata() {
if o.Original != nil {
o.originalSize = o.Original.Size()
o.originalType = o.Original.Type()
o.originalHash = o.Original.Hash()
o.resolvedOriginal = true
}
} | go | func (o *ObjectToPack) SaveOriginalMetadata() {
if o.Original != nil {
o.originalSize = o.Original.Size()
o.originalType = o.Original.Type()
o.originalHash = o.Original.Hash()
o.resolvedOriginal = true
}
} | [
"func",
"(",
"o",
"*",
"ObjectToPack",
")",
"SaveOriginalMetadata",
"(",
")",
"{",
"if",
"o",
".",
"Original",
"!=",
"nil",
"{",
"o",
".",
"originalSize",
"=",
"o",
".",
"Original",
".",
"Size",
"(",
")",
"\n",
"o",
".",
"originalType",
"=",
"o",
"... | // SaveOriginalMetadata saves size, type and hash of Original object | [
"SaveOriginalMetadata",
"saves",
"size",
"type",
"and",
"hash",
"of",
"Original",
"object"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/packfile/object_pack.go#L88-L95 |
160,979 | src-d/go-git | plumbing/format/gitignore/pattern.go | ParsePattern | func ParsePattern(p string, domain []string) Pattern {
res := pattern{domain: domain}
if strings.HasPrefix(p, inclusionPrefix) {
res.inclusion = true
p = p[1:]
}
if !strings.HasSuffix(p, "\\ ") {
p = strings.TrimRight(p, " ")
}
if strings.HasSuffix(p, patternDirSep) {
res.dirOnly = true
p = p[:len(p)-1]
}
if strings.Contains(p, patternDirSep) {
res.isGlob = true
}
res.pattern = strings.Split(p, patternDirSep)
return &res
} | go | func ParsePattern(p string, domain []string) Pattern {
res := pattern{domain: domain}
if strings.HasPrefix(p, inclusionPrefix) {
res.inclusion = true
p = p[1:]
}
if !strings.HasSuffix(p, "\\ ") {
p = strings.TrimRight(p, " ")
}
if strings.HasSuffix(p, patternDirSep) {
res.dirOnly = true
p = p[:len(p)-1]
}
if strings.Contains(p, patternDirSep) {
res.isGlob = true
}
res.pattern = strings.Split(p, patternDirSep)
return &res
} | [
"func",
"ParsePattern",
"(",
"p",
"string",
",",
"domain",
"[",
"]",
"string",
")",
"Pattern",
"{",
"res",
":=",
"pattern",
"{",
"domain",
":",
"domain",
"}",
"\n\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"p",
",",
"inclusionPrefix",
")",
"{",
"res",... | // ParsePattern parses a gitignore pattern string into the Pattern structure. | [
"ParsePattern",
"parses",
"a",
"gitignore",
"pattern",
"string",
"into",
"the",
"Pattern",
"structure",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/gitignore/pattern.go#L41-L64 |
160,980 | src-d/go-git | plumbing/format/index/encoder.go | Encode | func (e *Encoder) Encode(idx *Index) error {
// TODO: support versions v3 and v4
// TODO: support extensions
if idx.Version != EncodeVersionSupported {
return ErrUnsupportedVersion
}
if err := e.encodeHeader(idx); err != nil {
return err
}
if err := e.encodeEntries(idx); err != nil {
return err
}
return e.encodeFooter()
} | go | func (e *Encoder) Encode(idx *Index) error {
// TODO: support versions v3 and v4
// TODO: support extensions
if idx.Version != EncodeVersionSupported {
return ErrUnsupportedVersion
}
if err := e.encodeHeader(idx); err != nil {
return err
}
if err := e.encodeEntries(idx); err != nil {
return err
}
return e.encodeFooter()
} | [
"func",
"(",
"e",
"*",
"Encoder",
")",
"Encode",
"(",
"idx",
"*",
"Index",
")",
"error",
"{",
"// TODO: support versions v3 and v4",
"// TODO: support extensions",
"if",
"idx",
".",
"Version",
"!=",
"EncodeVersionSupported",
"{",
"return",
"ErrUnsupportedVersion",
"... | // Encode writes the Index to the stream of the encoder. | [
"Encode",
"writes",
"the",
"Index",
"to",
"the",
"stream",
"of",
"the",
"encoder",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/index/encoder.go#L38-L54 |
160,981 | src-d/go-git | plumbing/format/index/match.go | scanChunk | func scanChunk(pattern string) (star bool, chunk, rest string) {
for len(pattern) > 0 && pattern[0] == '*' {
pattern = pattern[1:]
star = true
}
inrange := false
var i int
Scan:
for i = 0; i < len(pattern); i++ {
switch pattern[i] {
case '\\':
if runtime.GOOS != "windows" {
// error check handled in matchChunk: bad pattern.
if i+1 < len(pattern) {
i++
}
}
case '[':
inrange = true
case ']':
inrange = false
case '*':
if !inrange {
break Scan
}
}
}
return star, pattern[0:i], pattern[i:]
} | go | func scanChunk(pattern string) (star bool, chunk, rest string) {
for len(pattern) > 0 && pattern[0] == '*' {
pattern = pattern[1:]
star = true
}
inrange := false
var i int
Scan:
for i = 0; i < len(pattern); i++ {
switch pattern[i] {
case '\\':
if runtime.GOOS != "windows" {
// error check handled in matchChunk: bad pattern.
if i+1 < len(pattern) {
i++
}
}
case '[':
inrange = true
case ']':
inrange = false
case '*':
if !inrange {
break Scan
}
}
}
return star, pattern[0:i], pattern[i:]
} | [
"func",
"scanChunk",
"(",
"pattern",
"string",
")",
"(",
"star",
"bool",
",",
"chunk",
",",
"rest",
"string",
")",
"{",
"for",
"len",
"(",
"pattern",
")",
">",
"0",
"&&",
"pattern",
"[",
"0",
"]",
"==",
"'*'",
"{",
"pattern",
"=",
"pattern",
"[",
... | // scanChunk gets the next segment of pattern, which is a non-star string
// possibly preceded by a star. | [
"scanChunk",
"gets",
"the",
"next",
"segment",
"of",
"pattern",
"which",
"is",
"a",
"non",
"-",
"star",
"string",
"possibly",
"preceded",
"by",
"a",
"star",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/plumbing/format/index/match.go#L56-L84 |
160,982 | src-d/go-git | submodule.go | Init | func (s *Submodule) Init() error {
cfg, err := s.w.r.Storer.Config()
if err != nil {
return err
}
_, ok := cfg.Submodules[s.c.Name]
if ok {
return ErrSubmoduleAlreadyInitialized
}
s.initialized = true
cfg.Submodules[s.c.Name] = s.c
return s.w.r.Storer.SetConfig(cfg)
} | go | func (s *Submodule) Init() error {
cfg, err := s.w.r.Storer.Config()
if err != nil {
return err
}
_, ok := cfg.Submodules[s.c.Name]
if ok {
return ErrSubmoduleAlreadyInitialized
}
s.initialized = true
cfg.Submodules[s.c.Name] = s.c
return s.w.r.Storer.SetConfig(cfg)
} | [
"func",
"(",
"s",
"*",
"Submodule",
")",
"Init",
"(",
")",
"error",
"{",
"cfg",
",",
"err",
":=",
"s",
".",
"w",
".",
"r",
".",
"Storer",
".",
"Config",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
... | // Init initialize the submodule reading the recorded Entry in the index for
// the given submodule | [
"Init",
"initialize",
"the",
"submodule",
"reading",
"the",
"recorded",
"Entry",
"in",
"the",
"index",
"for",
"the",
"given",
"submodule"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/submodule.go#L37-L52 |
160,983 | src-d/go-git | submodule.go | Status | func (s *Submodule) Status() (*SubmoduleStatus, error) {
idx, err := s.w.r.Storer.Index()
if err != nil {
return nil, err
}
return s.status(idx)
} | go | func (s *Submodule) Status() (*SubmoduleStatus, error) {
idx, err := s.w.r.Storer.Index()
if err != nil {
return nil, err
}
return s.status(idx)
} | [
"func",
"(",
"s",
"*",
"Submodule",
")",
"Status",
"(",
")",
"(",
"*",
"SubmoduleStatus",
",",
"error",
")",
"{",
"idx",
",",
"err",
":=",
"s",
".",
"w",
".",
"r",
".",
"Storer",
".",
"Index",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"r... | // Status returns the status of the submodule. | [
"Status",
"returns",
"the",
"status",
"of",
"the",
"submodule",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/submodule.go#L55-L62 |
160,984 | src-d/go-git | submodule.go | Repository | func (s *Submodule) Repository() (*Repository, error) {
if !s.initialized {
return nil, ErrSubmoduleNotInitialized
}
storer, err := s.w.r.Storer.Module(s.c.Name)
if err != nil {
return nil, err
}
_, err = storer.Reference(plumbing.HEAD)
if err != nil && err != plumbing.ErrReferenceNotFound {
return nil, err
}
var exists bool
if err == nil {
exists = true
}
var worktree billy.Filesystem
if worktree, err = s.w.Filesystem.Chroot(s.c.Path); err != nil {
return nil, err
}
if exists {
return Open(storer, worktree)
}
r, err := Init(storer, worktree)
if err != nil {
return nil, err
}
_, err = r.CreateRemote(&config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{s.c.URL},
})
return r, err
} | go | func (s *Submodule) Repository() (*Repository, error) {
if !s.initialized {
return nil, ErrSubmoduleNotInitialized
}
storer, err := s.w.r.Storer.Module(s.c.Name)
if err != nil {
return nil, err
}
_, err = storer.Reference(plumbing.HEAD)
if err != nil && err != plumbing.ErrReferenceNotFound {
return nil, err
}
var exists bool
if err == nil {
exists = true
}
var worktree billy.Filesystem
if worktree, err = s.w.Filesystem.Chroot(s.c.Path); err != nil {
return nil, err
}
if exists {
return Open(storer, worktree)
}
r, err := Init(storer, worktree)
if err != nil {
return nil, err
}
_, err = r.CreateRemote(&config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{s.c.URL},
})
return r, err
} | [
"func",
"(",
"s",
"*",
"Submodule",
")",
"Repository",
"(",
")",
"(",
"*",
"Repository",
",",
"error",
")",
"{",
"if",
"!",
"s",
".",
"initialized",
"{",
"return",
"nil",
",",
"ErrSubmoduleNotInitialized",
"\n",
"}",
"\n\n",
"storer",
",",
"err",
":=",... | // Repository returns the Repository represented by this submodule | [
"Repository",
"returns",
"the",
"Repository",
"represented",
"by",
"this",
"submodule"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/submodule.go#L100-L140 |
160,985 | src-d/go-git | submodule.go | UpdateContext | func (s *Submodule) UpdateContext(ctx context.Context, o *SubmoduleUpdateOptions) error {
return s.update(ctx, o, plumbing.ZeroHash)
} | go | func (s *Submodule) UpdateContext(ctx context.Context, o *SubmoduleUpdateOptions) error {
return s.update(ctx, o, plumbing.ZeroHash)
} | [
"func",
"(",
"s",
"*",
"Submodule",
")",
"UpdateContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"o",
"*",
"SubmoduleUpdateOptions",
")",
"error",
"{",
"return",
"s",
".",
"update",
"(",
"ctx",
",",
"o",
",",
"plumbing",
".",
"ZeroHash",
")",
"\n"... | // UpdateContext the registered submodule to match what the superproject
// expects, the submodule should be initialized first calling the Init method or
// setting in the options SubmoduleUpdateOptions.Init equals true.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects to the
// transport operations. | [
"UpdateContext",
"the",
"registered",
"submodule",
"to",
"match",
"what",
"the",
"superproject",
"expects",
"the",
"submodule",
"should",
"be",
"initialized",
"first",
"calling",
"the",
"Init",
"method",
"or",
"setting",
"in",
"the",
"options",
"SubmoduleUpdateOptio... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/submodule.go#L156-L158 |
160,986 | src-d/go-git | submodule.go | Init | func (s Submodules) Init() error {
for _, sub := range s {
if err := sub.Init(); err != nil {
return err
}
}
return nil
} | go | func (s Submodules) Init() error {
for _, sub := range s {
if err := sub.Init(); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"s",
"Submodules",
")",
"Init",
"(",
")",
"error",
"{",
"for",
"_",
",",
"sub",
":=",
"range",
"s",
"{",
"if",
"err",
":=",
"sub",
".",
"Init",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n"... | // Init initializes the submodules in this list. | [
"Init",
"initializes",
"the",
"submodules",
"in",
"this",
"list",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/submodule.go#L247-L255 |
160,987 | src-d/go-git | submodule.go | Update | func (s Submodules) Update(o *SubmoduleUpdateOptions) error {
return s.UpdateContext(context.Background(), o)
} | go | func (s Submodules) Update(o *SubmoduleUpdateOptions) error {
return s.UpdateContext(context.Background(), o)
} | [
"func",
"(",
"s",
"Submodules",
")",
"Update",
"(",
"o",
"*",
"SubmoduleUpdateOptions",
")",
"error",
"{",
"return",
"s",
".",
"UpdateContext",
"(",
"context",
".",
"Background",
"(",
")",
",",
"o",
")",
"\n",
"}"
] | // Update updates all the submodules in this list. | [
"Update",
"updates",
"all",
"the",
"submodules",
"in",
"this",
"list",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/submodule.go#L258-L260 |
160,988 | src-d/go-git | submodule.go | UpdateContext | func (s Submodules) UpdateContext(ctx context.Context, o *SubmoduleUpdateOptions) error {
for _, sub := range s {
if err := sub.UpdateContext(ctx, o); err != nil {
return err
}
}
return nil
} | go | func (s Submodules) UpdateContext(ctx context.Context, o *SubmoduleUpdateOptions) error {
for _, sub := range s {
if err := sub.UpdateContext(ctx, o); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"s",
"Submodules",
")",
"UpdateContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"o",
"*",
"SubmoduleUpdateOptions",
")",
"error",
"{",
"for",
"_",
",",
"sub",
":=",
"range",
"s",
"{",
"if",
"err",
":=",
"sub",
".",
"UpdateContext",
"(... | // UpdateContext updates all the submodules in this list.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects to the
// transport operations. | [
"UpdateContext",
"updates",
"all",
"the",
"submodules",
"in",
"this",
"list",
".",
"The",
"provided",
"Context",
"must",
"be",
"non",
"-",
"nil",
".",
"If",
"the",
"context",
"expires",
"before",
"the",
"operation",
"is",
"complete",
"an",
"error",
"is",
"... | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/submodule.go#L267-L275 |
160,989 | src-d/go-git | submodule.go | Status | func (s Submodules) Status() (SubmodulesStatus, error) {
var list SubmodulesStatus
var r *Repository
for _, sub := range s {
if r == nil {
r = sub.w.r
}
idx, err := r.Storer.Index()
if err != nil {
return nil, err
}
status, err := sub.status(idx)
if err != nil {
return nil, err
}
list = append(list, status)
}
return list, nil
} | go | func (s Submodules) Status() (SubmodulesStatus, error) {
var list SubmodulesStatus
var r *Repository
for _, sub := range s {
if r == nil {
r = sub.w.r
}
idx, err := r.Storer.Index()
if err != nil {
return nil, err
}
status, err := sub.status(idx)
if err != nil {
return nil, err
}
list = append(list, status)
}
return list, nil
} | [
"func",
"(",
"s",
"Submodules",
")",
"Status",
"(",
")",
"(",
"SubmodulesStatus",
",",
"error",
")",
"{",
"var",
"list",
"SubmodulesStatus",
"\n\n",
"var",
"r",
"*",
"Repository",
"\n",
"for",
"_",
",",
"sub",
":=",
"range",
"s",
"{",
"if",
"r",
"=="... | // Status returns the status of the submodules. | [
"Status",
"returns",
"the",
"status",
"of",
"the",
"submodules",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/submodule.go#L278-L301 |
160,990 | src-d/go-git | submodule.go | String | func (s SubmodulesStatus) String() string {
buf := bytes.NewBuffer(nil)
for _, sub := range s {
fmt.Fprintln(buf, sub)
}
return buf.String()
} | go | func (s SubmodulesStatus) String() string {
buf := bytes.NewBuffer(nil)
for _, sub := range s {
fmt.Fprintln(buf, sub)
}
return buf.String()
} | [
"func",
"(",
"s",
"SubmodulesStatus",
")",
"String",
"(",
")",
"string",
"{",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"nil",
")",
"\n",
"for",
"_",
",",
"sub",
":=",
"range",
"s",
"{",
"fmt",
".",
"Fprintln",
"(",
"buf",
",",
"sub",
")",
"\n... | // String is equivalent to `git submodule status` | [
"String",
"is",
"equivalent",
"to",
"git",
"submodule",
"status"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/submodule.go#L307-L314 |
160,991 | src-d/go-git | storage/filesystem/dotgit/dotgit.go | NewWithOptions | func NewWithOptions(fs billy.Filesystem, o Options) *DotGit {
return &DotGit{
options: o,
fs: fs,
}
} | go | func NewWithOptions(fs billy.Filesystem, o Options) *DotGit {
return &DotGit{
options: o,
fs: fs,
}
} | [
"func",
"NewWithOptions",
"(",
"fs",
"billy",
".",
"Filesystem",
",",
"o",
"Options",
")",
"*",
"DotGit",
"{",
"return",
"&",
"DotGit",
"{",
"options",
":",
"o",
",",
"fs",
":",
"fs",
",",
"}",
"\n",
"}"
] | // NewWithOptions sets non default configuration options.
// See New for complete help. | [
"NewWithOptions",
"sets",
"non",
"default",
"configuration",
"options",
".",
"See",
"New",
"for",
"complete",
"help",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L98-L103 |
160,992 | src-d/go-git | storage/filesystem/dotgit/dotgit.go | Initialize | func (d *DotGit) Initialize() error {
mustExists := []string{
d.fs.Join("objects", "info"),
d.fs.Join("objects", "pack"),
d.fs.Join("refs", "heads"),
d.fs.Join("refs", "tags"),
}
for _, path := range mustExists {
_, err := d.fs.Stat(path)
if err == nil {
continue
}
if !os.IsNotExist(err) {
return err
}
if err := d.fs.MkdirAll(path, os.ModeDir|os.ModePerm); err != nil {
return err
}
}
return nil
} | go | func (d *DotGit) Initialize() error {
mustExists := []string{
d.fs.Join("objects", "info"),
d.fs.Join("objects", "pack"),
d.fs.Join("refs", "heads"),
d.fs.Join("refs", "tags"),
}
for _, path := range mustExists {
_, err := d.fs.Stat(path)
if err == nil {
continue
}
if !os.IsNotExist(err) {
return err
}
if err := d.fs.MkdirAll(path, os.ModeDir|os.ModePerm); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"Initialize",
"(",
")",
"error",
"{",
"mustExists",
":=",
"[",
"]",
"string",
"{",
"d",
".",
"fs",
".",
"Join",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"d",
".",
"fs",
".",
"Join",
"(",
"\"",
"\"",
... | // Initialize creates all the folder scaffolding. | [
"Initialize",
"creates",
"all",
"the",
"folder",
"scaffolding",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L106-L130 |
160,993 | src-d/go-git | storage/filesystem/dotgit/dotgit.go | ConfigWriter | func (d *DotGit) ConfigWriter() (billy.File, error) {
return d.fs.Create(configPath)
} | go | func (d *DotGit) ConfigWriter() (billy.File, error) {
return d.fs.Create(configPath)
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"ConfigWriter",
"(",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"return",
"d",
".",
"fs",
".",
"Create",
"(",
"configPath",
")",
"\n",
"}"
] | // ConfigWriter returns a file pointer for write to the config file | [
"ConfigWriter",
"returns",
"a",
"file",
"pointer",
"for",
"write",
"to",
"the",
"config",
"file"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L155-L157 |
160,994 | src-d/go-git | storage/filesystem/dotgit/dotgit.go | Config | func (d *DotGit) Config() (billy.File, error) {
return d.fs.Open(configPath)
} | go | func (d *DotGit) Config() (billy.File, error) {
return d.fs.Open(configPath)
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"Config",
"(",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"return",
"d",
".",
"fs",
".",
"Open",
"(",
"configPath",
")",
"\n",
"}"
] | // Config returns a file pointer for read to the config file | [
"Config",
"returns",
"a",
"file",
"pointer",
"for",
"read",
"to",
"the",
"config",
"file"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L160-L162 |
160,995 | src-d/go-git | storage/filesystem/dotgit/dotgit.go | IndexWriter | func (d *DotGit) IndexWriter() (billy.File, error) {
return d.fs.Create(indexPath)
} | go | func (d *DotGit) IndexWriter() (billy.File, error) {
return d.fs.Create(indexPath)
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"IndexWriter",
"(",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"return",
"d",
".",
"fs",
".",
"Create",
"(",
"indexPath",
")",
"\n",
"}"
] | // IndexWriter returns a file pointer for write to the index file | [
"IndexWriter",
"returns",
"a",
"file",
"pointer",
"for",
"write",
"to",
"the",
"index",
"file"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L165-L167 |
160,996 | src-d/go-git | storage/filesystem/dotgit/dotgit.go | Index | func (d *DotGit) Index() (billy.File, error) {
return d.fs.Open(indexPath)
} | go | func (d *DotGit) Index() (billy.File, error) {
return d.fs.Open(indexPath)
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"Index",
"(",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"return",
"d",
".",
"fs",
".",
"Open",
"(",
"indexPath",
")",
"\n",
"}"
] | // Index returns a file pointer for read to the index file | [
"Index",
"returns",
"a",
"file",
"pointer",
"for",
"read",
"to",
"the",
"index",
"file"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L170-L172 |
160,997 | src-d/go-git | storage/filesystem/dotgit/dotgit.go | ShallowWriter | func (d *DotGit) ShallowWriter() (billy.File, error) {
return d.fs.Create(shallowPath)
} | go | func (d *DotGit) ShallowWriter() (billy.File, error) {
return d.fs.Create(shallowPath)
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"ShallowWriter",
"(",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"return",
"d",
".",
"fs",
".",
"Create",
"(",
"shallowPath",
")",
"\n",
"}"
] | // ShallowWriter returns a file pointer for write to the shallow file | [
"ShallowWriter",
"returns",
"a",
"file",
"pointer",
"for",
"write",
"to",
"the",
"shallow",
"file"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L175-L177 |
160,998 | src-d/go-git | storage/filesystem/dotgit/dotgit.go | Shallow | func (d *DotGit) Shallow() (billy.File, error) {
f, err := d.fs.Open(shallowPath)
if err != nil {
if os.IsNotExist(err) {
return nil, nil
}
return nil, err
}
return f, nil
} | go | func (d *DotGit) Shallow() (billy.File, error) {
f, err := d.fs.Open(shallowPath)
if err != nil {
if os.IsNotExist(err) {
return nil, nil
}
return nil, err
}
return f, nil
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"Shallow",
"(",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"d",
".",
"fs",
".",
"Open",
"(",
"shallowPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
... | // Shallow returns a file pointer for read to the shallow file | [
"Shallow",
"returns",
"a",
"file",
"pointer",
"for",
"read",
"to",
"the",
"shallow",
"file"
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L180-L191 |
160,999 | src-d/go-git | storage/filesystem/dotgit/dotgit.go | NewObjectPack | func (d *DotGit) NewObjectPack() (*PackWriter, error) {
d.cleanPackList()
return newPackWrite(d.fs)
} | go | func (d *DotGit) NewObjectPack() (*PackWriter, error) {
d.cleanPackList()
return newPackWrite(d.fs)
} | [
"func",
"(",
"d",
"*",
"DotGit",
")",
"NewObjectPack",
"(",
")",
"(",
"*",
"PackWriter",
",",
"error",
")",
"{",
"d",
".",
"cleanPackList",
"(",
")",
"\n",
"return",
"newPackWrite",
"(",
"d",
".",
"fs",
")",
"\n",
"}"
] | // NewObjectPack return a writer for a new packfile, it saves the packfile to
// disk and also generates and save the index for the given packfile. | [
"NewObjectPack",
"return",
"a",
"writer",
"for",
"a",
"new",
"packfile",
"it",
"saves",
"the",
"packfile",
"to",
"disk",
"and",
"also",
"generates",
"and",
"save",
"the",
"index",
"for",
"the",
"given",
"packfile",
"."
] | e17ee112ca6cc7db0a732c0676b61511e84ec899 | https://github.com/src-d/go-git/blob/e17ee112ca6cc7db0a732c0676b61511e84ec899/storage/filesystem/dotgit/dotgit.go#L195-L198 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.