id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c13600 |
if err != nil {
return 0
}
return fi.Size()
} | |
c13601 | if !loc.opts.compress {
newName := reGzip.ReplaceAllString(loc.filename, "")
loc.filename = newName
}
}
return loc.filename
} | |
c13602 |
if nmr != nil {
loc.Filename()
nmr.Next()
}
return loc.filename
} | |
c13603 | }
output := loc.Summary(linkCount)
if output != "" {
println(output)
}
} | |
c13604 | size := loc.Filesize()
if size <= 0 {
return out
}
return fmt.Sprintf("%s / %d bytes", out, size)
} | |
c13605 | namer := &Namer{opts: opts}
namer.Reset()
return namer
} | |
c13606 |
return fmt.Sprintf("%s%d%s", n.opts.base, n.count, ext)
} | |
c13607 | {
n.count = n.opts.start
} else {
n.count++
}
return n
} | |
c13608 | n.count <= n.opts.start {
n.count = n.opts.zero
} else {
n.count--
}
return n
} | |
c13609 | append(afters, strings.ToLower(name))
}
return afters
} | |
c13610 | return "", str
}
return str[:colon], str[colon+1:]
} | |
c13611 | publicPath: "public/",
sitemapsPath: "sitemaps/",
filename: "sitemap",
verbose: true,
compress: true,
pretty: false,
adp: NewFileAdapter(),
}
} | |
c13612 | return opts.sitemapsHost
}
return opts.defaultHost
} | |
c13613 |
o.nmr = NewNamer(&NOpts{base: opts.filename})
return NewLocation(o)
} | |
c13614 | opts.filename, zero: 1, start: 2})
}
return opts.nmr
} | |
c13615 | := gzip.NewWriter(file)
defer gz.Close()
gz.Write(data)
} | |
c13616 | file.Write(data)
defer file.Close()
} | |
c13617 | &sitemapIndexURL{opts: opts, data: url}
} | |
c13618 | "lastmod"); !ok {
lastmod := sitemap.CreateElement("lastmod")
lastmod.SetText(time.Now().Format(time.RFC3339))
}
if su.opts.pretty {
doc.Indent(2)
}
buf := poolBuffer.Get()
doc.WriteTo(buf)
bytes := buf.Bytes()
poolBuffer.Put(buf)
return bytes
} | |
c13619 | &BuilderFile{opts: opts, loc: loc}
b.clear()
return b
} | |
c13620 | := smu.XML()
if !b.isFileCanFit(bytes) {
return &builderFileError{error: err, full: true}
}
b.content = append(b.content, bytes...)
return nil
} | |
c13621 | < MaxSitemapLinks
return r && b.newscnt < MaxSitemapNews
} | |
c13622 | = append(append(c, b.Content()...), XMLFooter...)
return c
} | |
c13623 |
c := b.XMLContent()
b.loc.Write(c, b.linkcnt)
b.clear()
} | |
c13624 | &= 248
digest[31] &= 127
digest[31] |= 64
copy(curve25519Private[:], digest)
} | |
c13625 |
var x edwards25519.FieldElement
edwardsToMontgomeryX(&x, &A.Y)
edwards25519.FeToBytes(curve25519Public, &x)
return true
} | |
c13626 | y) >> 31))
equalSoFar = equalSoFar & (((x ^ y) - 1) >> 31)
}
return int32(^equalSoFar & 1 & greater)
} | |
c13627 | or 0xff (for e = -1)
eIsMinus1 := int32(eBytes[1]) & 1
var negV edwards25519.FieldElement
edwards25519.FeNeg(&negV, &v)
edwards25519.FeCMove(&v, &negV, eIsMinus1)
edwards25519.FeZero(&v2)
edwards25519.FeCMove(&v2, &edwards25519.A, eIsMinus1)
edwards25519.FeSub(&v, &v, &v2)
edwards25519.FeToBytes(publicKey, &... | |
c13628 | := uint32(b ^ c)
x--
return int32(x >> 31)
} | |
c13629 | hReduced [32]byte
edwards25519.ScReduce(&hReduced, &digest)
var R edwards25519.ProjectiveGroupElement
var b [32]byte
copy(b[:], sig[32:])
edwards25519.GeDoubleScalarMultVartime(&R, &hReduced, &A, &b)
var checkR [32]byte
R.ToBytes(&checkR)
return subtle.ConstantTimeCompare(sig[:32], checkR[:]) == 1
} | |
c13630 | reflect.Int &&
valField.CanSet() {
valField.SetInt(2)
}
if valField.Kind() == reflect.String &&
valField.CanSet() {
valField.SetString("B")
}
}
}
}
return nil
} | |
c13631 | return nil
}
var (
child = parent.Route(args)
clr = ctx.Color()
)
if child == nil {
return fmt.Errorf("command %s not found", clr.Yellow(strings.Join(args, " ")))
}
ctx.String(child.Usage(ctx))
return nil
} | |
c13632 |
NoHook: true,
Fn: HelpCommandFn,
}
} | |
c13633 |
return err
}
if strings.HasPrefix(line, successPrefix) {
ctx.String(line)
cmd.Process.Release()
} else {
cmd.Process.Kill()
line = strings.TrimSuffix(line, "\n")
return fmt.Errorf(line)
}
return nil
} | |
c13634 | json.NewDecoder(r).Decode(argv)
} | |
c13635 | defer file.Close()
err = ReadJSON(file, argv)
}
return err
} | |
c13636 | if e != nil {
return e
}
// allow self-config .json files to go with the executable file, #40
file, err = os.Open(filepath.Dir(exe) + string(filepath.Separator) + filename)
if err == nil {
defer file.Close()
err = ReadJSON(file, argv)
}
}
return err
} | |
c13637 | = strings.Split(s, ",")
return nil
} | |
c13638 | {
for _, alias := range child.Aliases {
if cmd.findChild(alias) != nil {
debug.Panicf("repeat register child `%s` for command `%s`", alias, cmd.Name)
}
}
}
cmd.children = append(cmd.children, child)
child.parent = cmd
return child
} | |
c13639 | return cmd.Register(&Command{Name: name, Fn: fn, Argv: argvFn})
} | |
c13640 | && len(tree.forest) > 0 {
tree.command.RegisterTree(tree.forest...)
}
}
} | |
c13641 | := []func(*Context) error{
ctx.command.OnBefore,
cmd.OnRootBefore,
ctx.command.Fn,
cmd.OnRootAfter,
ctx.command.OnAfter,
}
for _, f := range funcs {
if f != nil {
if err := f(ctx); err != nil {
if err == ExitError {
return nil
}
return err
}
}
}
return nil
} | |
c13642 | return cmd.UsageFn()
}
return cmd.defaultUsageFn(ctx)
} | |
c13643 |
for ancestor.parent != nil {
ancestor = ancestor.parent
}
return ancestor
} | |
c13644 | end := cmd.SubRoute(router)
if end != len(router) {
return nil
}
return child
} | |
c13645 | range router {
child := cur.findChild(name)
if child == nil {
return cur, i
}
cur = child
}
return cur, len(router)
} | |
c13646 | child.Aliases != nil {
for _, alias := range child.Aliases {
if alias == name {
return child
}
}
}
}
return nil
} | |
c13647 | _, child := range cmd.children {
ret = append(ret, child.Name)
}
return ret
} | |
c13648 | aliasesBuff.WriteString(strings.Join(child.Aliases, ","))
aliasesBuff.WriteString(")")
aliases = aliasesBuff.String()
}
fmt.Fprintf(buff, format, child.Name, child.Desc, aliases)
}
return buff.String()
} | |
c13649 | len(targets); i < size; i++ {
if d, ok := match(path, targets[i]); ok {
dists = append(dists, editDistanceRank{s: targets[i], d: d})
}
}
sort.Sort(editDistanceRankSlice(dists))
for i := 0; i < len(dists); i++ {
targets[i] = dists[i].s
}
return targets[:len(dists)]
} | |
c13650 | r.filename = file.Name()
} else {
r.filename = ""
}
} | |
c13651 | if r.reader == nil {
return os.Stdin.Read(data)
}
return r.reader.Read(data)
} | |
c13652 | w.filename = file.Name()
} else {
w.filename = ""
}
} | |
c13653 |
if err != nil {
return 0, err
}
w.writer = file
}
}
return w.writer.Write(data)
} | |
c13654 | log.Lshortfile|log.Ldate|log.Ltime)
cl.SetMinLevel(lvl)
cl.SetDefaultLevel(lvl)
lg := cl.NewLogger()
return lg, nil
} | |
c13655 | parserCreators[name]; ok {
panic("RegisterFlagParser has registered: " + name)
}
parserCreators[name] = creator
} | |
c13656 | return launchEditorWithFilename(editor, randomFilename())
} | |
c13657 | range ctx.flagSet.flagSlice {
if fl.isSet {
n++
}
}
return n
} | |
c13658 | == nil || len(ctx.argvList) == 0 {
return nil
}
return ctx.argvList[0]
} | |
c13659 | := len(ctx.argvList) - 1
return ctx.argvList[index]
} | |
c13660 |
buf := bytes.NewBufferString("")
if err := json.NewEncoder(buf).Encode(ctx.argvList[i]); err != nil {
return err
}
if err := json.NewDecoder(buf).Decode(argv); err != nil {
return err
}
}
return nil
} | |
c13661 | i, msg: "source is nil"}
}
buf := bytes.NewBufferString("")
if err := json.NewEncoder(buf).Encode(ctx.argvList[i]); err != nil {
return err
}
return json.NewDecoder(buf).Decode(argv)
} | |
c13662 |
if fl, ok := ctx.flagSet.flagMap[alias]; ok {
return fl.isSet
}
}
return false
} | |
c13663 | debug.Panicf("ctx.flagSet == nil")
}
return ctx.flagSet.values
} | |
c13664 | == nil {
ctx.writer = colorable.NewColorableStdout()
}
return ctx.writer
} | |
c13665 | *Context {
fmt.Fprintf(ctx.Writer(), format, args...)
return ctx
} | |
c13666 | fmt.Fprint(ctx.Writer(), string(data))
}
return ctx
} | |
c13667 | nil {
fmt.Fprint(ctx.Writer(), string(data))
}
return ctx
} | |
c13668 |
return ctx.JSONIndent(obj, prefix, indent).String("\n")
} | |
c13669 | return RunWithArgs(argv, os.Args, fn, descs...)
} | |
c13670 | { return argv },
CanSubRoute: true,
Fn: fn,
}).Run(args[1:])
if err != nil {
fmt.Fprintln(os.Stderr, err)
return 1
}
return 0
} | |
c13671 | *Command {
root.RegisterTree(forest...)
return root
} | |
c13672 |
command: cmd,
forest: forest,
}
} | |
c13673 |
clr := color.Color{}
fset := parseArgv(args, argv, clr)
return fset.err
} | |
c13674 | > 0 {
return s[:n]
}
return s
} | |
c13675 | "[%s] %s, %s: %v\n",
color.White(progname), color.Red("Error"), errCase, e)
os.Exit(1)
}
} | |
c13676 | >= levelSet {
fmt.Fprintf(os.Stderr, "[%s] ", color.White(progname))
fmt.Fprintf(os.Stderr, format+"\n", args...)
}
} | |
c13677 | _, exists := c.routersMap[r]; exists {
return throwRouterRepeat(clr.Yellow(r))
}
cmd.routersMap[r] = c.Path()
}
}
if c.nochild() {
continue
}
commands = append(commands, c.children...)
}
return nil
} | |
c13678 | new(bytes.Buffer)
statusCode := http.StatusOK
if err := cmd.RunWith(args, buf, w, r.Method); err != nil {
buf.Write([]byte(err.Error()))
nativeError := err
if werr, ok := err.(wrapError); ok {
nativeError = werr.err
}
switch nativeError.(type) {
case commandNotFoundError:
statusCode = http.StatusNo... | |
c13679 |
return http.ListenAndServe(addr, cmd)
} | |
c13680 | e := http.Serve(ln, cmd); e != nil {
panic(e.Error())
}
g.Done()
}(ln)
}
g.Wait()
return
} | |
c13681 | nil {
body = strings.NewReader(values.Encode())
}
req, err := http.NewRequest(method, addr, body)
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("User-Agent", "cli-RPC")
resp, err := httpc.Do(req)
if err != nil {
return err
}
defer resp.B... | |
c13682 |
return err
}
bashrcFiles := []string{
".bashrc",
".bash_profile",
}
var dstFile *os.File
for _, bashFilename := range bashrcFiles {
dstFilepath := filepath.Join(os.Getenv("HOME"), bashFilename)
dstFile, err = os.OpenFile(dstFilepath, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
if err == nil {
break
... | |
c13683 | return fmt.Errorf("invalid gender %s", ctx.Color().Yellow(argv.Gender))
}
return nil
} | |
c13684 | pre: make([]byte, preLen),
}
n.RandomizePrefix()
return n
} | |
c13685 | globalNUID.Unlock()
return nuid
} | |
c13686 |
// copy in the seq in base62.
for i, l := len(b), seq; i > preLen; l /= base {
i -= 1
b[i] = digits[l%base]
}
return string(b[:])
} | |
c13687 |
n.inc = minInc + prand.Int63n(maxInc-minInc)
} | |
c13688 | c.children = make(map[string]*Cmd)
}
c.children[cmd.Name] = cmd
} | |
c13689 | cmd)
}
sort.Sort(cmdSorter(cmds))
return cmds
} | |
c13690 | 2, ' ', 0)
for _, child := range c.Children() {
fmt.Fprintf(w, "\t%s\t\t\t%s\n", child.Name, child.Help)
}
w.Flush()
p()
}
return b.String()
} | |
c13691 | {
for _, alias := range cmd.Aliases {
if alias == name {
return cmd
}
}
}
return nil
} | |
c13692 | c = *cmd
continue
}
return cmd, args[i:]
}
return cmd, nil
} | |
c13693 | or operating system not supported.")
log.Fatal(err)
}
return NewWithReadline(rl)
} | |
c13694 | autoHelp: true,
}
shell.Actions = &shellActionsImpl{Shell: shell}
shell.progressBar = newProgressBar(shell)
addDefaultFuncs(shell)
return shell
} | |
c13695 | s.activeMutex.RUnlock()
return s.active
} | |
c13696 | s.customCompleter = true
s.setCompleter(completer)
} | |
c13697 | is never written. Simpler to just create a new readline
// Instance.
config := s.reader.scanner.Config.Clone()
config.HistoryFile = path
s.reader.scanner, _ = readline.NewEx(config)
} | |
c13698 | }
abspath := filepath.Join(home, path)
s.SetHistoryPath(abspath)
} | |
c13699 | s.pager = pager
s.pagerArgs = args
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.