id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c11600 | Scheme: "https",
Host: "checkpoint-api.hashicorp.com",
Path: fmt.Sprintf("/v1/telemetry/%s", r.Product),
}
req, err := http.NewRequest("POST", u.String(), bytes.NewReader(b))
if err != nil {
return nil, err
}
req.Header.Set("Accept", "application/json")
req.Header.Set("User-Agent", "HashiCorp/go-check... | |
c11601 | {
select {
case <-time.After(randomStagger(interval)):
resp, err := Check(p)
cb(resp, err)
case <-doneCh:
return
}
}
}()
return doneCh
} | |
c11602 |
RawQuery: v.Encode(),
}
req, err := http.NewRequest("GET", u.String(), nil)
if err != nil {
return nil, err
}
req.Header.Set("Accept", "application/json")
req.Header.Set("User-Agent", "HashiCorp/go-checkpoint")
client := cleanhttp.DefaultClient()
// We use a short timeout since checking for new versions... | |
c11603 | constraint.SetVersion(version)
return constraint
} | |
c11604 | Compare(version, self.version, self.operator)
} | |
c11605 | strings.Trim(self.operator+" "+self.version, " ")
} | |
c11606 |
}
self.constraints = append(self.constraints, constraint...)
} | |
c11607 | range config.PatternsDir {
err := g.AddPatternsFromPath(path)
if err != nil {
return nil, err
}
}
}
if err := g.AddPatternsFromMap(config.Patterns); err != nil {
return nil, err
}
return g, nil
} | |
c11608 |
if err != nil {
return err
}
g.patterns[name] = &gPattern{expression: dnPattern, typeInfo: ti}
return nil
} | |
c11609 |
g.rawPattern[name] = pattern
g.buildPatterns()
return nil
} | |
c11610 | range m {
g.rawPattern[name] = pattern
}
return g.buildPatterns()
} | |
c11611 | syntax)
}
}
keys = append(keys, syntax)
}
patternDeps[k] = keys
}
order, _ := sortGraph(patternDeps)
for _, key := range reverseList(order) {
g.addPattern(key, m[key])
}
return nil
} | |
c11612 | err
}
scanner := bufio.NewScanner(bufio.NewReader(file))
for scanner.Scan() {
l := scanner.Text()
if len(l) > 0 && l[0] != '#' {
names := strings.SplitN(l, " ", 2)
filePatterns[names[0]] = names[1]
}
}
file.Close()
}
return g.AddPatternsFromMap(filePatterns)
} | |
c11613 | gr.regexp.MatchString(text); !ok {
return false, nil
}
return true, nil
} | |
c11614 | "" {
if g.config.RemoveEmptyValues && match[i] == "" {
continue
}
name = g.nameToAlias(name)
captures[name] = match[i]
}
}
}
return captures, nil
} | |
c11615 | nil {
return nil, err
}
return g.compiledParse(gr, text)
} | |
c11616 | != "" {
if g.config.RemoveEmptyValues == true && match[i] == "" {
continue
}
name = g.nameToAlias(name)
captures[name] = append(captures[name], match[i])
}
}
}
return captures, nil
} | |
c11617 |
}
values, err := g.compiledParse(gr, line)
if err != nil {
return err
}
if err = process(values); err != nil {
return err
}
}
} | |
c11618 |
if cn != len(c.hash) {
panic("copy hash length is inconsistent")
}
return buf[:n+len(c.hash)]
default:
panic("not possible to reach this point")
}
} | |
c11619 | := s.set[c]
return ok
} | |
c11620 | out = append(out, k)
}
return out
} | |
c11621 | !s.Has(c) {
s.Add(c)
return true
}
return false
} | |
c11622 |
if err != nil {
return err
}
}
return nil
} | |
c11623 |
}
if dec.Code != mh.SHA2_256 || dec.Length != 32 {
panic("invalid hash for cidv0")
}
return Cid{string(mhash)}
} | |
c11624 | codecType)
cn := copy(buf[n:], mhash)
if cn != hashlen {
panic("copy hash length is inconsistent")
}
return Cid{string(buf[:n+hashlen])}
} | |
c11625 | is valid
_, err := mbase.NewEncoder(encoding)
if err != nil {
return -1, err
}
return encoding, nil
} | |
c11626 | == 34 && c.str[0] == 18 && c.str[1] == 32 {
return 0
}
return 1
} | |
c11627 | codec, _ := uvarint(c.str[n:])
return codec
} | |
c11628 |
return mbase.Encode(base, c.Bytes())
default:
panic("not possible to reach this point")
}
} | |
c11629 | c.Hash().B58String()
case 1:
return base.Encode(c.Bytes())
default:
panic("not possible to reach this point")
}
} | |
c11630 | }
// skip version length
_, n1 := binary.Uvarint(bytes)
// skip codec length
_, n2 := binary.Uvarint(bytes[n1:])
return mh.Multihash(bytes[n1+n2:])
} | |
c11631 | {
return fmt.Errorf("cid was incorrectly formatted")
}
out, err := Decode(obj.CidTarget)
if err != nil {
return err
}
*c = out
return nil
} | |
c11632 |
return Prefix{}, err
}
mhtype, err := binary.ReadUvarint(r)
if err != nil {
return Prefix{}, err
}
mhlen, err := binary.ReadUvarint(r)
if err != nil {
return Prefix{}, err
}
return Prefix{
Version: vers,
Codec: codec,
MhType: mhtype,
MhLength: int(mhlen),
}, nil
} | |
c11633 | > (p.TotalPages - wing - 1) {
loopEnd = p.TotalPages
loopStart = p.TotalPages - barLength + 3
}
}
for i := loopStart; i <= loopEnd; i++ {
li, err := pageLI(strconv.Itoa(i), i, path, p)
if err != nil {
return t, errors.WithStack(err)
}
t.Append(li)
}
if p.TotalPages > loopEnd {
t.Append(pageL... | |
c11634 | 1,
PerPage: 20,
}
return p.TagFromPagination(pagination, opts)
} | |
c11635 | "hidden",
"name": "authenticity_token",
}))
} | |
c11636 | = value
return tags.New("label", opts)
} | |
c11637 | "POST" && m != "GET" {
form.Options["method"] = "POST"
form.Prepend(tags.New("input", tags.Options{
"value": m,
"type": "hidden",
"name": "_method",
}))
}
return form
} | |
c11638 | tag.Append(ct)
if opts["name"] != nil && unchecked != nil {
tag.Append(tags.New("input", tags.Options{
"type": "hidden",
"name": opts["name"],
"value": unchecked,
}))
}
if opts["label"] != nil && hl == nil {
label := fmt.Sprint(opts["label"])
delete(opts, "label")
tag.Append(" " + label)
}
... | |
c11639 | *tags.Tag {
return f.RadioButtonTag(opts)
} | |
c11640 |
labelOptions := tags.Options{
"body": strings.Join([]string{ct.String(), label}, " "),
}
// If the ID is provided, give it to the label's for attribute
if ID != "" {
labelOptions["for"] = ID
}
tag := tags.New("label", labelOptions)
return tag
} | |
c11641 | divWrapper(opts, func(o tags.Options) tags.Body {
return f.Form.CheckboxTag(o)
})
} | |
c11642 | *tags.Tag {
return f.TextAreaTag(opts)
} | |
c11643 | *tags.Tag {
return f.Form.HiddenTag(opts)
} | |
c11644 |
}
delete(opts, "tag_only")
return tags.New("textarea", opts)
} | |
c11645 | f.Options["enctype"] = "multipart/form-data"
}
delete(opts, "tag_only")
return tags.New("input", opts)
} | |
c11646 | "hidden"
return tags.New("input", opts)
} | |
c11647 | := loadErrors(opts)
delete(opts, "errors")
return &FormFor{
Form: New(opts),
Model: model,
name: name,
dashedName: dashedName,
reflection: rv,
Errors: errors,
}
} | |
c11648 |
f.addFormatTag(field, opts)
return f.Form.InputTag(opts)
} | |
c11649 | *tags.Tag {
f.buildOptions(field, opts)
return f.Form.HiddenTag(opts)
} | |
c11650 | return f.RadioButtonTag(field, opts)
} | |
c11651 | return f.TextAreaTag(field, opts)
} | |
c11652 | return f.Form.SubmitTag(value, opts)
} | |
c11653 | tag.Options["value"] = ""
}
i := r.Interface()
if dv, ok := i.(driver.Valuer); ok {
value, _ := dv.Value()
if value == nil {
tag.Options["value"] = ""
}
tag.Options["value"] = fmt.Sprintf("%v", value)
}
}
}
if tag.Options["selected"] != nil {
tag.Selected = template.HTMLEsca... | |
c11654 | for _, c := range cls {
if c != "form-control" {
ncls = append(ncls, c)
}
}
o["class"] = strings.Join(ncls, " ")
}
if label != "" {
o["label"] = label
}
if hl != nil {
o["hide_label"] = hl
}
return f.FormFor.CheckboxTag(field, o)
})
} | |
c11655 | &FormFor{form.NewFormFor(model, opts)}
} | |
c11656 | delete(opts, "body")
}
return New("script", opts)
} | |
c11657 | if err != nil {
if strings.Contains(err.Error(), "exit status 1") {
return "", ErrNoMergeBase{}
}
return "", err
}
return strings.TrimSpace(stdout), nil
} | |
c11658 | err
}
logs, err := NewCommand("log", prInfo.MergeBase+"..."+headBranch, _PRETTY_LOG_FORMAT).RunInDirBytes(repo.Path)
if err != nil {
return nil, err
}
prInfo.Commits, err = repo.parsePrettyFormatLogToList(logs)
if err != nil {
return nil, fmt.Errorf("parsePrettyFormatLogToList: %v", err)
}
// Count numbe... | |
c11659 | "-p", "--binary", base, head).RunInDirBytes(repo.Path)
} | |
c11660 | name {
return true
}
}
return false
} | |
c11661 | Check sample file
samplePath := path.Join(repoPath, HookSampleDir, h.name) + ".sample"
if isFile(samplePath) {
data, err := ioutil.ReadFile(samplePath)
if err != nil {
return nil, err
}
h.Sample = string(data)
}
return h, nil
} | |
c11662 |
os.MkdirAll(path.Dir(h.path), os.ModePerm)
return ioutil.WriteFile(h.path, []byte(strings.Replace(h.Content, "\r", "", -1)), os.ModePerm)
} | |
c11663 | {
hooks[i], err = GetHook(repoPath, name)
if err != nil {
return nil, err
}
}
return hooks, nil
} | |
c11664 | || strings.HasPrefix(url, "../") {
// ...construct and return correct submodule url here...
idx := strings.Index(parentPath, "/src/")
if idx == -1 {
return url
}
return strings.TrimSuffix(urlPrefix, "/") + parentPath[:idx] + "/" + url
}
// sysuser@xxx:user/repo
i := strings.Index(url, "@")
j := strin... | |
c11665 |
// Handle special case on Windows.
i := strings.Index(fields[2], "windows")
if i >= 1 {
gitVersion = fields[2][:i-1]
return gitVersion, nil
}
gitVersion = fields[2]
return gitVersion, nil
} | |
c11666 | NewCommand("fsck").AddArguments(args...).RunInDirTimeout(timeout, repoPath)
return err
} | |
c11667 | err := NewIDFromString(idStr)
if err != nil {
return nil, err
}
return repo.getTree(id)
} | |
c11668 | = append(c.envs, envs...)
return c
} | |
c11669 | go func() {
done <- cmd.Wait()
}()
var err error
select {
case <-time.After(timeout):
if cmd.Process != nil && cmd.ProcessState != nil && !cmd.ProcessState.Exited() {
if err := cmd.Process.Kill(); err != nil {
return fmt.Errorf("fail to kill process: %v", err)
}
}
<-done
return ErrExecTimeout... | |
c11670 | return c.RunInDirTimeoutPipeline(-1, dir, stdout, stderr)
} | |
c11671 | := NewCommand("show-ref", "--verify", name).RunInDir(repoPath)
return err == nil
} | |
c11672 |
}
stdout = strings.TrimSpace(stdout)
if !strings.HasPrefix(stdout, BRANCH_PREFIX) {
return nil, fmt.Errorf("invalid HEAD branch: %v", stdout)
}
return &Branch{
Name: stdout[len(BRANCH_PREFIX):],
Path: stdout,
}, nil
} | |
c11673 |
_, err := NewCommand("symbolic-ref", "HEAD", BRANCH_PREFIX+name).RunInDir(repo.Path)
return err
} | |
c11674 | if len(fields) != 2 {
continue // NOTE: I should believe git will not give me wrong string.
}
branches[i] = strings.TrimPrefix(fields[1], BRANCH_PREFIX)
}
return branches, nil
} | |
c11675 | } else {
cmd.AddArguments("-d")
}
cmd.AddArguments(name)
_, err := cmd.RunInDir(repoPath)
return err
} | |
c11676 | return DeleteBranch(repo.Path, name, opts)
} | |
c11677 | }
cmd.AddArguments(name, url)
_, err := cmd.RunInDir(repo.Path)
return err
} | |
c11678 | := NewCommand("remote", "remove", name).RunInDir(repo.Path)
return err
} | |
c11679 |
if err := b.DataPipeline(stdout, stderr); err != nil {
return nil, concatenateError(err, stderr.String())
}
return stdout, nil
} | |
c11680 | := hex.DecodeString(s)
return MustID(b)
} | |
c11681 | hex.DecodeString(s)
if err != nil {
return id, err
}
return NewID(b)
} | |
c11682 | }
stdout, w := io.Pipe()
done := make(chan error)
var diff *Diff
go func() {
diff = ParsePatch(done, maxLines, maxLineCharacteres, maxFiles, stdout)
}()
stderr := new(bytes.Buffer)
err = cmd.RunInDirTimeoutPipeline(2*time.Minute, repoPath, w, stderr)
w.Close() // Close writer to exit parsing goroutine
if ... | |
c11683 |
c, _ := commit.Parent(0)
query := fmt.Sprintf("%s...%s", commitID, c.ID.String())
cmd.AddArguments("format-patch", "--no-signature", "--stdout", query)
}
default:
return fmt.Errorf("invalid diffType: %s", diffType)
}
stderr := new(bytes.Buffer)
if err = cmd.RunInDirPipeline(repoPath, writer, stderr);... | |
c11684 |
return GetDiffRange(repoPath, "", commitID, maxLines, maxLineCharacteres, maxFiles)
} | |
c11685 | return c.repo.getCommitByPathWithID(c.ID, relpath)
} | |
c11686 |
_, err := cmd.AddArguments(files...).RunInDir(repoPath)
return err
} | |
c11687 | cmd.AddArguments(fmt.Sprintf("--author='%s <%s>'", opts.Author.Name, opts.Author.Email))
}
cmd.AddArguments("-m", opts.Message)
_, err := cmd.RunInDir(repoPath)
// No stderr but exit status 1 means nothing to commit.
if err != nil && err.Error() == "exit status 1" {
return nil
}
return err
} | |
c11688 | }
}
done <- struct{}{}
}()
stderr := new(bytes.Buffer)
err := NewCommand("show", "--name-status", "--pretty=format:''", commitID).RunInDirPipeline(repoPath, w, stderr)
w.Close() // Close writer to exit parsing goroutine
if err != nil {
return nil, concatenateError(err, stderr.String())
}
<-done
return... | |
c11689 | GetCommitFileStatus(c.repo.Path, c.ID.String())
} | |
c11690 | return repo.getRefCommitID(BRANCH_PREFIX + name)
} | |
c11691 | return repo.getRefCommitID(TAG_PREFIX + name)
} | |
c11692 |
return repo.getRefCommitID(REMOTE_PREFIX + name)
} | |
c11693 | NewIDFromString(commitID)
if err != nil {
return nil, err
}
return repo.getCommit(id)
} | |
c11694 | err := repo.GetBranchCommitID(name)
if err != nil {
return nil, err
}
return repo.GetCommit(commitID)
} | |
c11695 |
return nil, err
}
return repo.GetCommit(commitID)
} | |
c11696 | err := repo.GetRemoteBranchCommitID(name)
if err != nil {
return nil, err
}
return repo.GetCommit(commitID)
} | |
c11697 | repo.parsePrettyFormatLogToList(stdout)
if err != nil {
return nil, err
}
return commits.Front().Value.(*Commit), nil
} | |
c11698 | last.ParentCount() == 0 {
return l, nil
}
var err error
cur := last
for {
if cur.ID.Equal(before.ID) {
break
}
l.PushBack(cur)
if cur.ParentCount() == 0 {
break
}
cur, err = cur.Parent(0)
if err != nil {
return nil, err
}
}
return l, nil
} | |
c11699 | return nil
} else if in.Next() == nil {
break
}
if in.Value.(*Commit).Committer.When.Equal(commit.Committer.When) {
break
}
if in.Value.(*Commit).Committer.When.After(commit.Committer.When) &&
in.Next().Value.(*Commit).Committer.When.Before(commit.Committer.When) {
break
}
in =... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.