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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
157,400 | git-lfs/git-lfs | errors/context.go | GetContext | func GetContext(err error, key string) interface{} {
if e, ok := err.(withContext); ok {
return e.Get(key)
}
return ""
} | go | func GetContext(err error, key string) interface{} {
if e, ok := err.(withContext); ok {
return e.Get(key)
}
return ""
} | [
"func",
"GetContext",
"(",
"err",
"error",
",",
"key",
"string",
")",
"interface",
"{",
"}",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"withContext",
")",
";",
"ok",
"{",
"return",
"e",
".",
"Get",
"(",
"key",
")",
"\n",
"}",
"\n",
"ret... | // ErrorGetContext gets a value from the error's context. If the error has not
// been wrapped, it returns an empty string. | [
"ErrorGetContext",
"gets",
"a",
"value",
"from",
"the",
"error",
"s",
"context",
".",
"If",
"the",
"error",
"has",
"not",
"been",
"wrapped",
"it",
"returns",
"an",
"empty",
"string",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/context.go#L20-L25 |
157,401 | git-lfs/git-lfs | errors/context.go | DelContext | func DelContext(err error, key string) {
if e, ok := err.(withContext); ok {
e.Del(key)
}
} | go | func DelContext(err error, key string) {
if e, ok := err.(withContext); ok {
e.Del(key)
}
} | [
"func",
"DelContext",
"(",
"err",
"error",
",",
"key",
"string",
")",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"withContext",
")",
";",
"ok",
"{",
"e",
".",
"Del",
"(",
"key",
")",
"\n",
"}",
"\n",
"}"
] | // ErrorDelContext removes a value from the error's context. If the error has
// not been wrapped, it does nothing. | [
"ErrorDelContext",
"removes",
"a",
"value",
"from",
"the",
"error",
"s",
"context",
".",
"If",
"the",
"error",
"has",
"not",
"been",
"wrapped",
"it",
"does",
"nothing",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/context.go#L29-L33 |
157,402 | git-lfs/git-lfs | errors/context.go | Context | func Context(err error) map[string]interface{} {
if e, ok := err.(withContext); ok {
return e.Context()
}
return nil
} | go | func Context(err error) map[string]interface{} {
if e, ok := err.(withContext); ok {
return e.Context()
}
return nil
} | [
"func",
"Context",
"(",
"err",
"error",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"withContext",
")",
";",
"ok",
"{",
"return",
"e",
".",
"Context",
"(",
")",
"\n",
"}",
"\n",
"retu... | // ErrorContext returns the context map for an error if it is a wrappedError.
// If it is not a wrappedError it will return an empty map. | [
"ErrorContext",
"returns",
"the",
"context",
"map",
"for",
"an",
"error",
"if",
"it",
"is",
"a",
"wrappedError",
".",
"If",
"it",
"is",
"not",
"a",
"wrappedError",
"it",
"will",
"return",
"an",
"empty",
"map",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/context.go#L37-L42 |
157,403 | git-lfs/git-lfs | lfs/hook.go | NewStandardHook | func NewStandardHook(theType, hookDir string, upgradeables []string, cfg *config.Configuration) *Hook {
return &Hook{
Type: theType,
Contents: strings.Replace(hookBaseContent, "{{Command}}", theType, -1),
Dir: hookDir,
upgradeables: upgradeables,
cfg: cfg,
}
} | go | func NewStandardHook(theType, hookDir string, upgradeables []string, cfg *config.Configuration) *Hook {
return &Hook{
Type: theType,
Contents: strings.Replace(hookBaseContent, "{{Command}}", theType, -1),
Dir: hookDir,
upgradeables: upgradeables,
cfg: cfg,
}
} | [
"func",
"NewStandardHook",
"(",
"theType",
",",
"hookDir",
"string",
",",
"upgradeables",
"[",
"]",
"string",
",",
"cfg",
"*",
"config",
".",
"Configuration",
")",
"*",
"Hook",
"{",
"return",
"&",
"Hook",
"{",
"Type",
":",
"theType",
",",
"Contents",
":"... | // NewStandardHook creates a new hook using the template script calling 'git lfs theType' | [
"NewStandardHook",
"creates",
"a",
"new",
"hook",
"using",
"the",
"template",
"script",
"calling",
"git",
"lfs",
"theType"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/hook.go#L48-L56 |
157,404 | git-lfs/git-lfs | lfs/hook.go | Install | func (h *Hook) Install(force bool) error {
msg := fmt.Sprintf("Install hook: %s, force=%t, path=%s", h.Type, force, h.Path())
if err := tools.MkdirAll(h.Dir, h.cfg); err != nil {
return err
}
if h.Exists() && !force {
tracerx.Printf(msg + ", upgrading...")
return h.Upgrade()
}
tracerx.Printf(msg)
return h.write()
} | go | func (h *Hook) Install(force bool) error {
msg := fmt.Sprintf("Install hook: %s, force=%t, path=%s", h.Type, force, h.Path())
if err := tools.MkdirAll(h.Dir, h.cfg); err != nil {
return err
}
if h.Exists() && !force {
tracerx.Printf(msg + ", upgrading...")
return h.Upgrade()
}
tracerx.Printf(msg)
return h.write()
} | [
"func",
"(",
"h",
"*",
"Hook",
")",
"Install",
"(",
"force",
"bool",
")",
"error",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"h",
".",
"Type",
",",
"force",
",",
"h",
".",
"Path",
"(",
")",
")",
"\n\n",
"if",
"err",
":=",... | // Install installs this Git hook on disk, or upgrades it if it does exist, and
// is upgradeable. It will create a hooks directory relative to the local Git
// directory. It returns and halts at any errors, and returns nil if the
// operation was a success. | [
"Install",
"installs",
"this",
"Git",
"hook",
"on",
"disk",
"or",
"upgrades",
"it",
"if",
"it",
"does",
"exist",
"and",
"is",
"upgradeable",
".",
"It",
"will",
"create",
"a",
"hooks",
"directory",
"relative",
"to",
"the",
"local",
"Git",
"directory",
".",
... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/hook.go#L74-L88 |
157,405 | git-lfs/git-lfs | lfs/hook.go | write | func (h *Hook) write() error {
return ioutil.WriteFile(h.Path(), []byte(h.Contents+"\n"), 0755)
} | go | func (h *Hook) write() error {
return ioutil.WriteFile(h.Path(), []byte(h.Contents+"\n"), 0755)
} | [
"func",
"(",
"h",
"*",
"Hook",
")",
"write",
"(",
")",
"error",
"{",
"return",
"ioutil",
".",
"WriteFile",
"(",
"h",
".",
"Path",
"(",
")",
",",
"[",
"]",
"byte",
"(",
"h",
".",
"Contents",
"+",
"\"",
"\\n",
"\"",
")",
",",
"0755",
")",
"\n",... | // write writes the contents of this Hook to disk, appending a newline at the
// end, and sets the mode to octal 0755. It writes to disk unconditionally, and
// returns at any error. | [
"write",
"writes",
"the",
"contents",
"of",
"this",
"Hook",
"to",
"disk",
"appending",
"a",
"newline",
"at",
"the",
"end",
"and",
"sets",
"the",
"mode",
"to",
"octal",
"0755",
".",
"It",
"writes",
"to",
"disk",
"unconditionally",
"and",
"returns",
"at",
... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/hook.go#L93-L95 |
157,406 | git-lfs/git-lfs | lfs/hook.go | Uninstall | func (h *Hook) Uninstall() error {
msg := fmt.Sprintf("Uninstall hook: %s, path=%s", h.Type, h.Path())
match, err := h.matchesCurrent()
if err != nil {
return err
}
if !match {
tracerx.Printf(msg + ", doesn't match...")
return nil
}
tracerx.Printf(msg)
return os.RemoveAll(h.Path())
} | go | func (h *Hook) Uninstall() error {
msg := fmt.Sprintf("Uninstall hook: %s, path=%s", h.Type, h.Path())
match, err := h.matchesCurrent()
if err != nil {
return err
}
if !match {
tracerx.Printf(msg + ", doesn't match...")
return nil
}
tracerx.Printf(msg)
return os.RemoveAll(h.Path())
} | [
"func",
"(",
"h",
"*",
"Hook",
")",
"Uninstall",
"(",
")",
"error",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"h",
".",
"Type",
",",
"h",
".",
"Path",
"(",
")",
")",
"\n\n",
"match",
",",
"err",
":=",
"h",
".",
"matchesCu... | // Uninstall removes the hook on disk so long as it matches the current version,
// or any of the past versions of this hook. | [
"Uninstall",
"removes",
"the",
"hook",
"on",
"disk",
"so",
"long",
"as",
"it",
"matches",
"the",
"current",
"version",
"or",
"any",
"of",
"the",
"past",
"versions",
"of",
"this",
"hook",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/hook.go#L116-L131 |
157,407 | git-lfs/git-lfs | lfs/hook.go | matchesCurrent | func (h *Hook) matchesCurrent() (bool, error) {
file, err := os.Open(h.Path())
if err != nil {
return false, err
}
by, err := ioutil.ReadAll(io.LimitReader(file, 1024))
file.Close()
if err != nil {
return false, err
}
contents := strings.TrimSpace(tools.Undent(string(by)))
if contents == h.Contents || len(contents) == 0 {
return true, nil
}
for _, u := range h.upgradeables {
if u == contents {
return true, nil
}
}
return false, fmt.Errorf("Hook already exists: %s\n\n%s\n", string(h.Type), tools.Indent(contents))
} | go | func (h *Hook) matchesCurrent() (bool, error) {
file, err := os.Open(h.Path())
if err != nil {
return false, err
}
by, err := ioutil.ReadAll(io.LimitReader(file, 1024))
file.Close()
if err != nil {
return false, err
}
contents := strings.TrimSpace(tools.Undent(string(by)))
if contents == h.Contents || len(contents) == 0 {
return true, nil
}
for _, u := range h.upgradeables {
if u == contents {
return true, nil
}
}
return false, fmt.Errorf("Hook already exists: %s\n\n%s\n", string(h.Type), tools.Indent(contents))
} | [
"func",
"(",
"h",
"*",
"Hook",
")",
"matchesCurrent",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"h",
".",
"Path",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",... | // matchesCurrent returns whether or not an existing git hook is able to be
// written to or upgraded. A git hook matches those conditions if and only if
// its contents match the current contents, or any past "upgrade-able" contents
// of this hook. | [
"matchesCurrent",
"returns",
"whether",
"or",
"not",
"an",
"existing",
"git",
"hook",
"is",
"able",
"to",
"be",
"written",
"to",
"or",
"upgraded",
".",
"A",
"git",
"hook",
"matches",
"those",
"conditions",
"if",
"and",
"only",
"if",
"its",
"contents",
"mat... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/hook.go#L137-L161 |
157,408 | git-lfs/git-lfs | lfsapi/endpoint_finder.go | Upgrade | func (a *Access) Upgrade(newMode AccessMode) Access {
return Access{url: a.url, mode: newMode}
} | go | func (a *Access) Upgrade(newMode AccessMode) Access {
return Access{url: a.url, mode: newMode}
} | [
"func",
"(",
"a",
"*",
"Access",
")",
"Upgrade",
"(",
"newMode",
"AccessMode",
")",
"Access",
"{",
"return",
"Access",
"{",
"url",
":",
"a",
".",
"url",
",",
"mode",
":",
"newMode",
"}",
"\n",
"}"
] | // Returns a copy of an AccessMode with the mode upgraded to newMode | [
"Returns",
"a",
"copy",
"of",
"an",
"AccessMode",
"with",
"the",
"mode",
"upgraded",
"to",
"newMode"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfsapi/endpoint_finder.go#L35-L37 |
157,409 | git-lfs/git-lfs | lfsapi/endpoint_finder.go | replaceUrlAlias | func (e *endpointGitFinder) replaceUrlAlias(aliases map[string]string, rawurl string) (string, bool) {
var longestalias string
for alias, _ := range aliases {
if !strings.HasPrefix(rawurl, alias) {
continue
}
if longestalias < alias {
longestalias = alias
}
}
if len(longestalias) > 0 {
return aliases[longestalias] + rawurl[len(longestalias):], true
}
return rawurl, false
} | go | func (e *endpointGitFinder) replaceUrlAlias(aliases map[string]string, rawurl string) (string, bool) {
var longestalias string
for alias, _ := range aliases {
if !strings.HasPrefix(rawurl, alias) {
continue
}
if longestalias < alias {
longestalias = alias
}
}
if len(longestalias) > 0 {
return aliases[longestalias] + rawurl[len(longestalias):], true
}
return rawurl, false
} | [
"func",
"(",
"e",
"*",
"endpointGitFinder",
")",
"replaceUrlAlias",
"(",
"aliases",
"map",
"[",
"string",
"]",
"string",
",",
"rawurl",
"string",
")",
"(",
"string",
",",
"bool",
")",
"{",
"var",
"longestalias",
"string",
"\n",
"for",
"alias",
",",
"_",
... | // replaceUrlAlias is a helper function for ReplaceUrlAlias. It must only be
// called while the e.aliasMu mutex is held. | [
"replaceUrlAlias",
"is",
"a",
"helper",
"function",
"for",
"ReplaceUrlAlias",
".",
"It",
"must",
"only",
"be",
"called",
"while",
"the",
"e",
".",
"aliasMu",
"mutex",
"is",
"held",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfsapi/endpoint_finder.go#L305-L322 |
157,410 | git-lfs/git-lfs | tools/str_tools.go | Ljust | func Ljust(strs []string) []string {
llen := len(Longest(strs))
dup := make([]string, len(strs), cap(strs))
copy(dup, strs)
for i, str := range strs {
width := MaxInt(0, llen-len(str))
padding := strings.Repeat(" ", width)
dup[i] = str + padding
}
return dup
} | go | func Ljust(strs []string) []string {
llen := len(Longest(strs))
dup := make([]string, len(strs), cap(strs))
copy(dup, strs)
for i, str := range strs {
width := MaxInt(0, llen-len(str))
padding := strings.Repeat(" ", width)
dup[i] = str + padding
}
return dup
} | [
"func",
"Ljust",
"(",
"strs",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"llen",
":=",
"len",
"(",
"Longest",
"(",
"strs",
")",
")",
"\n\n",
"dup",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"strs",
")",
",",
"cap",
"(",
"... | // Ljust returns a copied string slice where each element is left justified to
// match the width of the longest element in the set. | [
"Ljust",
"returns",
"a",
"copied",
"string",
"slice",
"where",
"each",
"element",
"is",
"left",
"justified",
"to",
"match",
"the",
"width",
"of",
"the",
"longest",
"element",
"in",
"the",
"set",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tools/str_tools.go#L51-L65 |
157,411 | git-lfs/git-lfs | tools/str_tools.go | Indent | func Indent(str string) string {
indented := strings.Replace(str, "\n", "\n\t", -1)
if len(indented) > 0 {
indented = "\t" + indented
}
return indented
} | go | func Indent(str string) string {
indented := strings.Replace(str, "\n", "\n\t", -1)
if len(indented) > 0 {
indented = "\t" + indented
}
return indented
} | [
"func",
"Indent",
"(",
"str",
"string",
")",
"string",
"{",
"indented",
":=",
"strings",
".",
"Replace",
"(",
"str",
",",
"\"",
"\\n",
"\"",
",",
"\"",
"\\n",
"\\t",
"\"",
",",
"-",
"1",
")",
"\n",
"if",
"len",
"(",
"indented",
")",
">",
"0",
"... | // Indent returns a string which prepends "\t" TAB characters to the beginning
// of each line in the given string "str". | [
"Indent",
"returns",
"a",
"string",
"which",
"prepends",
"\\",
"t",
"TAB",
"characters",
"to",
"the",
"beginning",
"of",
"each",
"line",
"in",
"the",
"given",
"string",
"str",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tools/str_tools.go#L106-L113 |
157,412 | git-lfs/git-lfs | commands/command_checkout.go | rootedPaths | func rootedPaths(args []string) []string {
pathConverter, err := lfs.NewCurrentToRepoPathConverter(cfg)
if err != nil {
Panic(err, "Could not checkout")
}
rootedpaths := make([]string, 0, len(args))
for _, arg := range args {
rootedpaths = append(rootedpaths, pathConverter.Convert(arg))
}
return rootedpaths
} | go | func rootedPaths(args []string) []string {
pathConverter, err := lfs.NewCurrentToRepoPathConverter(cfg)
if err != nil {
Panic(err, "Could not checkout")
}
rootedpaths := make([]string, 0, len(args))
for _, arg := range args {
rootedpaths = append(rootedpaths, pathConverter.Convert(arg))
}
return rootedpaths
} | [
"func",
"rootedPaths",
"(",
"args",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"pathConverter",
",",
"err",
":=",
"lfs",
".",
"NewCurrentToRepoPathConverter",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"Panic",
"(",
"err",
",",
"\"",
... | // Parameters are filters
// firstly convert any pathspecs to the root of the repo, in case this is being
// executed in a sub-folder | [
"Parameters",
"are",
"filters",
"firstly",
"convert",
"any",
"pathspecs",
"to",
"the",
"root",
"of",
"the",
"repo",
"in",
"case",
"this",
"is",
"being",
"executed",
"in",
"a",
"sub",
"-",
"folder"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/commands/command_checkout.go#L150-L161 |
157,413 | git-lfs/git-lfs | commands/command_locks.go | Filters | func (l *locksFlags) Filters() (map[string]string, error) {
filters := make(map[string]string)
if l.Path != "" {
path, err := lockPath(l.Path)
if err != nil {
return nil, err
}
filters["path"] = path
}
if l.Id != "" {
filters["id"] = l.Id
}
return filters, nil
} | go | func (l *locksFlags) Filters() (map[string]string, error) {
filters := make(map[string]string)
if l.Path != "" {
path, err := lockPath(l.Path)
if err != nil {
return nil, err
}
filters["path"] = path
}
if l.Id != "" {
filters["id"] = l.Id
}
return filters, nil
} | [
"func",
"(",
"l",
"*",
"locksFlags",
")",
"Filters",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"filters",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n\n",
"if",
"l",
".",
"Path",
"!=",
"\"",
... | // Filters produces a filter based on locksFlags instance. | [
"Filters",
"produces",
"a",
"filter",
"based",
"on",
"locksFlags",
"instance",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/commands/command_locks.go#L156-L172 |
157,414 | git-lfs/git-lfs | commands/command_filter_process.go | incomingOrCached | func incomingOrCached(r io.Reader, ptr *lfs.Pointer) (io.Reader, error) {
buf := make([]byte, 1024)
n, err := r.Read(buf)
buf = buf[:n]
if n == 0 {
if ptr == nil {
// If we read no data from the given io.Reader "r" _and_
// there was no data to fall back on, return an empty
// io.Reader yielding no data.
return bytes.NewReader(buf), nil
}
// If we read no data from the given io.Reader "r", _and_ there
// is a pointer that we can fall back on, return an io.Reader
// that yields the encoded version of the given pointer.
return strings.NewReader(ptr.Encoded()), nil
}
if err == io.EOF {
return bytes.NewReader(buf), nil
}
return io.MultiReader(bytes.NewReader(buf), r), err
} | go | func incomingOrCached(r io.Reader, ptr *lfs.Pointer) (io.Reader, error) {
buf := make([]byte, 1024)
n, err := r.Read(buf)
buf = buf[:n]
if n == 0 {
if ptr == nil {
// If we read no data from the given io.Reader "r" _and_
// there was no data to fall back on, return an empty
// io.Reader yielding no data.
return bytes.NewReader(buf), nil
}
// If we read no data from the given io.Reader "r", _and_ there
// is a pointer that we can fall back on, return an io.Reader
// that yields the encoded version of the given pointer.
return strings.NewReader(ptr.Encoded()), nil
}
if err == io.EOF {
return bytes.NewReader(buf), nil
}
return io.MultiReader(bytes.NewReader(buf), r), err
} | [
"func",
"incomingOrCached",
"(",
"r",
"io",
".",
"Reader",
",",
"ptr",
"*",
"lfs",
".",
"Pointer",
")",
"(",
"io",
".",
"Reader",
",",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1024",
")",
"\n",
"n",
",",
"err",
":=",... | // incomingOrCached returns an io.Reader that is either the contents of the
// given io.Reader "r", or the encoded contents of "ptr". It returns an error if
// there was an error reading from "r".
//
// This is done because when a `command=smudge` with `can-delay=0` is issued,
// the entry's contents are not sent, and must be re-encoded from the stored
// pointer corresponding to the request's filepath. | [
"incomingOrCached",
"returns",
"an",
"io",
".",
"Reader",
"that",
"is",
"either",
"the",
"contents",
"of",
"the",
"given",
"io",
".",
"Reader",
"r",
"or",
"the",
"encoded",
"contents",
"of",
"ptr",
".",
"It",
"returns",
"an",
"error",
"if",
"there",
"was... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/commands/command_filter_process.go#L281-L303 |
157,415 | git-lfs/git-lfs | commands/command_filter_process.go | statusFromErr | func statusFromErr(err error) git.FilterProcessStatus {
if err != nil && err != io.EOF {
return git.StatusError
}
return git.StatusSuccess
} | go | func statusFromErr(err error) git.FilterProcessStatus {
if err != nil && err != io.EOF {
return git.StatusError
}
return git.StatusSuccess
} | [
"func",
"statusFromErr",
"(",
"err",
"error",
")",
"git",
".",
"FilterProcessStatus",
"{",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
"{",
"return",
"git",
".",
"StatusError",
"\n",
"}",
"\n",
"return",
"git",
".",
"StatusSuccess",
... | // statusFromErr returns the status code that should be sent over the filter
// protocol based on a given error, "err". | [
"statusFromErr",
"returns",
"the",
"status",
"code",
"that",
"should",
"be",
"sent",
"over",
"the",
"filter",
"protocol",
"based",
"on",
"a",
"given",
"error",
"err",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/commands/command_filter_process.go#L348-L353 |
157,416 | git-lfs/git-lfs | commands/command_filter_process.go | delayedStatusFromErr | func delayedStatusFromErr(err error) git.FilterProcessStatus {
status := statusFromErr(err)
switch status {
case git.StatusSuccess:
return git.StatusDelay
default:
return status
}
} | go | func delayedStatusFromErr(err error) git.FilterProcessStatus {
status := statusFromErr(err)
switch status {
case git.StatusSuccess:
return git.StatusDelay
default:
return status
}
} | [
"func",
"delayedStatusFromErr",
"(",
"err",
"error",
")",
"git",
".",
"FilterProcessStatus",
"{",
"status",
":=",
"statusFromErr",
"(",
"err",
")",
"\n\n",
"switch",
"status",
"{",
"case",
"git",
".",
"StatusSuccess",
":",
"return",
"git",
".",
"StatusDelay",
... | // delayedStatusFromErr returns the status code that should be sent over the
// filter protocol based on a given error, "err" when the blob smudge operation
// was delayed. | [
"delayedStatusFromErr",
"returns",
"the",
"status",
"code",
"that",
"should",
"be",
"sent",
"over",
"the",
"filter",
"protocol",
"based",
"on",
"a",
"given",
"error",
"err",
"when",
"the",
"blob",
"smudge",
"operation",
"was",
"delayed",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/commands/command_filter_process.go#L358-L367 |
157,417 | git-lfs/git-lfs | commands/command_pre_push.go | decodeRefs | func decodeRefs(input string) (*git.Ref, *git.Ref) {
refs := strings.Split(strings.TrimSpace(input), " ")
for len(refs) < 4 {
refs = append(refs, "")
}
leftRef := git.ParseRef(refs[0], refs[1])
rightRef := git.ParseRef(refs[2], refs[3])
return leftRef, rightRef
} | go | func decodeRefs(input string) (*git.Ref, *git.Ref) {
refs := strings.Split(strings.TrimSpace(input), " ")
for len(refs) < 4 {
refs = append(refs, "")
}
leftRef := git.ParseRef(refs[0], refs[1])
rightRef := git.ParseRef(refs[2], refs[3])
return leftRef, rightRef
} | [
"func",
"decodeRefs",
"(",
"input",
"string",
")",
"(",
"*",
"git",
".",
"Ref",
",",
"*",
"git",
".",
"Ref",
")",
"{",
"refs",
":=",
"strings",
".",
"Split",
"(",
"strings",
".",
"TrimSpace",
"(",
"input",
")",
",",
"\"",
"\"",
")",
"\n",
"for",
... | // decodeRefs pulls the sha1s out of the line read from the pre-push
// hook's stdin. | [
"decodeRefs",
"pulls",
"the",
"sha1s",
"out",
"of",
"the",
"line",
"read",
"from",
"the",
"pre",
"-",
"push",
"hook",
"s",
"stdin",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/commands/command_pre_push.go#L94-L103 |
157,418 | git-lfs/git-lfs | tools/time_tools.go | IsExpiredAtOrIn | func IsExpiredAtOrIn(from time.Time, until time.Duration, at time.Time, in time.Duration) (time.Time, bool) {
expiration := TimeAtOrIn(from, at, in)
if expiration.IsZero() {
return expiration, false
}
return expiration, expiration.Before(time.Now().Add(until))
} | go | func IsExpiredAtOrIn(from time.Time, until time.Duration, at time.Time, in time.Duration) (time.Time, bool) {
expiration := TimeAtOrIn(from, at, in)
if expiration.IsZero() {
return expiration, false
}
return expiration, expiration.Before(time.Now().Add(until))
} | [
"func",
"IsExpiredAtOrIn",
"(",
"from",
"time",
".",
"Time",
",",
"until",
"time",
".",
"Duration",
",",
"at",
"time",
".",
"Time",
",",
"in",
"time",
".",
"Duration",
")",
"(",
"time",
".",
"Time",
",",
"bool",
")",
"{",
"expiration",
":=",
"TimeAtO... | // IsExpiredAtOrIn returns whether or not the result of calling TimeAtOrIn is
// "expired" within "until" units of time from now. | [
"IsExpiredAtOrIn",
"returns",
"whether",
"or",
"not",
"the",
"result",
"of",
"calling",
"TimeAtOrIn",
"is",
"expired",
"within",
"until",
"units",
"of",
"time",
"from",
"now",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tools/time_tools.go#L9-L16 |
157,419 | git-lfs/git-lfs | tools/time_tools.go | TimeAtOrIn | func TimeAtOrIn(from, at time.Time, in time.Duration) time.Time {
if in == 0 {
return at
}
return from.Add(in)
} | go | func TimeAtOrIn(from, at time.Time, in time.Duration) time.Time {
if in == 0 {
return at
}
return from.Add(in)
} | [
"func",
"TimeAtOrIn",
"(",
"from",
",",
"at",
"time",
".",
"Time",
",",
"in",
"time",
".",
"Duration",
")",
"time",
".",
"Time",
"{",
"if",
"in",
"==",
"0",
"{",
"return",
"at",
"\n",
"}",
"\n",
"return",
"from",
".",
"Add",
"(",
"in",
")",
"\n... | // TimeAtOrIn returns either "at", or the "in" duration added to the current
// time. TimeAtOrIn prefers to add a duration rather than return the "at"
// parameter. | [
"TimeAtOrIn",
"returns",
"either",
"at",
"or",
"the",
"in",
"duration",
"added",
"to",
"the",
"current",
"time",
".",
"TimeAtOrIn",
"prefers",
"to",
"add",
"a",
"duration",
"rather",
"than",
"return",
"the",
"at",
"parameter",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tools/time_tools.go#L21-L26 |
157,420 | git-lfs/git-lfs | git/githistory/rewriter.go | rewriteTree | func (r *Rewriter) rewriteTree(commitOID []byte, treeOID []byte, path string,
fn BlobRewriteFn, tpfn TreePreCallbackFn, tfn TreeCallbackFn,
perc *tasklog.PercentageTask) ([]byte, error) {
tree, err := r.db.Tree(treeOID)
if err != nil {
return nil, err
}
if err := tpfn("/"+path, tree); err != nil {
return nil, err
}
entries := make([]*gitobj.TreeEntry, 0, len(tree.Entries))
for _, entry := range tree.Entries {
var fullpath string
if len(path) > 0 {
fullpath = strings.Join([]string{path, entry.Name}, "/")
} else {
fullpath = entry.Name
}
if !r.allows(entry.Type(), fullpath) {
entries = append(entries, copyEntry(entry))
continue
}
// If this is a symlink, skip it
if entry.Filemode == 0120000 {
entries = append(entries, copyEntry(entry))
continue
}
if cached := r.uncacheEntry(entry); cached != nil {
entries = append(entries, copyEntry(cached))
continue
}
var oid []byte
switch entry.Type() {
case gitobj.BlobObjectType:
oid, err = r.rewriteBlob(commitOID, entry.Oid, fullpath, fn, perc)
case gitobj.TreeObjectType:
oid, err = r.rewriteTree(commitOID, entry.Oid, fullpath, fn, tpfn, tfn, perc)
default:
oid = entry.Oid
}
if err != nil {
return nil, err
}
entries = append(entries, r.cacheEntry(entry, &gitobj.TreeEntry{
Filemode: entry.Filemode,
Name: entry.Name,
Oid: oid,
}))
}
rewritten, err := tfn("/"+path, &gitobj.Tree{Entries: entries})
if err != nil {
return nil, err
}
if tree.Equal(rewritten) {
return treeOID, nil
}
return r.db.WriteTree(rewritten)
} | go | func (r *Rewriter) rewriteTree(commitOID []byte, treeOID []byte, path string,
fn BlobRewriteFn, tpfn TreePreCallbackFn, tfn TreeCallbackFn,
perc *tasklog.PercentageTask) ([]byte, error) {
tree, err := r.db.Tree(treeOID)
if err != nil {
return nil, err
}
if err := tpfn("/"+path, tree); err != nil {
return nil, err
}
entries := make([]*gitobj.TreeEntry, 0, len(tree.Entries))
for _, entry := range tree.Entries {
var fullpath string
if len(path) > 0 {
fullpath = strings.Join([]string{path, entry.Name}, "/")
} else {
fullpath = entry.Name
}
if !r.allows(entry.Type(), fullpath) {
entries = append(entries, copyEntry(entry))
continue
}
// If this is a symlink, skip it
if entry.Filemode == 0120000 {
entries = append(entries, copyEntry(entry))
continue
}
if cached := r.uncacheEntry(entry); cached != nil {
entries = append(entries, copyEntry(cached))
continue
}
var oid []byte
switch entry.Type() {
case gitobj.BlobObjectType:
oid, err = r.rewriteBlob(commitOID, entry.Oid, fullpath, fn, perc)
case gitobj.TreeObjectType:
oid, err = r.rewriteTree(commitOID, entry.Oid, fullpath, fn, tpfn, tfn, perc)
default:
oid = entry.Oid
}
if err != nil {
return nil, err
}
entries = append(entries, r.cacheEntry(entry, &gitobj.TreeEntry{
Filemode: entry.Filemode,
Name: entry.Name,
Oid: oid,
}))
}
rewritten, err := tfn("/"+path, &gitobj.Tree{Entries: entries})
if err != nil {
return nil, err
}
if tree.Equal(rewritten) {
return treeOID, nil
}
return r.db.WriteTree(rewritten)
} | [
"func",
"(",
"r",
"*",
"Rewriter",
")",
"rewriteTree",
"(",
"commitOID",
"[",
"]",
"byte",
",",
"treeOID",
"[",
"]",
"byte",
",",
"path",
"string",
",",
"fn",
"BlobRewriteFn",
",",
"tpfn",
"TreePreCallbackFn",
",",
"tfn",
"TreeCallbackFn",
",",
"perc",
"... | // rewriteTree is a recursive function which rewrites a tree given by the ID
// "sha" and path "path". It uses the given BlobRewriteFn to rewrite all blobs
// within the tree, either calling that function or recurring down into subtrees
// by re-assigning the SHA.
//
// Once it is done assembling the entries in a given subtree, it then calls the
// TreeCallbackFn, "tfn" to perform a final traversal of the subtree before
// saving it to the object database.
//
// It returns the new SHA of the rewritten tree, or an error if the tree was
// unable to be rewritten. | [
"rewriteTree",
"is",
"a",
"recursive",
"function",
"which",
"rewrites",
"a",
"tree",
"given",
"by",
"the",
"ID",
"sha",
"and",
"path",
"path",
".",
"It",
"uses",
"the",
"given",
"BlobRewriteFn",
"to",
"rewrite",
"all",
"blobs",
"within",
"the",
"tree",
"ei... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/githistory/rewriter.go#L353-L422 |
157,421 | git-lfs/git-lfs | git/githistory/rewriter.go | refsToMigrate | func (r *Rewriter) refsToMigrate() ([]*git.Ref, error) {
var refs []*git.Ref
var err error
if root, ok := r.db.Root(); ok {
refs, err = git.AllRefsIn(root)
} else {
refs, err = git.AllRefs()
}
if err != nil {
return nil, err
}
var local []*git.Ref
for _, ref := range refs {
if ref.Type == git.RefTypeRemoteBranch {
continue
}
local = append(local, ref)
}
return local, nil
} | go | func (r *Rewriter) refsToMigrate() ([]*git.Ref, error) {
var refs []*git.Ref
var err error
if root, ok := r.db.Root(); ok {
refs, err = git.AllRefsIn(root)
} else {
refs, err = git.AllRefs()
}
if err != nil {
return nil, err
}
var local []*git.Ref
for _, ref := range refs {
if ref.Type == git.RefTypeRemoteBranch {
continue
}
local = append(local, ref)
}
return local, nil
} | [
"func",
"(",
"r",
"*",
"Rewriter",
")",
"refsToMigrate",
"(",
")",
"(",
"[",
"]",
"*",
"git",
".",
"Ref",
",",
"error",
")",
"{",
"var",
"refs",
"[",
"]",
"*",
"git",
".",
"Ref",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"root",
",",
"ok",
"... | // refsToMigrate returns a list of references to migrate, or an error if loading
// those references failed. | [
"refsToMigrate",
"returns",
"a",
"list",
"of",
"references",
"to",
"migrate",
"or",
"an",
"error",
"if",
"loading",
"those",
"references",
"failed",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/githistory/rewriter.go#L528-L552 |
157,422 | git-lfs/git-lfs | tools/stringset.go | NewStringSetFromSlice | func NewStringSetFromSlice(s []string) StringSet {
a := NewStringSetWithCapacity(len(s))
for _, item := range s {
a.Add(item)
}
return a
} | go | func NewStringSetFromSlice(s []string) StringSet {
a := NewStringSetWithCapacity(len(s))
for _, item := range s {
a.Add(item)
}
return a
} | [
"func",
"NewStringSetFromSlice",
"(",
"s",
"[",
"]",
"string",
")",
"StringSet",
"{",
"a",
":=",
"NewStringSetWithCapacity",
"(",
"len",
"(",
"s",
")",
")",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"s",
"{",
"a",
".",
"Add",
"(",
"item",
")",
... | // Creates and returns a reference to a set from an existing slice | [
"Creates",
"and",
"returns",
"a",
"reference",
"to",
"a",
"set",
"from",
"an",
"existing",
"slice"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tools/stringset.go#L26-L32 |
157,423 | git-lfs/git-lfs | tools/stringset.go | IsSubset | func (set StringSet) IsSubset(other StringSet) bool {
for elem := range set {
if !other.Contains(elem) {
return false
}
}
return true
} | go | func (set StringSet) IsSubset(other StringSet) bool {
for elem := range set {
if !other.Contains(elem) {
return false
}
}
return true
} | [
"func",
"(",
"set",
"StringSet",
")",
"IsSubset",
"(",
"other",
"StringSet",
")",
"bool",
"{",
"for",
"elem",
":=",
"range",
"set",
"{",
"if",
"!",
"other",
".",
"Contains",
"(",
"elem",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"ret... | // Determines if every item in the other set is in this set. | [
"Determines",
"if",
"every",
"item",
"in",
"the",
"other",
"set",
"is",
"in",
"this",
"set",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tools/stringset.go#L57-L64 |
157,424 | git-lfs/git-lfs | tasklog/log.go | tty | func tty(writer io.Writer) bool {
if v, ok := writer.(hasFd); ok {
return isatty.IsTerminal(v.Fd()) || isatty.IsCygwinTerminal(v.Fd())
}
return false
} | go | func tty(writer io.Writer) bool {
if v, ok := writer.(hasFd); ok {
return isatty.IsTerminal(v.Fd()) || isatty.IsCygwinTerminal(v.Fd())
}
return false
} | [
"func",
"tty",
"(",
"writer",
"io",
".",
"Writer",
")",
"bool",
"{",
"if",
"v",
",",
"ok",
":=",
"writer",
".",
"(",
"hasFd",
")",
";",
"ok",
"{",
"return",
"isatty",
".",
"IsTerminal",
"(",
"v",
".",
"Fd",
"(",
")",
")",
"||",
"isatty",
".",
... | // tty returns true if the writer is connected to a tty | [
"tty",
"returns",
"true",
"if",
"the",
"writer",
"is",
"connected",
"to",
"a",
"tty"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tasklog/log.go#L99-L104 |
157,425 | git-lfs/git-lfs | tasklog/log.go | Enqueue | func (l *Logger) Enqueue(ts ...Task) {
if l == nil {
for _, t := range ts {
if t == nil {
// NOTE: Do not allow nil tasks which are unable
// to be completed.
continue
}
go func(t Task) {
for range t.Updates() {
// Discard all updates.
}
}(t)
}
return
}
l.wg.Add(len(ts))
for _, t := range ts {
if t == nil {
// NOTE: See above.
continue
}
l.queue <- t
}
} | go | func (l *Logger) Enqueue(ts ...Task) {
if l == nil {
for _, t := range ts {
if t == nil {
// NOTE: Do not allow nil tasks which are unable
// to be completed.
continue
}
go func(t Task) {
for range t.Updates() {
// Discard all updates.
}
}(t)
}
return
}
l.wg.Add(len(ts))
for _, t := range ts {
if t == nil {
// NOTE: See above.
continue
}
l.queue <- t
}
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"Enqueue",
"(",
"ts",
"...",
"Task",
")",
"{",
"if",
"l",
"==",
"nil",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"ts",
"{",
"if",
"t",
"==",
"nil",
"{",
"// NOTE: Do not allow nil tasks which are unable",
"// to be... | // Enqueue enqueues the given Tasks "ts". | [
"Enqueue",
"enqueues",
"the",
"given",
"Tasks",
"ts",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tasklog/log.go#L151-L176 |
157,426 | git-lfs/git-lfs | tasklog/log.go | consume | func (l *Logger) consume() {
go func() {
// Process the single next task in sequence until completion,
// then consume the next task.
for task := range l.tasks {
l.logTask(task)
}
}()
defer close(l.tasks)
pending := make([]Task, 0)
for {
// If there is a pending task, "peek" it off of the set of
// pending tasks.
var next Task
if len(pending) > 0 {
next = pending[0]
}
if next == nil {
// If there was no pending task, wait for either a)
// l.queue to close, or b) a new task to be submitted.
task, ok := <-l.queue
if !ok {
// If the queue is closed, no more new tasks may
// be added.
return
}
// Otherwise, add a new task to the set of tasks to
// process immediately, since there is no current
// buffer.
l.tasks <- task
} else {
// If there is a pending task, wait for either a) a
// write to process the task to become non-blocking, or
// b) a new task to enter the queue.
select {
case task, ok := <-l.queue:
if !ok {
// If the queue is closed, no more tasks
// may be added.
return
}
// Otherwise, add the next task to the set of
// pending, active tasks.
pending = append(pending, task)
case l.tasks <- next:
// Or "pop" the peeked task off of the pending
// set.
pending = pending[1:]
}
}
}
} | go | func (l *Logger) consume() {
go func() {
// Process the single next task in sequence until completion,
// then consume the next task.
for task := range l.tasks {
l.logTask(task)
}
}()
defer close(l.tasks)
pending := make([]Task, 0)
for {
// If there is a pending task, "peek" it off of the set of
// pending tasks.
var next Task
if len(pending) > 0 {
next = pending[0]
}
if next == nil {
// If there was no pending task, wait for either a)
// l.queue to close, or b) a new task to be submitted.
task, ok := <-l.queue
if !ok {
// If the queue is closed, no more new tasks may
// be added.
return
}
// Otherwise, add a new task to the set of tasks to
// process immediately, since there is no current
// buffer.
l.tasks <- task
} else {
// If there is a pending task, wait for either a) a
// write to process the task to become non-blocking, or
// b) a new task to enter the queue.
select {
case task, ok := <-l.queue:
if !ok {
// If the queue is closed, no more tasks
// may be added.
return
}
// Otherwise, add the next task to the set of
// pending, active tasks.
pending = append(pending, task)
case l.tasks <- next:
// Or "pop" the peeked task off of the pending
// set.
pending = pending[1:]
}
}
}
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"consume",
"(",
")",
"{",
"go",
"func",
"(",
")",
"{",
"// Process the single next task in sequence until completion,",
"// then consume the next task.",
"for",
"task",
":=",
"range",
"l",
".",
"tasks",
"{",
"l",
".",
"logTa... | // consume creates a pseudo-infinte buffer between the incoming set of tasks and
// the queue of tasks to work on. | [
"consume",
"creates",
"a",
"pseudo",
"-",
"infinte",
"buffer",
"between",
"the",
"incoming",
"set",
"of",
"tasks",
"and",
"the",
"queue",
"of",
"tasks",
"to",
"work",
"on",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tasklog/log.go#L180-L236 |
157,427 | git-lfs/git-lfs | tasklog/log.go | logLine | func (l *Logger) logLine(str string) (n int, err error) {
padding := strings.Repeat(" ", maxInt(0, l.widthFn()-len(str)))
return l.log(str + padding + "\r")
} | go | func (l *Logger) logLine(str string) (n int, err error) {
padding := strings.Repeat(" ", maxInt(0, l.widthFn()-len(str)))
return l.log(str + padding + "\r")
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"logLine",
"(",
"str",
"string",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"padding",
":=",
"strings",
".",
"Repeat",
"(",
"\"",
"\"",
",",
"maxInt",
"(",
"0",
",",
"l",
".",
"widthFn",
"(",
")",... | // logLine writes a complete line and moves the cursor to the beginning of the
// line.
//
// It returns the number of bytes "n" written to the sink and the error "err",
// if one was encountered. | [
"logLine",
"writes",
"a",
"complete",
"line",
"and",
"moves",
"the",
"cursor",
"to",
"the",
"beginning",
"of",
"the",
"line",
".",
"It",
"returns",
"the",
"number",
"of",
"bytes",
"n",
"written",
"to",
"the",
"sink",
"and",
"the",
"error",
"err",
"if",
... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tasklog/log.go#L287-L291 |
157,428 | git-lfs/git-lfs | tasklog/log.go | log | func (l *Logger) log(str string) (n int, err error) {
return fmt.Fprint(l.sink, str)
} | go | func (l *Logger) log(str string) (n int, err error) {
return fmt.Fprint(l.sink, str)
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"log",
"(",
"str",
"string",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"return",
"fmt",
".",
"Fprint",
"(",
"l",
".",
"sink",
",",
"str",
")",
"\n",
"}"
] | // log writes a string verbatim to the sink.
//
// It returns the number of bytes "n" written to the sink and the error "err",
// if one was encountered. | [
"log",
"writes",
"a",
"string",
"verbatim",
"to",
"the",
"sink",
".",
"It",
"returns",
"the",
"number",
"of",
"bytes",
"n",
"written",
"to",
"the",
"sink",
"and",
"the",
"error",
"err",
"if",
"one",
"was",
"encountered",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tasklog/log.go#L297-L299 |
157,429 | git-lfs/git-lfs | git/git.go | gitConfigNoLFS | func gitConfigNoLFS(args ...string) []string {
// Before git 2.8, setting filters to blank causes lots of warnings, so use cat instead (slightly slower)
// Also pre 2.2 it failed completely. We used to use it anyway in git 2.2-2.7 and
// suppress the messages in stderr, but doing that with standard StderrPipe suppresses
// the git clone output (git thinks it's not a terminal) and makes it look like it's
// not working. You can get around that with https://github.com/kr/pty but that
// causes difficult issues with passing through Stdin for login prompts
// This way is simpler & more practical.
filterOverride := ""
if !IsGitVersionAtLeast("2.8.0") {
filterOverride = "cat"
}
return append([]string{
"-c", fmt.Sprintf("filter.lfs.smudge=%v", filterOverride),
"-c", fmt.Sprintf("filter.lfs.clean=%v", filterOverride),
"-c", "filter.lfs.process=",
"-c", "filter.lfs.required=false",
}, args...)
} | go | func gitConfigNoLFS(args ...string) []string {
// Before git 2.8, setting filters to blank causes lots of warnings, so use cat instead (slightly slower)
// Also pre 2.2 it failed completely. We used to use it anyway in git 2.2-2.7 and
// suppress the messages in stderr, but doing that with standard StderrPipe suppresses
// the git clone output (git thinks it's not a terminal) and makes it look like it's
// not working. You can get around that with https://github.com/kr/pty but that
// causes difficult issues with passing through Stdin for login prompts
// This way is simpler & more practical.
filterOverride := ""
if !IsGitVersionAtLeast("2.8.0") {
filterOverride = "cat"
}
return append([]string{
"-c", fmt.Sprintf("filter.lfs.smudge=%v", filterOverride),
"-c", fmt.Sprintf("filter.lfs.clean=%v", filterOverride),
"-c", "filter.lfs.process=",
"-c", "filter.lfs.required=false",
}, args...)
} | [
"func",
"gitConfigNoLFS",
"(",
"args",
"...",
"string",
")",
"[",
"]",
"string",
"{",
"// Before git 2.8, setting filters to blank causes lots of warnings, so use cat instead (slightly slower)",
"// Also pre 2.2 it failed completely. We used to use it anyway in git 2.2-2.7 and",
"// suppre... | // Prepend Git config instructions to disable Git LFS filter | [
"Prepend",
"Git",
"config",
"instructions",
"to",
"disable",
"Git",
"LFS",
"filter"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L130-L149 |
157,430 | git-lfs/git-lfs | git/git.go | ValidateRemote | func ValidateRemote(remote string) error {
remotes, err := RemoteList()
if err != nil {
return err
}
for _, r := range remotes {
if r == remote {
return nil
}
}
if err = ValidateRemoteURL(remote); err == nil {
return nil
}
return fmt.Errorf("Invalid remote name: %q", remote)
} | go | func ValidateRemote(remote string) error {
remotes, err := RemoteList()
if err != nil {
return err
}
for _, r := range remotes {
if r == remote {
return nil
}
}
if err = ValidateRemoteURL(remote); err == nil {
return nil
}
return fmt.Errorf("Invalid remote name: %q", remote)
} | [
"func",
"ValidateRemote",
"(",
"remote",
"string",
")",
"error",
"{",
"remotes",
",",
"err",
":=",
"RemoteList",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"remotes",
"{",
"... | // ValidateRemote checks that a named remote is valid for use
// Mainly to check user-supplied remotes & fail more nicely | [
"ValidateRemote",
"checks",
"that",
"a",
"named",
"remote",
"is",
"valid",
"for",
"use",
"Mainly",
"to",
"check",
"user",
"-",
"supplied",
"remotes",
"&",
"fail",
"more",
"nicely"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L407-L423 |
157,431 | git-lfs/git-lfs | git/git.go | ValidateRemoteURL | func ValidateRemoteURL(remote string) error {
u, _ := url.Parse(remote)
if u == nil || u.Scheme == "" {
// This is either an invalid remote name (maybe the user made a typo
// when selecting a named remote) or a bare SSH URL like
// "x@y.com:path/to/resource.git". Guess that this is a URL in the latter
// form if the string contains a colon ":", and an invalid remote if it
// does not.
if strings.Contains(remote, ":") {
return nil
} else {
return fmt.Errorf("Invalid remote name: %q", remote)
}
}
switch u.Scheme {
case "ssh", "http", "https", "git":
return nil
default:
return fmt.Errorf("Invalid remote url protocol %q in %q", u.Scheme, remote)
}
} | go | func ValidateRemoteURL(remote string) error {
u, _ := url.Parse(remote)
if u == nil || u.Scheme == "" {
// This is either an invalid remote name (maybe the user made a typo
// when selecting a named remote) or a bare SSH URL like
// "x@y.com:path/to/resource.git". Guess that this is a URL in the latter
// form if the string contains a colon ":", and an invalid remote if it
// does not.
if strings.Contains(remote, ":") {
return nil
} else {
return fmt.Errorf("Invalid remote name: %q", remote)
}
}
switch u.Scheme {
case "ssh", "http", "https", "git":
return nil
default:
return fmt.Errorf("Invalid remote url protocol %q in %q", u.Scheme, remote)
}
} | [
"func",
"ValidateRemoteURL",
"(",
"remote",
"string",
")",
"error",
"{",
"u",
",",
"_",
":=",
"url",
".",
"Parse",
"(",
"remote",
")",
"\n",
"if",
"u",
"==",
"nil",
"||",
"u",
".",
"Scheme",
"==",
"\"",
"\"",
"{",
"// This is either an invalid remote nam... | // ValidateRemoteURL checks that a string is a valid Git remote URL | [
"ValidateRemoteURL",
"checks",
"that",
"a",
"string",
"is",
"a",
"valid",
"Git",
"remote",
"URL"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L426-L447 |
157,432 | git-lfs/git-lfs | git/git.go | ParseRefToTypeAndName | func ParseRefToTypeAndName(fullref string) (t RefType, name string) {
const localPrefix = "refs/heads/"
const remotePrefix = "refs/remotes/"
const localTagPrefix = "refs/tags/"
if fullref == "HEAD" {
name = fullref
t = RefTypeHEAD
} else if strings.HasPrefix(fullref, localPrefix) {
name = fullref[len(localPrefix):]
t = RefTypeLocalBranch
} else if strings.HasPrefix(fullref, remotePrefix) {
name = fullref[len(remotePrefix):]
t = RefTypeRemoteBranch
} else if strings.HasPrefix(fullref, localTagPrefix) {
name = fullref[len(localTagPrefix):]
t = RefTypeLocalTag
} else {
name = fullref
t = RefTypeOther
}
return
} | go | func ParseRefToTypeAndName(fullref string) (t RefType, name string) {
const localPrefix = "refs/heads/"
const remotePrefix = "refs/remotes/"
const localTagPrefix = "refs/tags/"
if fullref == "HEAD" {
name = fullref
t = RefTypeHEAD
} else if strings.HasPrefix(fullref, localPrefix) {
name = fullref[len(localPrefix):]
t = RefTypeLocalBranch
} else if strings.HasPrefix(fullref, remotePrefix) {
name = fullref[len(remotePrefix):]
t = RefTypeRemoteBranch
} else if strings.HasPrefix(fullref, localTagPrefix) {
name = fullref[len(localTagPrefix):]
t = RefTypeLocalTag
} else {
name = fullref
t = RefTypeOther
}
return
} | [
"func",
"ParseRefToTypeAndName",
"(",
"fullref",
"string",
")",
"(",
"t",
"RefType",
",",
"name",
"string",
")",
"{",
"const",
"localPrefix",
"=",
"\"",
"\"",
"\n",
"const",
"remotePrefix",
"=",
"\"",
"\"",
"\n",
"const",
"localTagPrefix",
"=",
"\"",
"\"",... | // Get the type & name of a git reference | [
"Get",
"the",
"type",
"&",
"name",
"of",
"a",
"git",
"reference"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L514-L536 |
157,433 | git-lfs/git-lfs | git/git.go | GetCommitSummary | func GetCommitSummary(commit string) (*CommitSummary, error) {
cmd := gitNoLFS("show", "-s",
`--format=%H|%h|%P|%ai|%ci|%ae|%an|%ce|%cn|%s`, commit)
out, err := cmd.CombinedOutput()
if err != nil {
return nil, fmt.Errorf("Failed to call git show: %v %v", err, string(out))
}
// At most 10 substrings so subject line is not split on anything
fields := strings.SplitN(string(out), "|", 10)
// Cope with the case where subject is blank
if len(fields) >= 9 {
ret := &CommitSummary{}
// Get SHAs from output, not commit input, so we can support symbolic refs
ret.Sha = fields[0]
ret.ShortSha = fields[1]
ret.Parents = strings.Split(fields[2], " ")
// %aD & %cD (RFC2822) matches Go's RFC1123Z format
ret.AuthorDate, _ = ParseGitDate(fields[3])
ret.CommitDate, _ = ParseGitDate(fields[4])
ret.AuthorEmail = fields[5]
ret.AuthorName = fields[6]
ret.CommitterEmail = fields[7]
ret.CommitterName = fields[8]
if len(fields) > 9 {
ret.Subject = strings.TrimRight(fields[9], "\n")
}
return ret, nil
} else {
msg := fmt.Sprintf("Unexpected output from git show: %v", string(out))
return nil, errors.New(msg)
}
} | go | func GetCommitSummary(commit string) (*CommitSummary, error) {
cmd := gitNoLFS("show", "-s",
`--format=%H|%h|%P|%ai|%ci|%ae|%an|%ce|%cn|%s`, commit)
out, err := cmd.CombinedOutput()
if err != nil {
return nil, fmt.Errorf("Failed to call git show: %v %v", err, string(out))
}
// At most 10 substrings so subject line is not split on anything
fields := strings.SplitN(string(out), "|", 10)
// Cope with the case where subject is blank
if len(fields) >= 9 {
ret := &CommitSummary{}
// Get SHAs from output, not commit input, so we can support symbolic refs
ret.Sha = fields[0]
ret.ShortSha = fields[1]
ret.Parents = strings.Split(fields[2], " ")
// %aD & %cD (RFC2822) matches Go's RFC1123Z format
ret.AuthorDate, _ = ParseGitDate(fields[3])
ret.CommitDate, _ = ParseGitDate(fields[4])
ret.AuthorEmail = fields[5]
ret.AuthorName = fields[6]
ret.CommitterEmail = fields[7]
ret.CommitterName = fields[8]
if len(fields) > 9 {
ret.Subject = strings.TrimRight(fields[9], "\n")
}
return ret, nil
} else {
msg := fmt.Sprintf("Unexpected output from git show: %v", string(out))
return nil, errors.New(msg)
}
} | [
"func",
"GetCommitSummary",
"(",
"commit",
"string",
")",
"(",
"*",
"CommitSummary",
",",
"error",
")",
"{",
"cmd",
":=",
"gitNoLFS",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"`--format=%H|%h|%P|%ai|%ci|%ae|%an|%ce|%cn|%s`",
",",
"commit",
")",
"\n\n",
"out",
... | // Get summary information about a commit | [
"Get",
"summary",
"information",
"about",
"a",
"commit"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L557-L590 |
157,434 | git-lfs/git-lfs | git/git.go | parseRefFile | func parseRefFile(filename string) (*Ref, error) {
bytes, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
contents := strings.TrimSpace(string(bytes))
if strings.HasPrefix(contents, "ref:") {
contents = strings.TrimSpace(contents[4:])
}
return ResolveRef(contents)
} | go | func parseRefFile(filename string) (*Ref, error) {
bytes, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
contents := strings.TrimSpace(string(bytes))
if strings.HasPrefix(contents, "ref:") {
contents = strings.TrimSpace(contents[4:])
}
return ResolveRef(contents)
} | [
"func",
"parseRefFile",
"(",
"filename",
"string",
")",
"(",
"*",
"Ref",
",",
"error",
")",
"{",
"bytes",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}"... | // Manually parse a reference file like HEAD and return the Ref it resolves to | [
"Manually",
"parse",
"a",
"reference",
"file",
"like",
"HEAD",
"and",
"return",
"the",
"Ref",
"it",
"resolves",
"to"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L728-L738 |
157,435 | git-lfs/git-lfs | git/git.go | IsBare | func IsBare() (bool, error) {
s, err := subprocess.SimpleExec(
"git", "rev-parse", "--is-bare-repository")
if err != nil {
return false, err
}
return strconv.ParseBool(s)
} | go | func IsBare() (bool, error) {
s, err := subprocess.SimpleExec(
"git", "rev-parse", "--is-bare-repository")
if err != nil {
return false, err
}
return strconv.ParseBool(s)
} | [
"func",
"IsBare",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"subprocess",
".",
"SimpleExec",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err... | // IsBare returns whether or not a repository is bare. It requires that the
// current working directory is a repository.
//
// If there was an error determining whether or not the repository is bare, it
// will be returned. | [
"IsBare",
"returns",
"whether",
"or",
"not",
"a",
"repository",
"is",
"bare",
".",
"It",
"requires",
"that",
"the",
"current",
"working",
"directory",
"is",
"a",
"repository",
".",
"If",
"there",
"was",
"an",
"error",
"determining",
"whether",
"or",
"not",
... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L745-L754 |
157,436 | git-lfs/git-lfs | git/git.go | CachedRemoteRefs | func CachedRemoteRefs(remoteName string) ([]*Ref, error) {
var ret []*Ref
cmd := gitNoLFS("show-ref")
outp, err := cmd.StdoutPipe()
if err != nil {
return nil, fmt.Errorf("Failed to call git show-ref: %v", err)
}
cmd.Start()
scanner := bufio.NewScanner(outp)
r := regexp.MustCompile(fmt.Sprintf(`([0-9a-fA-F]{40})\s+refs/remotes/%v/(.*)`, remoteName))
for scanner.Scan() {
if match := r.FindStringSubmatch(scanner.Text()); match != nil {
name := strings.TrimSpace(match[2])
// Don't match head
if name == "HEAD" {
continue
}
sha := match[1]
ret = append(ret, &Ref{name, RefTypeRemoteBranch, sha})
}
}
return ret, cmd.Wait()
} | go | func CachedRemoteRefs(remoteName string) ([]*Ref, error) {
var ret []*Ref
cmd := gitNoLFS("show-ref")
outp, err := cmd.StdoutPipe()
if err != nil {
return nil, fmt.Errorf("Failed to call git show-ref: %v", err)
}
cmd.Start()
scanner := bufio.NewScanner(outp)
r := regexp.MustCompile(fmt.Sprintf(`([0-9a-fA-F]{40})\s+refs/remotes/%v/(.*)`, remoteName))
for scanner.Scan() {
if match := r.FindStringSubmatch(scanner.Text()); match != nil {
name := strings.TrimSpace(match[2])
// Don't match head
if name == "HEAD" {
continue
}
sha := match[1]
ret = append(ret, &Ref{name, RefTypeRemoteBranch, sha})
}
}
return ret, cmd.Wait()
} | [
"func",
"CachedRemoteRefs",
"(",
"remoteName",
"string",
")",
"(",
"[",
"]",
"*",
"Ref",
",",
"error",
")",
"{",
"var",
"ret",
"[",
"]",
"*",
"Ref",
"\n",
"cmd",
":=",
"gitNoLFS",
"(",
"\"",
"\"",
")",
"\n\n",
"outp",
",",
"err",
":=",
"cmd",
"."... | // CachedRemoteRefs returns the list of branches & tags for a remote which are
// currently cached locally. No remote request is made to verify them. | [
"CachedRemoteRefs",
"returns",
"the",
"list",
"of",
"branches",
"&",
"tags",
"for",
"a",
"remote",
"which",
"are",
"currently",
"cached",
"locally",
".",
"No",
"remote",
"request",
"is",
"made",
"to",
"verify",
"them",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L965-L990 |
157,437 | git-lfs/git-lfs | git/git.go | Fetch | func Fetch(remotes ...string) error {
if len(remotes) == 0 {
return nil
}
var args []string
if len(remotes) > 1 {
args = []string{"--multiple", "--"}
}
args = append(args, remotes...)
_, err := gitNoLFSSimple(append([]string{"fetch"}, args...)...)
return err
} | go | func Fetch(remotes ...string) error {
if len(remotes) == 0 {
return nil
}
var args []string
if len(remotes) > 1 {
args = []string{"--multiple", "--"}
}
args = append(args, remotes...)
_, err := gitNoLFSSimple(append([]string{"fetch"}, args...)...)
return err
} | [
"func",
"Fetch",
"(",
"remotes",
"...",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"remotes",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"args",
"[",
"]",
"string",
"\n",
"if",
"len",
"(",
"remotes",
")",
">",
"1",
"{",
... | // Fetch performs a fetch with no arguments against the given remotes. | [
"Fetch",
"performs",
"a",
"fetch",
"with",
"no",
"arguments",
"against",
"the",
"given",
"remotes",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L993-L1006 |
157,438 | git-lfs/git-lfs | git/git.go | AllRefsIn | func AllRefsIn(wd string) ([]*Ref, error) {
cmd := gitNoLFS(
"for-each-ref", "--format=%(objectname)%00%(refname)")
cmd.Dir = wd
outp, err := cmd.StdoutPipe()
if err != nil {
return nil, lfserrors.Wrap(err, "cannot open pipe")
}
cmd.Start()
refs := make([]*Ref, 0)
scanner := bufio.NewScanner(outp)
for scanner.Scan() {
parts := strings.SplitN(scanner.Text(), "\x00", 2)
if len(parts) != 2 {
return nil, lfserrors.Errorf(
"git: invalid for-each-ref line: %q", scanner.Text())
}
sha := parts[0]
typ, name := ParseRefToTypeAndName(parts[1])
refs = append(refs, &Ref{
Name: name,
Type: typ,
Sha: sha,
})
}
if err := scanner.Err(); err != nil {
return nil, err
}
return refs, nil
} | go | func AllRefsIn(wd string) ([]*Ref, error) {
cmd := gitNoLFS(
"for-each-ref", "--format=%(objectname)%00%(refname)")
cmd.Dir = wd
outp, err := cmd.StdoutPipe()
if err != nil {
return nil, lfserrors.Wrap(err, "cannot open pipe")
}
cmd.Start()
refs := make([]*Ref, 0)
scanner := bufio.NewScanner(outp)
for scanner.Scan() {
parts := strings.SplitN(scanner.Text(), "\x00", 2)
if len(parts) != 2 {
return nil, lfserrors.Errorf(
"git: invalid for-each-ref line: %q", scanner.Text())
}
sha := parts[0]
typ, name := ParseRefToTypeAndName(parts[1])
refs = append(refs, &Ref{
Name: name,
Type: typ,
Sha: sha,
})
}
if err := scanner.Err(); err != nil {
return nil, err
}
return refs, nil
} | [
"func",
"AllRefsIn",
"(",
"wd",
"string",
")",
"(",
"[",
"]",
"*",
"Ref",
",",
"error",
")",
"{",
"cmd",
":=",
"gitNoLFS",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"wd",
"\n\n",
"outp",
",",
"err",
":=",
"cmd",
"."... | // AllRefs returns a slice of all references in a Git repository located in a
// the given working directory "wd", or an error if those references could not
// be loaded. | [
"AllRefs",
"returns",
"a",
"slice",
"of",
"all",
"references",
"in",
"a",
"Git",
"repository",
"located",
"in",
"a",
"the",
"given",
"working",
"directory",
"wd",
"or",
"an",
"error",
"if",
"those",
"references",
"could",
"not",
"be",
"loaded",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L1046-L1082 |
157,439 | git-lfs/git-lfs | git/git.go | GetFilesChanged | func GetFilesChanged(from, to string) ([]string, error) {
var files []string
args := []string{
"-c", "core.quotepath=false", // handle special chars in filenames
"diff-tree",
"--no-commit-id",
"--name-only",
"-r",
}
if len(from) > 0 {
args = append(args, from)
}
if len(to) > 0 {
args = append(args, to)
}
args = append(args, "--") // no ambiguous patterns
cmd := gitNoLFS(args...)
outp, err := cmd.StdoutPipe()
if err != nil {
return nil, fmt.Errorf("Failed to call git diff: %v", err)
}
if err := cmd.Start(); err != nil {
return nil, fmt.Errorf("Failed to start git diff: %v", err)
}
scanner := bufio.NewScanner(outp)
for scanner.Scan() {
files = append(files, strings.TrimSpace(scanner.Text()))
}
if err := cmd.Wait(); err != nil {
return nil, fmt.Errorf("Git diff failed: %v", err)
}
return files, err
} | go | func GetFilesChanged(from, to string) ([]string, error) {
var files []string
args := []string{
"-c", "core.quotepath=false", // handle special chars in filenames
"diff-tree",
"--no-commit-id",
"--name-only",
"-r",
}
if len(from) > 0 {
args = append(args, from)
}
if len(to) > 0 {
args = append(args, to)
}
args = append(args, "--") // no ambiguous patterns
cmd := gitNoLFS(args...)
outp, err := cmd.StdoutPipe()
if err != nil {
return nil, fmt.Errorf("Failed to call git diff: %v", err)
}
if err := cmd.Start(); err != nil {
return nil, fmt.Errorf("Failed to start git diff: %v", err)
}
scanner := bufio.NewScanner(outp)
for scanner.Scan() {
files = append(files, strings.TrimSpace(scanner.Text()))
}
if err := cmd.Wait(); err != nil {
return nil, fmt.Errorf("Git diff failed: %v", err)
}
return files, err
} | [
"func",
"GetFilesChanged",
"(",
"from",
",",
"to",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"var",
"files",
"[",
"]",
"string",
"\n",
"args",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"// handle special... | // GetFilesChanged returns a list of files which were changed, either between 2
// commits, or at a single commit if you only supply one argument and a blank
// string for the other | [
"GetFilesChanged",
"returns",
"a",
"list",
"of",
"files",
"which",
"were",
"changed",
"either",
"between",
"2",
"commits",
"or",
"at",
"a",
"single",
"commit",
"if",
"you",
"only",
"supply",
"one",
"argument",
"and",
"a",
"blank",
"string",
"for",
"the",
"... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L1134-L1169 |
157,440 | git-lfs/git-lfs | git/git.go | IsFileModified | func IsFileModified(filepath string) (bool, error) {
args := []string{
"-c", "core.quotepath=false", // handle special chars in filenames
"status",
"--porcelain",
"--", // separator in case filename ambiguous
filepath,
}
cmd := git(args...)
outp, err := cmd.StdoutPipe()
if err != nil {
return false, lfserrors.Wrap(err, "Failed to call git status")
}
if err := cmd.Start(); err != nil {
return false, lfserrors.Wrap(err, "Failed to start git status")
}
matched := false
for scanner := bufio.NewScanner(outp); scanner.Scan(); {
line := scanner.Text()
// Porcelain format is "<I><W> <filename>"
// Where <I> = index status, <W> = working copy status
if len(line) > 3 {
// Double-check even though should be only match
if strings.TrimSpace(line[3:]) == filepath {
matched = true
// keep consuming output to exit cleanly
// will typically fall straight through anyway due to 1 line output
}
}
}
if err := cmd.Wait(); err != nil {
return false, lfserrors.Wrap(err, "Git status failed")
}
return matched, nil
} | go | func IsFileModified(filepath string) (bool, error) {
args := []string{
"-c", "core.quotepath=false", // handle special chars in filenames
"status",
"--porcelain",
"--", // separator in case filename ambiguous
filepath,
}
cmd := git(args...)
outp, err := cmd.StdoutPipe()
if err != nil {
return false, lfserrors.Wrap(err, "Failed to call git status")
}
if err := cmd.Start(); err != nil {
return false, lfserrors.Wrap(err, "Failed to start git status")
}
matched := false
for scanner := bufio.NewScanner(outp); scanner.Scan(); {
line := scanner.Text()
// Porcelain format is "<I><W> <filename>"
// Where <I> = index status, <W> = working copy status
if len(line) > 3 {
// Double-check even though should be only match
if strings.TrimSpace(line[3:]) == filepath {
matched = true
// keep consuming output to exit cleanly
// will typically fall straight through anyway due to 1 line output
}
}
}
if err := cmd.Wait(); err != nil {
return false, lfserrors.Wrap(err, "Git status failed")
}
return matched, nil
} | [
"func",
"IsFileModified",
"(",
"filepath",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"args",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"// handle special chars in filenames",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\""... | // IsFileModified returns whether the filepath specified is modified according
// to `git status`. A file is modified if it has uncommitted changes in the
// working copy or the index. This includes being untracked. | [
"IsFileModified",
"returns",
"whether",
"the",
"filepath",
"specified",
"is",
"modified",
"according",
"to",
"git",
"status",
".",
"A",
"file",
"is",
"modified",
"if",
"it",
"has",
"uncommitted",
"changes",
"in",
"the",
"working",
"copy",
"or",
"the",
"index",... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L1174-L1210 |
157,441 | git-lfs/git-lfs | git/git.go | IsWorkingCopyDirty | func IsWorkingCopyDirty() (bool, error) {
bare, err := IsBare()
if bare || err != nil {
return false, err
}
out, err := gitSimple("status", "--porcelain")
if err != nil {
return false, err
}
return len(out) != 0, nil
} | go | func IsWorkingCopyDirty() (bool, error) {
bare, err := IsBare()
if bare || err != nil {
return false, err
}
out, err := gitSimple("status", "--porcelain")
if err != nil {
return false, err
}
return len(out) != 0, nil
} | [
"func",
"IsWorkingCopyDirty",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"bare",
",",
"err",
":=",
"IsBare",
"(",
")",
"\n",
"if",
"bare",
"||",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"out",
",",
"err",
":=... | // IsWorkingCopyDirty returns true if and only if the working copy in which the
// command was executed is dirty as compared to the index.
//
// If the status of the working copy could not be determined, an error will be
// returned instead. | [
"IsWorkingCopyDirty",
"returns",
"true",
"if",
"and",
"only",
"if",
"the",
"working",
"copy",
"in",
"which",
"the",
"command",
"was",
"executed",
"is",
"dirty",
"as",
"compared",
"to",
"the",
"index",
".",
"If",
"the",
"status",
"of",
"the",
"working",
"co... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/git.go#L1217-L1228 |
157,442 | git-lfs/git-lfs | tq/manifest.go | GetAdapterNames | func (m *Manifest) GetAdapterNames(dir Direction) []string {
switch dir {
case Upload:
return m.GetUploadAdapterNames()
case Download:
return m.GetDownloadAdapterNames()
}
return nil
} | go | func (m *Manifest) GetAdapterNames(dir Direction) []string {
switch dir {
case Upload:
return m.GetUploadAdapterNames()
case Download:
return m.GetDownloadAdapterNames()
}
return nil
} | [
"func",
"(",
"m",
"*",
"Manifest",
")",
"GetAdapterNames",
"(",
"dir",
"Direction",
")",
"[",
"]",
"string",
"{",
"switch",
"dir",
"{",
"case",
"Upload",
":",
"return",
"m",
".",
"GetUploadAdapterNames",
"(",
")",
"\n",
"case",
"Download",
":",
"return",... | // GetAdapterNames returns a list of the names of adapters available to be created | [
"GetAdapterNames",
"returns",
"a",
"list",
"of",
"the",
"names",
"of",
"adapters",
"available",
"to",
"be",
"created"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tq/manifest.go#L123-L131 |
157,443 | git-lfs/git-lfs | tq/manifest.go | getAdapterNames | func (m *Manifest) getAdapterNames(adapters map[string]NewAdapterFunc) []string {
if m.basicTransfersOnly {
return []string{BasicAdapterName}
}
m.mu.Lock()
defer m.mu.Unlock()
ret := make([]string, 0, len(adapters))
for n, _ := range adapters {
ret = append(ret, n)
}
return ret
} | go | func (m *Manifest) getAdapterNames(adapters map[string]NewAdapterFunc) []string {
if m.basicTransfersOnly {
return []string{BasicAdapterName}
}
m.mu.Lock()
defer m.mu.Unlock()
ret := make([]string, 0, len(adapters))
for n, _ := range adapters {
ret = append(ret, n)
}
return ret
} | [
"func",
"(",
"m",
"*",
"Manifest",
")",
"getAdapterNames",
"(",
"adapters",
"map",
"[",
"string",
"]",
"NewAdapterFunc",
")",
"[",
"]",
"string",
"{",
"if",
"m",
".",
"basicTransfersOnly",
"{",
"return",
"[",
"]",
"string",
"{",
"BasicAdapterName",
"}",
... | // getAdapterNames returns a list of the names of adapters available to be created | [
"getAdapterNames",
"returns",
"a",
"list",
"of",
"the",
"names",
"of",
"adapters",
"available",
"to",
"be",
"created"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tq/manifest.go#L144-L157 |
157,444 | git-lfs/git-lfs | tq/manifest.go | RegisterNewAdapterFunc | func (m *Manifest) RegisterNewAdapterFunc(name string, dir Direction, f NewAdapterFunc) {
m.mu.Lock()
defer m.mu.Unlock()
switch dir {
case Upload:
m.uploadAdapterFuncs[name] = f
case Download:
m.downloadAdapterFuncs[name] = f
}
} | go | func (m *Manifest) RegisterNewAdapterFunc(name string, dir Direction, f NewAdapterFunc) {
m.mu.Lock()
defer m.mu.Unlock()
switch dir {
case Upload:
m.uploadAdapterFuncs[name] = f
case Download:
m.downloadAdapterFuncs[name] = f
}
} | [
"func",
"(",
"m",
"*",
"Manifest",
")",
"RegisterNewAdapterFunc",
"(",
"name",
"string",
",",
"dir",
"Direction",
",",
"f",
"NewAdapterFunc",
")",
"{",
"m",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"Unlock",
"(",
")",
"... | // RegisterNewTransferAdapterFunc registers a new function for creating upload
// or download adapters. If a function with that name & direction is already
// registered, it is overridden | [
"RegisterNewTransferAdapterFunc",
"registers",
"a",
"new",
"function",
"for",
"creating",
"upload",
"or",
"download",
"adapters",
".",
"If",
"a",
"function",
"with",
"that",
"name",
"&",
"direction",
"is",
"already",
"registered",
"it",
"is",
"overridden"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tq/manifest.go#L162-L172 |
157,445 | git-lfs/git-lfs | tq/manifest.go | NewAdapterOrDefault | func (m *Manifest) NewAdapterOrDefault(name string, dir Direction) Adapter {
if len(name) == 0 {
name = BasicAdapterName
}
a := m.NewAdapter(name, dir)
if a == nil {
tracerx.Printf("Defaulting to basic transfer adapter since %q did not exist", name)
a = m.NewAdapter(BasicAdapterName, dir)
}
return a
} | go | func (m *Manifest) NewAdapterOrDefault(name string, dir Direction) Adapter {
if len(name) == 0 {
name = BasicAdapterName
}
a := m.NewAdapter(name, dir)
if a == nil {
tracerx.Printf("Defaulting to basic transfer adapter since %q did not exist", name)
a = m.NewAdapter(BasicAdapterName, dir)
}
return a
} | [
"func",
"(",
"m",
"*",
"Manifest",
")",
"NewAdapterOrDefault",
"(",
"name",
"string",
",",
"dir",
"Direction",
")",
"Adapter",
"{",
"if",
"len",
"(",
"name",
")",
"==",
"0",
"{",
"name",
"=",
"BasicAdapterName",
"\n",
"}",
"\n\n",
"a",
":=",
"m",
"."... | // Create a new adapter by name and direction; default to BasicAdapterName if doesn't exist | [
"Create",
"a",
"new",
"adapter",
"by",
"name",
"and",
"direction",
";",
"default",
"to",
"BasicAdapterName",
"if",
"doesn",
"t",
"exist"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tq/manifest.go#L175-L186 |
157,446 | git-lfs/git-lfs | tq/manifest.go | NewAdapter | func (m *Manifest) NewAdapter(name string, dir Direction) Adapter {
m.mu.Lock()
defer m.mu.Unlock()
switch dir {
case Upload:
if u, ok := m.uploadAdapterFuncs[name]; ok {
return u(name, dir)
}
case Download:
if d, ok := m.downloadAdapterFuncs[name]; ok {
return d(name, dir)
}
}
return nil
} | go | func (m *Manifest) NewAdapter(name string, dir Direction) Adapter {
m.mu.Lock()
defer m.mu.Unlock()
switch dir {
case Upload:
if u, ok := m.uploadAdapterFuncs[name]; ok {
return u(name, dir)
}
case Download:
if d, ok := m.downloadAdapterFuncs[name]; ok {
return d(name, dir)
}
}
return nil
} | [
"func",
"(",
"m",
"*",
"Manifest",
")",
"NewAdapter",
"(",
"name",
"string",
",",
"dir",
"Direction",
")",
"Adapter",
"{",
"m",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"switch",
"dir",
"{"... | // Create a new adapter by name and direction, or nil if doesn't exist | [
"Create",
"a",
"new",
"adapter",
"by",
"name",
"and",
"direction",
"or",
"nil",
"if",
"doesn",
"t",
"exist"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tq/manifest.go#L189-L204 |
157,447 | git-lfs/git-lfs | tq/manifest.go | NewDownloadAdapter | func (m *Manifest) NewDownloadAdapter(name string) Adapter {
return m.NewAdapterOrDefault(name, Download)
} | go | func (m *Manifest) NewDownloadAdapter(name string) Adapter {
return m.NewAdapterOrDefault(name, Download)
} | [
"func",
"(",
"m",
"*",
"Manifest",
")",
"NewDownloadAdapter",
"(",
"name",
"string",
")",
"Adapter",
"{",
"return",
"m",
".",
"NewAdapterOrDefault",
"(",
"name",
",",
"Download",
")",
"\n",
"}"
] | // Create a new download adapter by name, or BasicAdapterName if doesn't exist | [
"Create",
"a",
"new",
"download",
"adapter",
"by",
"name",
"or",
"BasicAdapterName",
"if",
"doesn",
"t",
"exist"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tq/manifest.go#L207-L209 |
157,448 | git-lfs/git-lfs | tq/manifest.go | NewUploadAdapter | func (m *Manifest) NewUploadAdapter(name string) Adapter {
return m.NewAdapterOrDefault(name, Upload)
} | go | func (m *Manifest) NewUploadAdapter(name string) Adapter {
return m.NewAdapterOrDefault(name, Upload)
} | [
"func",
"(",
"m",
"*",
"Manifest",
")",
"NewUploadAdapter",
"(",
"name",
"string",
")",
"Adapter",
"{",
"return",
"m",
".",
"NewAdapterOrDefault",
"(",
"name",
",",
"Upload",
")",
"\n",
"}"
] | // Create a new upload adapter by name, or BasicAdapterName if doesn't exist | [
"Create",
"a",
"new",
"upload",
"adapter",
"by",
"name",
"or",
"BasicAdapterName",
"if",
"doesn",
"t",
"exist"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tq/manifest.go#L212-L214 |
157,449 | git-lfs/git-lfs | git/config.go | NewReadOnlyConfig | func NewReadOnlyConfig(workdir, gitdir string) *Configuration {
cfg := NewConfig(workdir, gitdir)
cfg.readOnly = true
return cfg
} | go | func NewReadOnlyConfig(workdir, gitdir string) *Configuration {
cfg := NewConfig(workdir, gitdir)
cfg.readOnly = true
return cfg
} | [
"func",
"NewReadOnlyConfig",
"(",
"workdir",
",",
"gitdir",
"string",
")",
"*",
"Configuration",
"{",
"cfg",
":=",
"NewConfig",
"(",
"workdir",
",",
"gitdir",
")",
"\n",
"cfg",
".",
"readOnly",
"=",
"true",
"\n",
"return",
"cfg",
"\n\n",
"}"
] | // NewReadOnlyConfig creates a new confguration that returns an error if an
// attempt to write to the configuration is made. | [
"NewReadOnlyConfig",
"creates",
"a",
"new",
"confguration",
"that",
"returns",
"an",
"error",
"if",
"an",
"attempt",
"to",
"write",
"to",
"the",
"configuration",
"is",
"made",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/config.go#L36-L41 |
157,450 | git-lfs/git-lfs | git/config.go | FindGlobal | func (c *Configuration) FindGlobal(key string) string {
output, _ := c.gitConfig("--global", key)
return output
} | go | func (c *Configuration) FindGlobal(key string) string {
output, _ := c.gitConfig("--global", key)
return output
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"FindGlobal",
"(",
"key",
"string",
")",
"string",
"{",
"output",
",",
"_",
":=",
"c",
".",
"gitConfig",
"(",
"\"",
"\"",
",",
"key",
")",
"\n",
"return",
"output",
"\n",
"}"
] | // FindGlobal returns the git config value global scope for the key | [
"FindGlobal",
"returns",
"the",
"git",
"config",
"value",
"global",
"scope",
"for",
"the",
"key"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/config.go#L62-L65 |
157,451 | git-lfs/git-lfs | git/config.go | FindSystem | func (c *Configuration) FindSystem(key string) string {
output, _ := c.gitConfig("--system", key)
return output
} | go | func (c *Configuration) FindSystem(key string) string {
output, _ := c.gitConfig("--system", key)
return output
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"FindSystem",
"(",
"key",
"string",
")",
"string",
"{",
"output",
",",
"_",
":=",
"c",
".",
"gitConfig",
"(",
"\"",
"\"",
",",
"key",
")",
"\n",
"return",
"output",
"\n",
"}"
] | // FindSystem returns the git config value in system scope for the key | [
"FindSystem",
"returns",
"the",
"git",
"config",
"value",
"in",
"system",
"scope",
"for",
"the",
"key"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/config.go#L68-L71 |
157,452 | git-lfs/git-lfs | git/config.go | SetGlobal | func (c *Configuration) SetGlobal(key, val string) (string, error) {
return c.gitConfigWrite("--global", "--replace-all", key, val)
} | go | func (c *Configuration) SetGlobal(key, val string) (string, error) {
return c.gitConfigWrite("--global", "--replace-all", key, val)
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"SetGlobal",
"(",
"key",
",",
"val",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"c",
".",
"gitConfigWrite",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"key",
",",
"val",
")",
"\n",
"}"... | // SetGlobal sets the git config value for the key in the global config | [
"SetGlobal",
"sets",
"the",
"git",
"config",
"value",
"for",
"the",
"key",
"in",
"the",
"global",
"config"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/config.go#L80-L82 |
157,453 | git-lfs/git-lfs | git/config.go | SetSystem | func (c *Configuration) SetSystem(key, val string) (string, error) {
return c.gitConfigWrite("--system", "--replace-all", key, val)
} | go | func (c *Configuration) SetSystem(key, val string) (string, error) {
return c.gitConfigWrite("--system", "--replace-all", key, val)
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"SetSystem",
"(",
"key",
",",
"val",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"c",
".",
"gitConfigWrite",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"key",
",",
"val",
")",
"\n",
"}"... | // SetSystem sets the git config value for the key in the system config | [
"SetSystem",
"sets",
"the",
"git",
"config",
"value",
"for",
"the",
"key",
"in",
"the",
"system",
"config"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/config.go#L85-L87 |
157,454 | git-lfs/git-lfs | git/config.go | UnsetGlobalSection | func (c *Configuration) UnsetGlobalSection(key string) (string, error) {
return c.gitConfigWrite("--global", "--remove-section", key)
} | go | func (c *Configuration) UnsetGlobalSection(key string) (string, error) {
return c.gitConfigWrite("--global", "--remove-section", key)
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"UnsetGlobalSection",
"(",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"c",
".",
"gitConfigWrite",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"key",
")",
"\n",
"}"
] | // UnsetGlobalSection removes the entire named section from the global config | [
"UnsetGlobalSection",
"removes",
"the",
"entire",
"named",
"section",
"from",
"the",
"global",
"config"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/config.go#L90-L92 |
157,455 | git-lfs/git-lfs | git/config.go | UnsetSystemSection | func (c *Configuration) UnsetSystemSection(key string) (string, error) {
return c.gitConfigWrite("--system", "--remove-section", key)
} | go | func (c *Configuration) UnsetSystemSection(key string) (string, error) {
return c.gitConfigWrite("--system", "--remove-section", key)
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"UnsetSystemSection",
"(",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"c",
".",
"gitConfigWrite",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"key",
")",
"\n",
"}"
] | // UnsetSystemSection removes the entire named section from the system config | [
"UnsetSystemSection",
"removes",
"the",
"entire",
"named",
"section",
"from",
"the",
"system",
"config"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/config.go#L95-L97 |
157,456 | git-lfs/git-lfs | git/config.go | UnsetLocalSection | func (c *Configuration) UnsetLocalSection(key string) (string, error) {
return c.gitConfigWrite("--local", "--remove-section", key)
} | go | func (c *Configuration) UnsetLocalSection(key string) (string, error) {
return c.gitConfigWrite("--local", "--remove-section", key)
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"UnsetLocalSection",
"(",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"c",
".",
"gitConfigWrite",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"key",
")",
"\n",
"}"
] | // UnsetLocalSection removes the entire named section from the system config | [
"UnsetLocalSection",
"removes",
"the",
"entire",
"named",
"section",
"from",
"the",
"system",
"config"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/config.go#L100-L102 |
157,457 | git-lfs/git-lfs | git/config.go | SetLocal | func (c *Configuration) SetLocal(key, val string) (string, error) {
return c.gitConfigWrite("--replace-all", key, val)
} | go | func (c *Configuration) SetLocal(key, val string) (string, error) {
return c.gitConfigWrite("--replace-all", key, val)
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"SetLocal",
"(",
"key",
",",
"val",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"c",
".",
"gitConfigWrite",
"(",
"\"",
"\"",
",",
"key",
",",
"val",
")",
"\n",
"}"
] | // SetLocal sets the git config value for the key in the specified config file | [
"SetLocal",
"sets",
"the",
"git",
"config",
"value",
"for",
"the",
"key",
"in",
"the",
"specified",
"config",
"file"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/config.go#L105-L107 |
157,458 | git-lfs/git-lfs | git/config.go | UnsetLocalKey | func (c *Configuration) UnsetLocalKey(key string) (string, error) {
return c.gitConfigWrite("--unset", key)
} | go | func (c *Configuration) UnsetLocalKey(key string) (string, error) {
return c.gitConfigWrite("--unset", key)
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"UnsetLocalKey",
"(",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"c",
".",
"gitConfigWrite",
"(",
"\"",
"\"",
",",
"key",
")",
"\n",
"}"
] | // UnsetLocalKey removes the git config value for the key from the specified config file | [
"UnsetLocalKey",
"removes",
"the",
"git",
"config",
"value",
"for",
"the",
"key",
"from",
"the",
"specified",
"config",
"file"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/config.go#L110-L112 |
157,459 | git-lfs/git-lfs | git/gitattr/macro.go | NewMacroProcessor | func NewMacroProcessor() *MacroProcessor {
macros := make(map[string][]*Attr)
// This is built into Git.
macros["binary"] = []*Attr{
&Attr{K: "diff", V: "false"},
&Attr{K: "merge", V: "false"},
&Attr{K: "text", V: "false"},
}
return &MacroProcessor{
macros: macros,
}
} | go | func NewMacroProcessor() *MacroProcessor {
macros := make(map[string][]*Attr)
// This is built into Git.
macros["binary"] = []*Attr{
&Attr{K: "diff", V: "false"},
&Attr{K: "merge", V: "false"},
&Attr{K: "text", V: "false"},
}
return &MacroProcessor{
macros: macros,
}
} | [
"func",
"NewMacroProcessor",
"(",
")",
"*",
"MacroProcessor",
"{",
"macros",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"*",
"Attr",
")",
"\n\n",
"// This is built into Git.",
"macros",
"[",
"\"",
"\"",
"]",
"=",
"[",
"]",
"*",
"Attr",
"{"... | // NewMacroProcessor returns a new MacroProcessor object for parsing macros. | [
"NewMacroProcessor",
"returns",
"a",
"new",
"MacroProcessor",
"object",
"for",
"parsing",
"macros",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/gitattr/macro.go#L8-L21 |
157,460 | git-lfs/git-lfs | git/gitattr/macro.go | ProcessLines | func (mp *MacroProcessor) ProcessLines(lines []*Line, readMacros bool) []*Line {
result := make([]*Line, 0, len(lines))
for _, line := range lines {
if line.Pattern != nil {
resultLine := Line{
Pattern: line.Pattern,
Attrs: make([]*Attr, 0, len(line.Attrs)),
}
for _, attr := range line.Attrs {
macros := mp.macros[attr.K]
if attr.V == "true" && macros != nil {
resultLine.Attrs = append(
resultLine.Attrs,
macros...,
)
}
// Git copies through aliases as well as
// expanding them.
resultLine.Attrs = append(
resultLine.Attrs,
attr,
)
}
result = append(result, &resultLine)
} else if readMacros {
mp.macros[line.Macro] = line.Attrs
}
}
return result
} | go | func (mp *MacroProcessor) ProcessLines(lines []*Line, readMacros bool) []*Line {
result := make([]*Line, 0, len(lines))
for _, line := range lines {
if line.Pattern != nil {
resultLine := Line{
Pattern: line.Pattern,
Attrs: make([]*Attr, 0, len(line.Attrs)),
}
for _, attr := range line.Attrs {
macros := mp.macros[attr.K]
if attr.V == "true" && macros != nil {
resultLine.Attrs = append(
resultLine.Attrs,
macros...,
)
}
// Git copies through aliases as well as
// expanding them.
resultLine.Attrs = append(
resultLine.Attrs,
attr,
)
}
result = append(result, &resultLine)
} else if readMacros {
mp.macros[line.Macro] = line.Attrs
}
}
return result
} | [
"func",
"(",
"mp",
"*",
"MacroProcessor",
")",
"ProcessLines",
"(",
"lines",
"[",
"]",
"*",
"Line",
",",
"readMacros",
"bool",
")",
"[",
"]",
"*",
"Line",
"{",
"result",
":=",
"make",
"(",
"[",
"]",
"*",
"Line",
",",
"0",
",",
"len",
"(",
"lines"... | // ProcessLines reads the specified lines, returning a new set of lines which
// all have a valid pattern. If readMacros is true, it additionally loads any
// macro lines as it reads them. | [
"ProcessLines",
"reads",
"the",
"specified",
"lines",
"returning",
"a",
"new",
"set",
"of",
"lines",
"which",
"all",
"have",
"a",
"valid",
"pattern",
".",
"If",
"readMacros",
"is",
"true",
"it",
"additionally",
"loads",
"any",
"macro",
"lines",
"as",
"it",
... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/gitattr/macro.go#L26-L56 |
157,461 | git-lfs/git-lfs | tasklog/task.go | Throttled | func (u *Update) Throttled(next time.Time) bool {
return !(u.Force || u.At.After(next))
} | go | func (u *Update) Throttled(next time.Time) bool {
return !(u.Force || u.At.After(next))
} | [
"func",
"(",
"u",
"*",
"Update",
")",
"Throttled",
"(",
"next",
"time",
".",
"Time",
")",
"bool",
"{",
"return",
"!",
"(",
"u",
".",
"Force",
"||",
"u",
".",
"At",
".",
"After",
"(",
"next",
")",
")",
"\n",
"}"
] | // Throttled determines whether this update should be throttled, based on the
// given earliest time of the next update. The caller should determine how often
// updates should be throttled. An Update with Force=true is never throttled. | [
"Throttled",
"determines",
"whether",
"this",
"update",
"should",
"be",
"throttled",
"based",
"on",
"the",
"given",
"earliest",
"time",
"of",
"the",
"next",
"update",
".",
"The",
"caller",
"should",
"determine",
"how",
"often",
"updates",
"should",
"be",
"thro... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tasklog/task.go#L33-L35 |
157,462 | git-lfs/git-lfs | lfsapi/ntlm.go | ntlmReAuth | func (c *Client) ntlmReAuth(req *http.Request, credHelper creds.CredentialHelper, creds creds.Creds, retry bool) (*http.Response, error) {
ntmlCreds, err := ntlmGetCredentials(creds)
if err != nil {
return nil, err
}
res, err := c.ntlmAuthenticateRequest(req, ntmlCreds)
if err != nil && !errors.IsAuthError(err) {
return res, err
}
switch res.StatusCode {
case 401:
credHelper.Reject(creds)
if retry {
return c.ntlmReAuth(req, credHelper, creds, false)
}
case 403:
credHelper.Reject(creds)
default:
if res.StatusCode < 300 && res.StatusCode > 199 {
credHelper.Approve(creds)
}
}
return res, nil
} | go | func (c *Client) ntlmReAuth(req *http.Request, credHelper creds.CredentialHelper, creds creds.Creds, retry bool) (*http.Response, error) {
ntmlCreds, err := ntlmGetCredentials(creds)
if err != nil {
return nil, err
}
res, err := c.ntlmAuthenticateRequest(req, ntmlCreds)
if err != nil && !errors.IsAuthError(err) {
return res, err
}
switch res.StatusCode {
case 401:
credHelper.Reject(creds)
if retry {
return c.ntlmReAuth(req, credHelper, creds, false)
}
case 403:
credHelper.Reject(creds)
default:
if res.StatusCode < 300 && res.StatusCode > 199 {
credHelper.Approve(creds)
}
}
return res, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ntlmReAuth",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"credHelper",
"creds",
".",
"CredentialHelper",
",",
"creds",
"creds",
".",
"Creds",
",",
"retry",
"bool",
")",
"(",
"*",
"http",
".",
"Response",
",",
... | // If the status is 401 then we need to re-authenticate | [
"If",
"the",
"status",
"is",
"401",
"then",
"we",
"need",
"to",
"re",
"-",
"authenticate"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfsapi/ntlm.go#L36-L62 |
157,463 | git-lfs/git-lfs | lfs/attribute.go | normalizeKey | func (a *Attribute) normalizeKey(relative string) string {
return strings.Join([]string{a.Section, relative}, ".")
} | go | func (a *Attribute) normalizeKey(relative string) string {
return strings.Join([]string{a.Section, relative}, ".")
} | [
"func",
"(",
"a",
"*",
"Attribute",
")",
"normalizeKey",
"(",
"relative",
"string",
")",
"string",
"{",
"return",
"strings",
".",
"Join",
"(",
"[",
"]",
"string",
"{",
"a",
".",
"Section",
",",
"relative",
"}",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // normalizeKey makes an absolute path out of a partial relative one. For a
// relative path of "foo", and a root Section of "bar", "bar.foo" will be returned. | [
"normalizeKey",
"makes",
"an",
"absolute",
"path",
"out",
"of",
"a",
"partial",
"relative",
"one",
".",
"For",
"a",
"relative",
"path",
"of",
"foo",
"and",
"a",
"root",
"Section",
"of",
"bar",
"bar",
".",
"foo",
"will",
"be",
"returned",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/attribute.go#L128-L130 |
157,464 | git-lfs/git-lfs | lfs/attribute.go | Uninstall | func (a *Attribute) Uninstall(opt *FilterOptions) {
if opt.Local {
opt.GitConfig.UnsetLocalSection(a.Section)
} else if opt.System {
opt.GitConfig.UnsetSystemSection(a.Section)
} else {
opt.GitConfig.UnsetGlobalSection(a.Section)
}
} | go | func (a *Attribute) Uninstall(opt *FilterOptions) {
if opt.Local {
opt.GitConfig.UnsetLocalSection(a.Section)
} else if opt.System {
opt.GitConfig.UnsetSystemSection(a.Section)
} else {
opt.GitConfig.UnsetGlobalSection(a.Section)
}
} | [
"func",
"(",
"a",
"*",
"Attribute",
")",
"Uninstall",
"(",
"opt",
"*",
"FilterOptions",
")",
"{",
"if",
"opt",
".",
"Local",
"{",
"opt",
".",
"GitConfig",
".",
"UnsetLocalSection",
"(",
"a",
".",
"Section",
")",
"\n",
"}",
"else",
"if",
"opt",
".",
... | // Uninstall removes all properties in the path of this property. | [
"Uninstall",
"removes",
"all",
"properties",
"in",
"the",
"path",
"of",
"this",
"property",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/attribute.go#L165-L173 |
157,465 | git-lfs/git-lfs | commands/lockverifier.go | Contains | func (lv *lockVerifier) Contains(name string) bool {
if lv == nil {
return false
}
_, ok := lv.theirLocks[name]
return ok
} | go | func (lv *lockVerifier) Contains(name string) bool {
if lv == nil {
return false
}
_, ok := lv.theirLocks[name]
return ok
} | [
"func",
"(",
"lv",
"*",
"lockVerifier",
")",
"Contains",
"(",
"name",
"string",
")",
"bool",
"{",
"if",
"lv",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"_",
",",
"ok",
":=",
"lv",
".",
"theirLocks",
"[",
"name",
"]",
"\n",
"return",
"... | // Determines if a filename is lockable. Implements lfs.GitScannerSet | [
"Determines",
"if",
"a",
"filename",
"is",
"lockable",
".",
"Implements",
"lfs",
".",
"GitScannerSet"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/commands/lockverifier.go#L101-L107 |
157,466 | git-lfs/git-lfs | commands/lockverifier.go | getVerifyStateFor | func getVerifyStateFor(rawurl string) verifyState {
uc := config.NewURLConfig(cfg.Git)
v, ok := uc.Get("lfs", rawurl, "locksverify")
if !ok {
if supportsLockingAPI(rawurl) {
return verifyStateEnabled
}
return verifyStateUnknown
}
if enabled, _ := strconv.ParseBool(v); enabled {
return verifyStateEnabled
}
return verifyStateDisabled
} | go | func getVerifyStateFor(rawurl string) verifyState {
uc := config.NewURLConfig(cfg.Git)
v, ok := uc.Get("lfs", rawurl, "locksverify")
if !ok {
if supportsLockingAPI(rawurl) {
return verifyStateEnabled
}
return verifyStateUnknown
}
if enabled, _ := strconv.ParseBool(v); enabled {
return verifyStateEnabled
}
return verifyStateDisabled
} | [
"func",
"getVerifyStateFor",
"(",
"rawurl",
"string",
")",
"verifyState",
"{",
"uc",
":=",
"config",
".",
"NewURLConfig",
"(",
"cfg",
".",
"Git",
")",
"\n\n",
"v",
",",
"ok",
":=",
"uc",
".",
"Get",
"(",
"\"",
"\"",
",",
"rawurl",
",",
"\"",
"\"",
... | // getVerifyStateFor returns whether or not lock verification is enabled for the
// given url. If no state has been explicitly set, an "unknown" state will be
// returned instead. | [
"getVerifyStateFor",
"returns",
"whether",
"or",
"not",
"lock",
"verification",
"is",
"enabled",
"for",
"the",
"given",
"url",
".",
"If",
"no",
"state",
"has",
"been",
"explicitly",
"set",
"an",
"unknown",
"state",
"will",
"be",
"returned",
"instead",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/commands/lockverifier.go#L229-L244 |
157,467 | git-lfs/git-lfs | tq/basic_download.go | checkResumeDownload | func (a *basicDownloadAdapter) checkResumeDownload(t *Transfer) (outFile *os.File, fromByte int64, hashSoFar hash.Hash, e error) {
// lock the file by opening it for read/write, rather than checking Stat() etc
// which could be subject to race conditions by other processes
f, err := os.OpenFile(a.downloadFilename(t), os.O_RDWR, 0644)
if err != nil {
// Create a new file instead, must not already exist or error (permissions / race condition)
newfile, err := os.OpenFile(a.downloadFilename(t), os.O_CREATE|os.O_WRONLY|os.O_EXCL, 0644)
return newfile, 0, nil, err
}
// Successfully opened an existing file at this point
// Read any existing data into hash then return file handle at end
hash := tools.NewLfsContentHash()
n, err := io.Copy(hash, f)
if err != nil {
f.Close()
return nil, 0, nil, err
}
tracerx.Printf("xfer: Attempting to resume download of %q from byte %d", t.Oid, n)
return f, n, hash, nil
} | go | func (a *basicDownloadAdapter) checkResumeDownload(t *Transfer) (outFile *os.File, fromByte int64, hashSoFar hash.Hash, e error) {
// lock the file by opening it for read/write, rather than checking Stat() etc
// which could be subject to race conditions by other processes
f, err := os.OpenFile(a.downloadFilename(t), os.O_RDWR, 0644)
if err != nil {
// Create a new file instead, must not already exist or error (permissions / race condition)
newfile, err := os.OpenFile(a.downloadFilename(t), os.O_CREATE|os.O_WRONLY|os.O_EXCL, 0644)
return newfile, 0, nil, err
}
// Successfully opened an existing file at this point
// Read any existing data into hash then return file handle at end
hash := tools.NewLfsContentHash()
n, err := io.Copy(hash, f)
if err != nil {
f.Close()
return nil, 0, nil, err
}
tracerx.Printf("xfer: Attempting to resume download of %q from byte %d", t.Oid, n)
return f, n, hash, nil
} | [
"func",
"(",
"a",
"*",
"basicDownloadAdapter",
")",
"checkResumeDownload",
"(",
"t",
"*",
"Transfer",
")",
"(",
"outFile",
"*",
"os",
".",
"File",
",",
"fromByte",
"int64",
",",
"hashSoFar",
"hash",
".",
"Hash",
",",
"e",
"error",
")",
"{",
"// lock the ... | // Checks to see if a download can be resumed, and if so returns a non-nil locked file, byte start and hash | [
"Checks",
"to",
"see",
"if",
"a",
"download",
"can",
"be",
"resumed",
"and",
"if",
"so",
"returns",
"a",
"non",
"-",
"nil",
"locked",
"file",
"byte",
"start",
"and",
"hash"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tq/basic_download.go#L53-L75 |
157,468 | git-lfs/git-lfs | tq/basic_download.go | downloadFilename | func (a *basicDownloadAdapter) downloadFilename(t *Transfer) string {
// Not a temp file since we will be resuming it
return filepath.Join(a.tempDir(), t.Oid+".tmp")
} | go | func (a *basicDownloadAdapter) downloadFilename(t *Transfer) string {
// Not a temp file since we will be resuming it
return filepath.Join(a.tempDir(), t.Oid+".tmp")
} | [
"func",
"(",
"a",
"*",
"basicDownloadAdapter",
")",
"downloadFilename",
"(",
"t",
"*",
"Transfer",
")",
"string",
"{",
"// Not a temp file since we will be resuming it",
"return",
"filepath",
".",
"Join",
"(",
"a",
".",
"tempDir",
"(",
")",
",",
"t",
".",
"Oid... | // Create or open a download file for resuming | [
"Create",
"or",
"open",
"a",
"download",
"file",
"for",
"resuming"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/tq/basic_download.go#L78-L81 |
157,469 | git-lfs/git-lfs | errors/types.go | IsFatalError | func IsFatalError(err error) bool {
if e, ok := err.(interface {
Fatal() bool
}); ok {
return e.Fatal()
}
if parent := parentOf(err); parent != nil {
return IsFatalError(parent)
}
return false
} | go | func IsFatalError(err error) bool {
if e, ok := err.(interface {
Fatal() bool
}); ok {
return e.Fatal()
}
if parent := parentOf(err); parent != nil {
return IsFatalError(parent)
}
return false
} | [
"func",
"IsFatalError",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"interface",
"{",
"Fatal",
"(",
")",
"bool",
"\n",
"}",
")",
";",
"ok",
"{",
"return",
"e",
".",
"Fatal",
"(",
")",
"\n",
"}",
"\n",
"... | // IsFatalError indicates that the error is fatal and the process should exit
// immediately after handling the error. | [
"IsFatalError",
"indicates",
"that",
"the",
"error",
"is",
"fatal",
"and",
"the",
"process",
"should",
"exit",
"immediately",
"after",
"handling",
"the",
"error",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/types.go#L14-L24 |
157,470 | git-lfs/git-lfs | errors/types.go | IsSmudgeError | func IsSmudgeError(err error) bool {
if e, ok := err.(interface {
SmudgeError() bool
}); ok {
return e.SmudgeError()
}
if parent := parentOf(err); parent != nil {
return IsSmudgeError(parent)
}
return false
} | go | func IsSmudgeError(err error) bool {
if e, ok := err.(interface {
SmudgeError() bool
}); ok {
return e.SmudgeError()
}
if parent := parentOf(err); parent != nil {
return IsSmudgeError(parent)
}
return false
} | [
"func",
"IsSmudgeError",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"interface",
"{",
"SmudgeError",
"(",
")",
"bool",
"\n",
"}",
")",
";",
"ok",
"{",
"return",
"e",
".",
"SmudgeError",
"(",
")",
"\n",
"}"... | // IsSmudgeError indicates an error while smudging a files. | [
"IsSmudgeError",
"indicates",
"an",
"error",
"while",
"smudging",
"a",
"files",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/types.go#L55-L65 |
157,471 | git-lfs/git-lfs | errors/types.go | IsCleanPointerError | func IsCleanPointerError(err error) bool {
if e, ok := err.(interface {
CleanPointerError() bool
}); ok {
return e.CleanPointerError()
}
if parent := parentOf(err); parent != nil {
return IsCleanPointerError(parent)
}
return false
} | go | func IsCleanPointerError(err error) bool {
if e, ok := err.(interface {
CleanPointerError() bool
}); ok {
return e.CleanPointerError()
}
if parent := parentOf(err); parent != nil {
return IsCleanPointerError(parent)
}
return false
} | [
"func",
"IsCleanPointerError",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"interface",
"{",
"CleanPointerError",
"(",
")",
"bool",
"\n",
"}",
")",
";",
"ok",
"{",
"return",
"e",
".",
"CleanPointerError",
"(",
... | // IsCleanPointerError indicates an error while cleaning a file. | [
"IsCleanPointerError",
"indicates",
"an",
"error",
"while",
"cleaning",
"a",
"file",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/types.go#L68-L78 |
157,472 | git-lfs/git-lfs | errors/types.go | IsNotAPointerError | func IsNotAPointerError(err error) bool {
if e, ok := err.(interface {
NotAPointerError() bool
}); ok {
return e.NotAPointerError()
}
if parent := parentOf(err); parent != nil {
return IsNotAPointerError(parent)
}
return false
} | go | func IsNotAPointerError(err error) bool {
if e, ok := err.(interface {
NotAPointerError() bool
}); ok {
return e.NotAPointerError()
}
if parent := parentOf(err); parent != nil {
return IsNotAPointerError(parent)
}
return false
} | [
"func",
"IsNotAPointerError",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"interface",
"{",
"NotAPointerError",
"(",
")",
"bool",
"\n",
"}",
")",
";",
"ok",
"{",
"return",
"e",
".",
"NotAPointerError",
"(",
")"... | // IsNotAPointerError indicates the parsed data is not an LFS pointer. | [
"IsNotAPointerError",
"indicates",
"the",
"parsed",
"data",
"is",
"not",
"an",
"LFS",
"pointer",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/types.go#L81-L91 |
157,473 | git-lfs/git-lfs | errors/types.go | IsBadPointerKeyError | func IsBadPointerKeyError(err error) bool {
if e, ok := err.(interface {
BadPointerKeyError() bool
}); ok {
return e.BadPointerKeyError()
}
if parent := parentOf(err); parent != nil {
return IsBadPointerKeyError(parent)
}
return false
} | go | func IsBadPointerKeyError(err error) bool {
if e, ok := err.(interface {
BadPointerKeyError() bool
}); ok {
return e.BadPointerKeyError()
}
if parent := parentOf(err); parent != nil {
return IsBadPointerKeyError(parent)
}
return false
} | [
"func",
"IsBadPointerKeyError",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"interface",
"{",
"BadPointerKeyError",
"(",
")",
"bool",
"\n",
"}",
")",
";",
"ok",
"{",
"return",
"e",
".",
"BadPointerKeyError",
"(",... | // IsBadPointerKeyError indicates that the parsed data has an invalid key. | [
"IsBadPointerKeyError",
"indicates",
"that",
"the",
"parsed",
"data",
"has",
"an",
"invalid",
"key",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/types.go#L94-L105 |
157,474 | git-lfs/git-lfs | errors/types.go | StandardizeBadPointerError | func StandardizeBadPointerError(err error) error {
if IsBadPointerKeyError(err) {
badErr := err.(badPointerKeyError)
if badErr.Expected == "version" {
return NewNotAPointerError(err)
}
}
return err
} | go | func StandardizeBadPointerError(err error) error {
if IsBadPointerKeyError(err) {
badErr := err.(badPointerKeyError)
if badErr.Expected == "version" {
return NewNotAPointerError(err)
}
}
return err
} | [
"func",
"StandardizeBadPointerError",
"(",
"err",
"error",
")",
"error",
"{",
"if",
"IsBadPointerKeyError",
"(",
"err",
")",
"{",
"badErr",
":=",
"err",
".",
"(",
"badPointerKeyError",
")",
"\n",
"if",
"badErr",
".",
"Expected",
"==",
"\"",
"\"",
"{",
"ret... | // If an error is abad pointer error of any type, returns NotAPointerError | [
"If",
"an",
"error",
"is",
"abad",
"pointer",
"error",
"of",
"any",
"type",
"returns",
"NotAPointerError"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/types.go#L108-L116 |
157,475 | git-lfs/git-lfs | errors/types.go | IsUnprocessableEntityError | func IsUnprocessableEntityError(err error) bool {
if e, ok := err.(interface {
UnprocessableEntityError() bool
}); ok {
return e.UnprocessableEntityError()
}
if parent := parentOf(err); parent != nil {
return IsUnprocessableEntityError(parent)
}
return false
} | go | func IsUnprocessableEntityError(err error) bool {
if e, ok := err.(interface {
UnprocessableEntityError() bool
}); ok {
return e.UnprocessableEntityError()
}
if parent := parentOf(err); parent != nil {
return IsUnprocessableEntityError(parent)
}
return false
} | [
"func",
"IsUnprocessableEntityError",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"interface",
"{",
"UnprocessableEntityError",
"(",
")",
"bool",
"\n",
"}",
")",
";",
"ok",
"{",
"return",
"e",
".",
"UnprocessableEn... | // IsDownloadDeclinedError indicates that the upload operation failed because of
// an HTTP 422 response code. | [
"IsDownloadDeclinedError",
"indicates",
"that",
"the",
"upload",
"operation",
"failed",
"because",
"of",
"an",
"HTTP",
"422",
"response",
"code",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/types.go#L134-L144 |
157,476 | git-lfs/git-lfs | errors/types.go | IsRetriableError | func IsRetriableError(err error) bool {
if e, ok := err.(interface {
RetriableError() bool
}); ok {
return e.RetriableError()
}
if cause, ok := Cause(err).(*url.Error); ok {
return cause.Temporary() || cause.Timeout()
}
if parent := parentOf(err); parent != nil {
return IsRetriableError(parent)
}
return false
} | go | func IsRetriableError(err error) bool {
if e, ok := err.(interface {
RetriableError() bool
}); ok {
return e.RetriableError()
}
if cause, ok := Cause(err).(*url.Error); ok {
return cause.Temporary() || cause.Timeout()
}
if parent := parentOf(err); parent != nil {
return IsRetriableError(parent)
}
return false
} | [
"func",
"IsRetriableError",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"interface",
"{",
"RetriableError",
"(",
")",
"bool",
"\n",
"}",
")",
";",
"ok",
"{",
"return",
"e",
".",
"RetriableError",
"(",
")",
"\... | // IsRetriableError indicates the low level transfer had an error but the
// caller may retry the operation. | [
"IsRetriableError",
"indicates",
"the",
"low",
"level",
"transfer",
"had",
"an",
"error",
"but",
"the",
"caller",
"may",
"retry",
"the",
"operation",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/types.go#L148-L161 |
157,477 | git-lfs/git-lfs | errors/types.go | newWrappedError | func newWrappedError(err error, message string) *wrappedError {
if err == nil {
err = errors.New("Error")
}
var errWithCause errorWithCause
if len(message) > 0 {
errWithCause = errors.Wrap(err, message).(errorWithCause)
} else if ewc, ok := err.(errorWithCause); ok {
errWithCause = ewc
} else {
errWithCause = errors.Wrap(err, "LFS").(errorWithCause)
}
return &wrappedError{
context: make(map[string]interface{}),
errorWithCause: errWithCause,
}
} | go | func newWrappedError(err error, message string) *wrappedError {
if err == nil {
err = errors.New("Error")
}
var errWithCause errorWithCause
if len(message) > 0 {
errWithCause = errors.Wrap(err, message).(errorWithCause)
} else if ewc, ok := err.(errorWithCause); ok {
errWithCause = ewc
} else {
errWithCause = errors.Wrap(err, "LFS").(errorWithCause)
}
return &wrappedError{
context: make(map[string]interface{}),
errorWithCause: errWithCause,
}
} | [
"func",
"newWrappedError",
"(",
"err",
"error",
",",
"message",
"string",
")",
"*",
"wrappedError",
"{",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"errWithCause",
"errorWithCause",
... | // newWrappedError creates a wrappedError. | [
"newWrappedError",
"creates",
"a",
"wrappedError",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/types.go#L190-L209 |
157,478 | git-lfs/git-lfs | errors/types.go | Set | func (e wrappedError) Set(key string, val interface{}) {
e.context[key] = val
} | go | func (e wrappedError) Set(key string, val interface{}) {
e.context[key] = val
} | [
"func",
"(",
"e",
"wrappedError",
")",
"Set",
"(",
"key",
"string",
",",
"val",
"interface",
"{",
"}",
")",
"{",
"e",
".",
"context",
"[",
"key",
"]",
"=",
"val",
"\n",
"}"
] | // Set sets the value for the key in the context. | [
"Set",
"sets",
"the",
"value",
"for",
"the",
"key",
"in",
"the",
"context",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/errors/types.go#L212-L214 |
157,479 | git-lfs/git-lfs | git/rev_list_scanner.go | Close | func (s *RevListScanner) Close() error {
if s.closeFn == nil {
return nil
}
return s.closeFn()
} | go | func (s *RevListScanner) Close() error {
if s.closeFn == nil {
return nil
}
return s.closeFn()
} | [
"func",
"(",
"s",
"*",
"RevListScanner",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"s",
".",
"closeFn",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"s",
".",
"closeFn",
"(",
")",
"\n",
"}"
] | // Close closes the RevListScanner by freeing any resources held by the
// instance while running, and returns any error encountered while doing so. | [
"Close",
"closes",
"the",
"RevListScanner",
"by",
"freeing",
"any",
"resources",
"held",
"by",
"the",
"instance",
"while",
"running",
"and",
"returns",
"any",
"error",
"encountered",
"while",
"doing",
"so",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/git/rev_list_scanner.go#L332-L337 |
157,480 | git-lfs/git-lfs | lfs/gitscanner.go | Close | func (s *GitScanner) Close() {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return
}
s.closed = true
tracerx.PerformanceSince("scan", s.started)
} | go | func (s *GitScanner) Close() {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return
}
s.closed = true
tracerx.PerformanceSince("scan", s.started)
} | [
"func",
"(",
"s",
"*",
"GitScanner",
")",
"Close",
"(",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"s",
".",
"closed",
"{",
"return",
"\n",
"}",
"\n\n",
"s",
".",
"... | // Close stops exits once all processing has stopped, and all resources are
// tracked and cleaned up. | [
"Close",
"stops",
"exits",
"once",
"all",
"processing",
"has",
"stopped",
"and",
"all",
"resources",
"are",
"tracked",
"and",
"cleaned",
"up",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/gitscanner.go#L50-L60 |
157,481 | git-lfs/git-lfs | lfs/gitscanner.go | ScanRefs | func (s *GitScanner) ScanRefs(include, exclude []string, cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
opts := s.opts(ScanRefsMode)
opts.SkipDeletedBlobs = false
return scanRefsToChan(s, callback, include, exclude, opts)
} | go | func (s *GitScanner) ScanRefs(include, exclude []string, cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
opts := s.opts(ScanRefsMode)
opts.SkipDeletedBlobs = false
return scanRefsToChan(s, callback, include, exclude, opts)
} | [
"func",
"(",
"s",
"*",
"GitScanner",
")",
"ScanRefs",
"(",
"include",
",",
"exclude",
"[",
"]",
"string",
",",
"cb",
"GitScannerFoundPointer",
")",
"error",
"{",
"callback",
",",
"err",
":=",
"firstGitScannerCallback",
"(",
"cb",
",",
"s",
".",
"FoundPoint... | // ScanRefs through all commits reachable by refs contained in "include" and
// not reachable by any refs included in "excluded" | [
"ScanRefs",
"through",
"all",
"commits",
"reachable",
"by",
"refs",
"contained",
"in",
"include",
"and",
"not",
"reachable",
"by",
"any",
"refs",
"included",
"in",
"excluded"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/gitscanner.go#L97-L106 |
157,482 | git-lfs/git-lfs | lfs/gitscanner.go | ScanRefRange | func (s *GitScanner) ScanRefRange(left, right string, cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
opts := s.opts(ScanRefsMode)
opts.SkipDeletedBlobs = false
return scanLeftRightToChan(s, callback, left, right, opts)
} | go | func (s *GitScanner) ScanRefRange(left, right string, cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
opts := s.opts(ScanRefsMode)
opts.SkipDeletedBlobs = false
return scanLeftRightToChan(s, callback, left, right, opts)
} | [
"func",
"(",
"s",
"*",
"GitScanner",
")",
"ScanRefRange",
"(",
"left",
",",
"right",
"string",
",",
"cb",
"GitScannerFoundPointer",
")",
"error",
"{",
"callback",
",",
"err",
":=",
"firstGitScannerCallback",
"(",
"cb",
",",
"s",
".",
"FoundPointer",
")",
"... | // ScanRefRange scans through all commits from the given left and right refs,
// including git objects that have been modified or deleted. | [
"ScanRefRange",
"scans",
"through",
"all",
"commits",
"from",
"the",
"given",
"left",
"and",
"right",
"refs",
"including",
"git",
"objects",
"that",
"have",
"been",
"modified",
"or",
"deleted",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/gitscanner.go#L110-L119 |
157,483 | git-lfs/git-lfs | lfs/gitscanner.go | ScanRefWithDeleted | func (s *GitScanner) ScanRefWithDeleted(ref string, cb GitScannerFoundPointer) error {
return s.ScanRefRange(ref, "", cb)
} | go | func (s *GitScanner) ScanRefWithDeleted(ref string, cb GitScannerFoundPointer) error {
return s.ScanRefRange(ref, "", cb)
} | [
"func",
"(",
"s",
"*",
"GitScanner",
")",
"ScanRefWithDeleted",
"(",
"ref",
"string",
",",
"cb",
"GitScannerFoundPointer",
")",
"error",
"{",
"return",
"s",
".",
"ScanRefRange",
"(",
"ref",
",",
"\"",
"\"",
",",
"cb",
")",
"\n",
"}"
] | // ScanRefWithDeleted scans through all objects in the given ref, including
// git objects that have been modified or deleted. | [
"ScanRefWithDeleted",
"scans",
"through",
"all",
"objects",
"in",
"the",
"given",
"ref",
"including",
"git",
"objects",
"that",
"have",
"been",
"modified",
"or",
"deleted",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/gitscanner.go#L123-L125 |
157,484 | git-lfs/git-lfs | lfs/gitscanner.go | ScanRef | func (s *GitScanner) ScanRef(ref string, cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
opts := s.opts(ScanRefsMode)
opts.SkipDeletedBlobs = true
return scanLeftRightToChan(s, callback, ref, "", opts)
} | go | func (s *GitScanner) ScanRef(ref string, cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
opts := s.opts(ScanRefsMode)
opts.SkipDeletedBlobs = true
return scanLeftRightToChan(s, callback, ref, "", opts)
} | [
"func",
"(",
"s",
"*",
"GitScanner",
")",
"ScanRef",
"(",
"ref",
"string",
",",
"cb",
"GitScannerFoundPointer",
")",
"error",
"{",
"callback",
",",
"err",
":=",
"firstGitScannerCallback",
"(",
"cb",
",",
"s",
".",
"FoundPointer",
")",
"\n",
"if",
"err",
... | // ScanRef scans through all objects in the current ref, excluding git objects
// that have been modified or deleted before the ref. | [
"ScanRef",
"scans",
"through",
"all",
"objects",
"in",
"the",
"current",
"ref",
"excluding",
"git",
"objects",
"that",
"have",
"been",
"modified",
"or",
"deleted",
"before",
"the",
"ref",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/gitscanner.go#L129-L138 |
157,485 | git-lfs/git-lfs | lfs/gitscanner.go | ScanAll | func (s *GitScanner) ScanAll(cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
opts := s.opts(ScanAllMode)
opts.SkipDeletedBlobs = false
return scanLeftRightToChan(s, callback, "", "", opts)
} | go | func (s *GitScanner) ScanAll(cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
opts := s.opts(ScanAllMode)
opts.SkipDeletedBlobs = false
return scanLeftRightToChan(s, callback, "", "", opts)
} | [
"func",
"(",
"s",
"*",
"GitScanner",
")",
"ScanAll",
"(",
"cb",
"GitScannerFoundPointer",
")",
"error",
"{",
"callback",
",",
"err",
":=",
"firstGitScannerCallback",
"(",
"cb",
",",
"s",
".",
"FoundPointer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ret... | // ScanAll scans through all objects in the git repository. | [
"ScanAll",
"scans",
"through",
"all",
"objects",
"in",
"the",
"git",
"repository",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/gitscanner.go#L141-L150 |
157,486 | git-lfs/git-lfs | lfs/gitscanner.go | ScanTree | func (s *GitScanner) ScanTree(ref string) error {
callback, err := firstGitScannerCallback(s.FoundPointer)
if err != nil {
return err
}
return runScanTree(callback, ref, s.Filter)
} | go | func (s *GitScanner) ScanTree(ref string) error {
callback, err := firstGitScannerCallback(s.FoundPointer)
if err != nil {
return err
}
return runScanTree(callback, ref, s.Filter)
} | [
"func",
"(",
"s",
"*",
"GitScanner",
")",
"ScanTree",
"(",
"ref",
"string",
")",
"error",
"{",
"callback",
",",
"err",
":=",
"firstGitScannerCallback",
"(",
"s",
".",
"FoundPointer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",... | // ScanTree takes a ref and returns WrappedPointer objects in the tree at that
// ref. Differs from ScanRefs in that multiple files in the tree with the same
// content are all reported. | [
"ScanTree",
"takes",
"a",
"ref",
"and",
"returns",
"WrappedPointer",
"objects",
"in",
"the",
"tree",
"at",
"that",
"ref",
".",
"Differs",
"from",
"ScanRefs",
"in",
"that",
"multiple",
"files",
"in",
"the",
"tree",
"with",
"the",
"same",
"content",
"are",
"... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/gitscanner.go#L155-L161 |
157,487 | git-lfs/git-lfs | lfs/gitscanner.go | ScanUnpushed | func (s *GitScanner) ScanUnpushed(remote string, cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
return scanUnpushed(callback, remote)
} | go | func (s *GitScanner) ScanUnpushed(remote string, cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
return scanUnpushed(callback, remote)
} | [
"func",
"(",
"s",
"*",
"GitScanner",
")",
"ScanUnpushed",
"(",
"remote",
"string",
",",
"cb",
"GitScannerFoundPointer",
")",
"error",
"{",
"callback",
",",
"err",
":=",
"firstGitScannerCallback",
"(",
"cb",
",",
"s",
".",
"FoundPointer",
")",
"\n",
"if",
"... | // ScanUnpushed scans history for all LFS pointers which have been added but not
// pushed to the named remote. remote can be left blank to mean 'any remote'. | [
"ScanUnpushed",
"scans",
"history",
"for",
"all",
"LFS",
"pointers",
"which",
"have",
"been",
"added",
"but",
"not",
"pushed",
"to",
"the",
"named",
"remote",
".",
"remote",
"can",
"be",
"left",
"blank",
"to",
"mean",
"any",
"remote",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/gitscanner.go#L165-L171 |
157,488 | git-lfs/git-lfs | lfs/gitscanner.go | ScanIndex | func (s *GitScanner) ScanIndex(ref string, cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
return scanIndex(callback, ref, s.Filter)
} | go | func (s *GitScanner) ScanIndex(ref string, cb GitScannerFoundPointer) error {
callback, err := firstGitScannerCallback(cb, s.FoundPointer)
if err != nil {
return err
}
return scanIndex(callback, ref, s.Filter)
} | [
"func",
"(",
"s",
"*",
"GitScanner",
")",
"ScanIndex",
"(",
"ref",
"string",
",",
"cb",
"GitScannerFoundPointer",
")",
"error",
"{",
"callback",
",",
"err",
":=",
"firstGitScannerCallback",
"(",
"cb",
",",
"s",
".",
"FoundPointer",
")",
"\n",
"if",
"err",
... | // ScanIndex scans the git index for modified LFS objects. | [
"ScanIndex",
"scans",
"the",
"git",
"index",
"for",
"modified",
"LFS",
"objects",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/gitscanner.go#L186-L192 |
157,489 | git-lfs/git-lfs | creds/netrc.go | newNetrcCredentialHelper | func newNetrcCredentialHelper(osEnv config.Environment) *netrcCredentialHelper {
netrcFinder, netrcfile, err := ParseNetrc(osEnv)
if err != nil {
tracerx.Printf("bad netrc file %s: %s", netrcfile, err)
return nil
}
if netrcFinder == nil {
netrcFinder = defaultNetrcFinder
}
return &netrcCredentialHelper{netrcFinder: netrcFinder, skip: make(map[string]bool)}
} | go | func newNetrcCredentialHelper(osEnv config.Environment) *netrcCredentialHelper {
netrcFinder, netrcfile, err := ParseNetrc(osEnv)
if err != nil {
tracerx.Printf("bad netrc file %s: %s", netrcfile, err)
return nil
}
if netrcFinder == nil {
netrcFinder = defaultNetrcFinder
}
return &netrcCredentialHelper{netrcFinder: netrcFinder, skip: make(map[string]bool)}
} | [
"func",
"newNetrcCredentialHelper",
"(",
"osEnv",
"config",
".",
"Environment",
")",
"*",
"netrcCredentialHelper",
"{",
"netrcFinder",
",",
"netrcfile",
",",
"err",
":=",
"ParseNetrc",
"(",
"osEnv",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"tracerx",
".",
"... | // NewNetrcCredentialHelper creates a new netrc credential helper using a
// .netrc file gleaned from the OS environment | [
"NewNetrcCredentialHelper",
"creates",
"a",
"new",
"netrc",
"credential",
"helper",
"using",
"a",
".",
"netrc",
"file",
"gleaned",
"from",
"the",
"OS",
"environment"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/creds/netrc.go#L49-L61 |
157,490 | git-lfs/git-lfs | lfs/util.go | NewRepoToCurrentPathConverter | func NewRepoToCurrentPathConverter(cfg *config.Configuration) (PathConverter, error) {
r, c, p, err := pathConverterArgs(cfg)
if err != nil {
return nil, err
}
return &repoToCurrentPathConverter{
repoDir: r,
currDir: c,
passthrough: p,
}, nil
} | go | func NewRepoToCurrentPathConverter(cfg *config.Configuration) (PathConverter, error) {
r, c, p, err := pathConverterArgs(cfg)
if err != nil {
return nil, err
}
return &repoToCurrentPathConverter{
repoDir: r,
currDir: c,
passthrough: p,
}, nil
} | [
"func",
"NewRepoToCurrentPathConverter",
"(",
"cfg",
"*",
"config",
".",
"Configuration",
")",
"(",
"PathConverter",
",",
"error",
")",
"{",
"r",
",",
"c",
",",
"p",
",",
"err",
":=",
"pathConverterArgs",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // Convert filenames expressed relative to the root of the repo relative to the
// current working dir. Useful when needing to calling git with results from a rooted command,
// but the user is in a subdir of their repo
// Pass in a channel which you will fill with relative files & receive a channel which will get results | [
"Convert",
"filenames",
"expressed",
"relative",
"to",
"the",
"root",
"of",
"the",
"repo",
"relative",
"to",
"the",
"current",
"working",
"dir",
".",
"Useful",
"when",
"needing",
"to",
"calling",
"git",
"with",
"results",
"from",
"a",
"rooted",
"command",
"b... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/util.go#L102-L113 |
157,491 | git-lfs/git-lfs | lfs/util.go | NewCurrentToRepoPathConverter | func NewCurrentToRepoPathConverter(cfg *config.Configuration) (PathConverter, error) {
r, c, p, err := pathConverterArgs(cfg)
if err != nil {
return nil, err
}
return ¤tToRepoPathConverter{
repoDir: r,
currDir: c,
passthrough: p,
}, nil
} | go | func NewCurrentToRepoPathConverter(cfg *config.Configuration) (PathConverter, error) {
r, c, p, err := pathConverterArgs(cfg)
if err != nil {
return nil, err
}
return ¤tToRepoPathConverter{
repoDir: r,
currDir: c,
passthrough: p,
}, nil
} | [
"func",
"NewCurrentToRepoPathConverter",
"(",
"cfg",
"*",
"config",
".",
"Configuration",
")",
"(",
"PathConverter",
",",
"error",
")",
"{",
"r",
",",
"c",
",",
"p",
",",
"err",
":=",
"pathConverterArgs",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // Convert filenames expressed relative to the current directory to be
// relative to the repo root. Useful when calling git with arguments that requires them
// to be rooted but the user is in a subdir of their repo & expects to use relative args
// Pass in a channel which you will fill with relative files & receive a channel which will get results | [
"Convert",
"filenames",
"expressed",
"relative",
"to",
"the",
"current",
"directory",
"to",
"be",
"relative",
"to",
"the",
"repo",
"root",
".",
"Useful",
"when",
"calling",
"git",
"with",
"arguments",
"that",
"requires",
"them",
"to",
"be",
"rooted",
"but",
... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfs/util.go#L139-L150 |
157,492 | git-lfs/git-lfs | config/os_fetcher.go | Get | func (o *OsFetcher) Get(key string) (val string, ok bool) {
o.vmu.Lock()
defer o.vmu.Unlock()
if i, ok := o.vals[key]; ok {
if i == nil {
return "", false
}
return *i, true
}
v, ok := os.LookupEnv(key)
if ok {
o.vals[key] = &v
} else {
o.vals[key] = nil
}
return v, ok
} | go | func (o *OsFetcher) Get(key string) (val string, ok bool) {
o.vmu.Lock()
defer o.vmu.Unlock()
if i, ok := o.vals[key]; ok {
if i == nil {
return "", false
}
return *i, true
}
v, ok := os.LookupEnv(key)
if ok {
o.vals[key] = &v
} else {
o.vals[key] = nil
}
return v, ok
} | [
"func",
"(",
"o",
"*",
"OsFetcher",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"val",
"string",
",",
"ok",
"bool",
")",
"{",
"o",
".",
"vmu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"o",
".",
"vmu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"i",
... | // Get returns the value associated with the given key as stored in the local
// cache, or in the operating system's environment variables.
//
// If there was a cache-hit, the value will be returned from the cache, skipping
// a check against os.Getenv. Otherwise, the value will be fetched from the
// system, stored in the cache, and then returned. If no value was present in
// the cache or in the system, an empty string will be returned.
//
// Get is safe to call across multiple goroutines. | [
"Get",
"returns",
"the",
"value",
"associated",
"with",
"the",
"given",
"key",
"as",
"stored",
"in",
"the",
"local",
"cache",
"or",
"in",
"the",
"operating",
"system",
"s",
"environment",
"variables",
".",
"If",
"there",
"was",
"a",
"cache",
"-",
"hit",
... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/config/os_fetcher.go#L36-L55 |
157,493 | git-lfs/git-lfs | commands/run.go | Run | func Run() int {
log.SetOutput(ErrorWriter)
root := NewCommand("git-lfs", gitlfsCommand)
root.PreRun = nil
// Set up help/usage funcs based on manpage text
helpcmd := &cobra.Command{
Use: "help [command]",
Short: "Help about any command",
Long: `Help provides help for any command in the application.
Simply type ` + root.Name() + ` help [path to command] for full details.`,
Run: func(c *cobra.Command, args []string) {
cmd, _, e := c.Root().Find(args)
if cmd == nil || e != nil {
c.Printf("Unknown help topic %#q\n", args)
c.Root().Usage()
} else {
c.HelpFunc()(cmd, args)
}
},
}
root.SetHelpCommand(helpcmd)
root.SetHelpTemplate("{{.UsageString}}")
root.SetHelpFunc(helpCommand)
root.SetUsageFunc(usageCommand)
root.Flags().BoolVarP(&rootVersion, "version", "v", false, "")
cfg = config.New()
for _, f := range commandFuncs {
if cmd := f(); cmd != nil {
root.AddCommand(cmd)
}
}
err := root.Execute()
closeAPIClient()
if err != nil {
return 127
}
return 0
} | go | func Run() int {
log.SetOutput(ErrorWriter)
root := NewCommand("git-lfs", gitlfsCommand)
root.PreRun = nil
// Set up help/usage funcs based on manpage text
helpcmd := &cobra.Command{
Use: "help [command]",
Short: "Help about any command",
Long: `Help provides help for any command in the application.
Simply type ` + root.Name() + ` help [path to command] for full details.`,
Run: func(c *cobra.Command, args []string) {
cmd, _, e := c.Root().Find(args)
if cmd == nil || e != nil {
c.Printf("Unknown help topic %#q\n", args)
c.Root().Usage()
} else {
c.HelpFunc()(cmd, args)
}
},
}
root.SetHelpCommand(helpcmd)
root.SetHelpTemplate("{{.UsageString}}")
root.SetHelpFunc(helpCommand)
root.SetUsageFunc(usageCommand)
root.Flags().BoolVarP(&rootVersion, "version", "v", false, "")
cfg = config.New()
for _, f := range commandFuncs {
if cmd := f(); cmd != nil {
root.AddCommand(cmd)
}
}
err := root.Execute()
closeAPIClient()
if err != nil {
return 127
}
return 0
} | [
"func",
"Run",
"(",
")",
"int",
"{",
"log",
".",
"SetOutput",
"(",
"ErrorWriter",
")",
"\n\n",
"root",
":=",
"NewCommand",
"(",
"\"",
"\"",
",",
"gitlfsCommand",
")",
"\n",
"root",
".",
"PreRun",
"=",
"nil",
"\n\n",
"// Set up help/usage funcs based on manpa... | // Run initializes the 'git-lfs' command and runs it with the given stdin and
// command line args.
//
// It returns an exit code. | [
"Run",
"initializes",
"the",
"git",
"-",
"lfs",
"command",
"and",
"runs",
"it",
"with",
"the",
"given",
"stdin",
"and",
"command",
"line",
"args",
".",
"It",
"returns",
"an",
"exit",
"code",
"."
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/commands/run.go#L57-L104 |
157,494 | git-lfs/git-lfs | lfsapi/auth.go | DoWithAuth | func (c *Client) DoWithAuth(remote string, access Access, req *http.Request) (*http.Response, error) {
res, err := c.doWithAuth(remote, access, req, nil)
if errors.IsAuthError(err) {
if len(req.Header.Get("Authorization")) == 0 {
// This case represents a rejected request that
// should have been authenticated but wasn't. Do
// not count this against our redirection
// maximum.
newAccess := c.Endpoints.AccessFor(access.url)
tracerx.Printf("api: http response indicates %q authentication. Resubmitting...", newAccess.Mode())
return c.DoWithAuth(remote, newAccess, req)
}
}
return res, err
} | go | func (c *Client) DoWithAuth(remote string, access Access, req *http.Request) (*http.Response, error) {
res, err := c.doWithAuth(remote, access, req, nil)
if errors.IsAuthError(err) {
if len(req.Header.Get("Authorization")) == 0 {
// This case represents a rejected request that
// should have been authenticated but wasn't. Do
// not count this against our redirection
// maximum.
newAccess := c.Endpoints.AccessFor(access.url)
tracerx.Printf("api: http response indicates %q authentication. Resubmitting...", newAccess.Mode())
return c.DoWithAuth(remote, newAccess, req)
}
}
return res, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DoWithAuth",
"(",
"remote",
"string",
",",
"access",
"Access",
",",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"c",
".",
"doW... | // DoWithAuth sends an HTTP request to get an HTTP response. It attempts to add
// authentication from netrc or git's credential helpers if necessary,
// supporting basic and ntlm authentication. | [
"DoWithAuth",
"sends",
"an",
"HTTP",
"request",
"to",
"get",
"an",
"HTTP",
"response",
".",
"It",
"attempts",
"to",
"add",
"authentication",
"from",
"netrc",
"or",
"git",
"s",
"credential",
"helpers",
"if",
"necessary",
"supporting",
"basic",
"and",
"ntlm",
... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfsapi/auth.go#L24-L40 |
157,495 | git-lfs/git-lfs | lfsapi/auth.go | DoWithAuthNoRetry | func (c *Client) DoWithAuthNoRetry(remote string, access Access, req *http.Request) (*http.Response, error) {
return c.doWithAuth(remote, access, req, nil)
} | go | func (c *Client) DoWithAuthNoRetry(remote string, access Access, req *http.Request) (*http.Response, error) {
return c.doWithAuth(remote, access, req, nil)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DoWithAuthNoRetry",
"(",
"remote",
"string",
",",
"access",
"Access",
",",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"c",
".",
"doWithAuth",
"(... | // DoWithAuthNoRetry sends an HTTP request to get an HTTP response. It works in
// the same way as DoWithAuth, but will not retry the request if it fails with
// an authorization error. | [
"DoWithAuthNoRetry",
"sends",
"an",
"HTTP",
"request",
"to",
"get",
"an",
"HTTP",
"response",
".",
"It",
"works",
"in",
"the",
"same",
"way",
"as",
"DoWithAuth",
"but",
"will",
"not",
"retry",
"the",
"request",
"if",
"it",
"fails",
"with",
"an",
"authoriza... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfsapi/auth.go#L45-L47 |
157,496 | git-lfs/git-lfs | lfsapi/auth.go | DoAPIRequestWithAuth | func (c *Client) DoAPIRequestWithAuth(remote string, req *http.Request) (*http.Response, error) {
operation := getReqOperation(req)
apiEndpoint := c.Endpoints.Endpoint(operation, remote)
access := c.Endpoints.AccessFor(apiEndpoint.Url)
return c.DoWithAuth(remote, access, req)
} | go | func (c *Client) DoAPIRequestWithAuth(remote string, req *http.Request) (*http.Response, error) {
operation := getReqOperation(req)
apiEndpoint := c.Endpoints.Endpoint(operation, remote)
access := c.Endpoints.AccessFor(apiEndpoint.Url)
return c.DoWithAuth(remote, access, req)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DoAPIRequestWithAuth",
"(",
"remote",
"string",
",",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"operation",
":=",
"getReqOperation",
"(",
"req",
")",
"\n",... | // DoAPIRequestWithAuth sends an HTTP request to get an HTTP response similarly
// to DoWithAuth, but using the LFS API endpoint for the provided remote and
// operation to determine the access mode. | [
"DoAPIRequestWithAuth",
"sends",
"an",
"HTTP",
"request",
"to",
"get",
"an",
"HTTP",
"response",
"similarly",
"to",
"DoWithAuth",
"but",
"using",
"the",
"LFS",
"API",
"endpoint",
"for",
"the",
"provided",
"remote",
"and",
"operation",
"to",
"determine",
"the",
... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfsapi/auth.go#L52-L57 |
157,497 | git-lfs/git-lfs | lfshttp/ssh.go | sshParseShellCommand | func sshParseShellCommand(command string, existing string) (ssh string, cmd string, needShell bool) {
ssh = existing
if cmdArgs := tools.QuotedFields(command); len(cmdArgs) > 0 {
needShell = true
ssh = cmdArgs[0]
cmd = command
}
return
} | go | func sshParseShellCommand(command string, existing string) (ssh string, cmd string, needShell bool) {
ssh = existing
if cmdArgs := tools.QuotedFields(command); len(cmdArgs) > 0 {
needShell = true
ssh = cmdArgs[0]
cmd = command
}
return
} | [
"func",
"sshParseShellCommand",
"(",
"command",
"string",
",",
"existing",
"string",
")",
"(",
"ssh",
"string",
",",
"cmd",
"string",
",",
"needShell",
"bool",
")",
"{",
"ssh",
"=",
"existing",
"\n",
"if",
"cmdArgs",
":=",
"tools",
".",
"QuotedFields",
"("... | // Parse command, and if it looks like a valid command, return the ssh binary
// name, the command to run, and whether we need a shell. If not, return
// existing as the ssh binary name. | [
"Parse",
"command",
"and",
"if",
"it",
"looks",
"like",
"a",
"valid",
"command",
"return",
"the",
"ssh",
"binary",
"name",
"the",
"command",
"to",
"run",
"and",
"whether",
"we",
"need",
"a",
"shell",
".",
"If",
"not",
"return",
"existing",
"as",
"the",
... | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfshttp/ssh.go#L141-L149 |
157,498 | git-lfs/git-lfs | config/extension.go | SortExtensions | func SortExtensions(m map[string]Extension) ([]Extension, error) {
pMap := make(map[int]Extension)
priorities := make([]int, 0, len(m))
for n, ext := range m {
p := ext.Priority
if _, exist := pMap[p]; exist {
err := fmt.Errorf("duplicate priority %d on %s", p, n)
return nil, err
}
pMap[p] = ext
priorities = append(priorities, p)
}
sort.Ints(priorities)
result := make([]Extension, len(priorities))
for i, p := range priorities {
result[i] = pMap[p]
}
return result, nil
} | go | func SortExtensions(m map[string]Extension) ([]Extension, error) {
pMap := make(map[int]Extension)
priorities := make([]int, 0, len(m))
for n, ext := range m {
p := ext.Priority
if _, exist := pMap[p]; exist {
err := fmt.Errorf("duplicate priority %d on %s", p, n)
return nil, err
}
pMap[p] = ext
priorities = append(priorities, p)
}
sort.Ints(priorities)
result := make([]Extension, len(priorities))
for i, p := range priorities {
result[i] = pMap[p]
}
return result, nil
} | [
"func",
"SortExtensions",
"(",
"m",
"map",
"[",
"string",
"]",
"Extension",
")",
"(",
"[",
"]",
"Extension",
",",
"error",
")",
"{",
"pMap",
":=",
"make",
"(",
"map",
"[",
"int",
"]",
"Extension",
")",
"\n",
"priorities",
":=",
"make",
"(",
"[",
"]... | // SortExtensions sorts a map of extensions in ascending order by Priority | [
"SortExtensions",
"sorts",
"a",
"map",
"of",
"extensions",
"in",
"ascending",
"order",
"by",
"Priority"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/config/extension.go#L18-L39 |
157,499 | git-lfs/git-lfs | lfshttp/certs.go | isCertVerificationDisabledForHost | func isCertVerificationDisabledForHost(c *Client, host string) bool {
hostSslVerify, _ := c.uc.Get("http", fmt.Sprintf("https://%v", host), "sslverify")
if hostSslVerify == "false" {
return true
}
return c.SkipSSLVerify
} | go | func isCertVerificationDisabledForHost(c *Client, host string) bool {
hostSslVerify, _ := c.uc.Get("http", fmt.Sprintf("https://%v", host), "sslverify")
if hostSslVerify == "false" {
return true
}
return c.SkipSSLVerify
} | [
"func",
"isCertVerificationDisabledForHost",
"(",
"c",
"*",
"Client",
",",
"host",
"string",
")",
"bool",
"{",
"hostSslVerify",
",",
"_",
":=",
"c",
".",
"uc",
".",
"Get",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"host",
")"... | // isCertVerificationDisabledForHost returns whether SSL certificate verification
// has been disabled for the given host, or globally | [
"isCertVerificationDisabledForHost",
"returns",
"whether",
"SSL",
"certificate",
"verification",
"has",
"been",
"disabled",
"for",
"the",
"given",
"host",
"or",
"globally"
] | fe8f7002c6efb083feadc0a078fa2fbb389127c7 | https://github.com/git-lfs/git-lfs/blob/fe8f7002c6efb083feadc0a078fa2fbb389127c7/lfshttp/certs.go#L18-L25 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.