_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q13600 | Filesize | train | func (loc *Location) Filesize() int64 {
f, _ := os.Open(loc.Path())
defer f.Close()
fi, err := f.Stat()
if err != nil {
return 0
}
return fi.Size()
} | go | {
"resource": ""
} |
q13601 | Filename | train | func (loc *Location) Filename() string {
nmr := loc.Namer()
if loc.filename == "" && nmr == nil {
log.Fatal("[F] No filename or namer set")
}
if loc.filename == "" {
loc.filename = nmr.String()
if !loc.opts.compress {
newName := reGzip.ReplaceAllString(loc.filename, "")
loc.filename = newName
}
}
return loc.filename
} | go | {
"resource": ""
} |
q13602 | ReserveName | train | func (loc *Location) ReserveName() string {
nmr := loc.Namer()
if nmr != nil {
loc.Filename()
nmr.Next()
}
return loc.filename
} | go | {
"resource": ""
} |
q13603 | Write | train | func (loc *Location) Write(data []byte, linkCount int) {
loc.opts.adp.Write(loc, data)
if !loc.IsVerbose() {
return
}
output := loc.Summary(linkCount)
if output != "" {
println(output)
}
} | go | {
"resource": ""
} |
q13604 | Summary | train | func (loc *Location) Summary(linkCount int) string {
nmr := loc.Namer()
if nmr.IsStart() {
return ""
}
out := fmt.Sprintf("%s '%d' links",
loc.PathInPublic(), linkCount)
size := loc.Filesize()
if size <= 0 {
return out
}
return fmt.Sprintf("%s / %d bytes", out, size)
} | go | {
"resource": ""
} |
q13605 | NewNamer | train | func NewNamer(opts *NOpts) *Namer {
if opts.extension == "" {
opts.extension = ".xml.gz"
}
namer := &Namer{opts: opts}
namer.Reset()
return namer
} | go | {
"resource": ""
} |
q13606 | String | train | func (n *Namer) String() string {
ext := n.opts.extension
if n.count == 0 {
return fmt.Sprintf("%s%s", n.opts.base, ext)
}
return fmt.Sprintf("%s%d%s", n.opts.base, n.count, ext)
} | go | {
"resource": ""
} |
q13607 | Next | train | func (n *Namer) Next() *Namer {
if n.IsStart() {
n.count = n.opts.start
} else {
n.count++
}
return n
} | go | {
"resource": ""
} |
q13608 | Previous | train | func (n *Namer) Previous() *Namer {
if n.IsStart() {
log.Fatal("[F] Already at the start of the series")
}
if n.count <= n.opts.start {
n.count = n.opts.zero
} else {
n.count--
}
return n
} | go | {
"resource": ""
} |
q13609 | ToLowerString | train | func ToLowerString(befores []string) (afters []string) {
for _, name := range befores {
afters = append(afters, strings.ToLower(name))
}
return afters
} | go | {
"resource": ""
} |
q13610 | spaceDecompose | train | func spaceDecompose(str string) (space, key string) {
colon := strings.IndexByte(str, ':')
if colon == -1 {
return "", str
}
return str[:colon], str[colon+1:]
} | go | {
"resource": ""
} |
q13611 | NewOptions | train | func NewOptions() *Options {
// Default values
return &Options{
defaultHost: "http://www.example.com",
sitemapsHost: "", // http://s3.amazonaws.com/sitemap-generator/,
publicPath: "public/",
sitemapsPath: "sitemaps/",
filename: "sitemap",
verbose: true,
compress: true,
pretty: false,
adp: NewFileAdapter(),
}
} | go | {
"resource": ""
} |
q13612 | SitemapsHost | train | func (opts *Options) SitemapsHost() string {
if opts.sitemapsHost != "" {
return opts.sitemapsHost
}
return opts.defaultHost
} | go | {
"resource": ""
} |
q13613 | IndexLocation | train | func (opts *Options) IndexLocation() *Location {
o := opts.Clone()
o.nmr = NewNamer(&NOpts{base: opts.filename})
return NewLocation(o)
} | go | {
"resource": ""
} |
q13614 | Namer | train | func (opts *Options) Namer() *Namer {
if opts.nmr == nil {
opts.nmr = NewNamer(&NOpts{base: opts.filename, zero: 1, start: 2})
}
return opts.nmr
} | go | {
"resource": ""
} |
q13615 | gzip | train | func (adp *FileAdapter) gzip(file *os.File, data []byte) {
gz := gzip.NewWriter(file)
defer gz.Close()
gz.Write(data)
} | go | {
"resource": ""
} |
q13616 | plain | train | func (adp *FileAdapter) plain(file *os.File, data []byte) {
file.Write(data)
defer file.Close()
} | go | {
"resource": ""
} |
q13617 | NewSitemapIndexURL | train | func NewSitemapIndexURL(opts *Options, url URL) SitemapURL {
return &sitemapIndexURL{opts: opts, data: url}
} | go | {
"resource": ""
} |
q13618 | XML | train | func (su *sitemapIndexURL) XML() []byte {
doc := etree.NewDocument()
sitemap := doc.CreateElement("sitemap")
SetBuilderElementValue(sitemap, su.data, "loc")
if _, ok := SetBuilderElementValue(sitemap, su.data, "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
} | go | {
"resource": ""
} |
q13619 | NewBuilderFile | train | func NewBuilderFile(opts *Options, loc *Location) *BuilderFile {
b := &BuilderFile{opts: opts, loc: loc}
b.clear()
return b
} | go | {
"resource": ""
} |
q13620 | Add | train | func (b *BuilderFile) Add(url interface{}) BuilderError {
u := MergeMap(url.(URL),
URL{{"host", b.loc.opts.defaultHost}},
)
b.linkcnt++
smu, err := NewSitemapURL(b.opts, u)
if err != nil {
log.Fatalf("[F] Sitemap: %s", err)
}
bytes := smu.XML()
if !b.isFileCanFit(bytes) {
return &builderFileError{error: err, full: true}
}
b.content = append(b.content, bytes...)
return nil
} | go | {
"resource": ""
} |
q13621 | isFileCanFit | train | func (b *BuilderFile) isFileCanFit(bytes []byte) bool {
r := len(append(b.content, bytes...)) < MaxSitemapFilesize
r = r && b.linkcnt < MaxSitemapLinks
return r && b.newscnt < MaxSitemapNews
} | go | {
"resource": ""
} |
q13622 | XMLContent | train | func (b *BuilderFile) XMLContent() []byte {
c := bytes.Join(bytes.Fields(XMLHeader), []byte(" "))
c = append(append(c, b.Content()...), XMLFooter...)
return c
} | go | {
"resource": ""
} |
q13623 | Write | train | func (b *BuilderFile) Write() {
b.loc.ReserveName()
c := b.XMLContent()
b.loc.Write(c, b.linkcnt)
b.clear()
} | go | {
"resource": ""
} |
q13624 | PrivateKeyToCurve25519 | train | func PrivateKeyToCurve25519(curve25519Private *[32]byte, privateKey *[64]byte) {
h := sha512.New()
h.Write(privateKey[:32])
digest := h.Sum(nil)
digest[0] &= 248
digest[31] &= 127
digest[31] |= 64
copy(curve25519Private[:], digest)
} | go | {
"resource": ""
} |
q13625 | PublicKeyToCurve25519 | train | func PublicKeyToCurve25519(curve25519Public *[32]byte, publicKey *[32]byte) bool {
var A edwards25519.ExtendedGroupElement
if !A.FromBytes(publicKey) {
return false
}
// A.Z = 1 as a postcondition of FromBytes.
var x edwards25519.FieldElement
edwardsToMontgomeryX(&x, &A.Y)
edwards25519.FeToBytes(curve25519Public, &x)
return true
} | go | {
"resource": ""
} |
q13626 | feBytesLE | train | func feBytesLE(a, b *[32]byte) int32 {
equalSoFar := int32(-1)
greater := int32(0)
for i := uint(31); i < 32; i-- {
x := int32(a[i])
y := int32(b[i])
greater = (^equalSoFar & greater) | (equalSoFar & ((x - y) >> 31))
equalSoFar = equalSoFar & (((x ^ y) - 1) >> 31)
}
return int32(^equalSoFar & 1 & greater)
} | go | {
"resource": ""
} |
q13627 | RepresentativeToPublicKey | train | func RepresentativeToPublicKey(publicKey, representative *[32]byte) {
var rr2, v, e edwards25519.FieldElement
edwards25519.FeFromBytes(&rr2, representative)
edwards25519.FeSquare2(&rr2, &rr2)
rr2[0]++
edwards25519.FeInvert(&rr2, &rr2)
edwards25519.FeMul(&v, &edwards25519.A, &rr2)
edwards25519.FeNeg(&v, &v)
var v2, v3 edwards25519.FieldElement
edwards25519.FeSquare(&v2, &v)
edwards25519.FeMul(&v3, &v, &v2)
edwards25519.FeAdd(&e, &v3, &v)
edwards25519.FeMul(&v2, &v2, &edwards25519.A)
edwards25519.FeAdd(&e, &v2, &e)
chi(&e, &e)
var eBytes [32]byte
edwards25519.FeToBytes(&eBytes, &e)
// eBytes[1] is either 0 (for e = 1) 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, &v)
} | go | {
"resource": ""
} |
q13628 | equal | train | func equal(b, c int32) int32 {
x := uint32(b ^ c)
x--
return int32(x >> 31)
} | go | {
"resource": ""
} |
q13629 | Verify | train | func Verify(publicKey *[PublicKeySize]byte, message []byte, sig *[SignatureSize]byte) bool {
if sig[63]&224 != 0 {
return false
}
var A edwards25519.ExtendedGroupElement
if !A.FromBytes(publicKey) {
return false
}
edwards25519.FeNeg(&A.X, &A.X)
edwards25519.FeNeg(&A.T, &A.T)
h := sha512.New()
h.Write(sig[:32])
h.Write(publicKey[:])
h.Write(message)
var digest [64]byte
h.Sum(digest[:0])
var 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
} | go | {
"resource": ""
} |
q13630 | Parse | train | func (parser *myParser) Parse(s string) error {
typ := reflect.TypeOf(parser.ptr)
val := reflect.ValueOf(parser.ptr)
if typ.Kind() == reflect.Ptr {
kind := reflect.Indirect(val).Type().Kind()
if kind == reflect.Struct {
typElem, valElem := typ.Elem(), val.Elem()
numField := valElem.NumField()
for i := 0; i < numField; i++ {
_, valField := typElem.Field(i), valElem.Field(i)
if valField.Kind() == reflect.Int &&
valField.CanSet() {
valField.SetInt(2)
}
if valField.Kind() == reflect.String &&
valField.CanSet() {
valField.SetString("B")
}
}
}
}
return nil
} | go | {
"resource": ""
} |
q13631 | HelpCommandFn | train | func HelpCommandFn(ctx *Context) error {
var (
args = ctx.NativeArgs()
parent = ctx.Command().Parent()
)
if len(args) == 0 {
ctx.String(parent.Usage(ctx))
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
} | go | {
"resource": ""
} |
q13632 | HelpCommand | train | func HelpCommand(desc string) *Command {
return &Command{
Name: "help",
Desc: desc,
CanSubRoute: true,
NoHook: true,
Fn: HelpCommandFn,
}
} | go | {
"resource": ""
} |
q13633 | Daemon | train | func Daemon(ctx *Context, successPrefix string) error {
cmd := exec.Command(os.Args[0], ctx.NativeArgs()...)
serr, err := cmd.StderrPipe()
if err != nil {
return err
}
if err := cmd.Start(); err != nil {
return err
}
reader := bufio.NewReader(serr)
line, err := reader.ReadString('\n')
if err != nil {
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
} | go | {
"resource": ""
} |
q13634 | ReadJSON | train | func ReadJSON(r io.Reader, argv interface{}) error {
return json.NewDecoder(r).Decode(argv)
} | go | {
"resource": ""
} |
q13635 | ReadJSONFromFile | train | func ReadJSONFromFile(filename string, argv interface{}) error {
file, err := os.Open(filename)
if err == nil {
defer file.Close()
err = ReadJSON(file, argv)
}
return err
} | go | {
"resource": ""
} |
q13636 | ReadJSONConfigFromFile | train | func ReadJSONConfigFromFile(filename string, argv interface{}) error {
file, err := os.Open(filename)
if err == nil {
defer file.Close()
err = ReadJSON(file, argv)
} else {
exe, e := os.Executable()
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
} | go | {
"resource": ""
} |
q13637 | Decode | train | func (d *exampleDecoder) Decode(s string) error {
d.list = strings.Split(s, ",")
return nil
} | go | {
"resource": ""
} |
q13638 | Register | train | func (cmd *Command) Register(child *Command) *Command {
if child == nil {
debug.Panicf("command `%s` try register a nil command", cmd.Name)
}
if !IsValidCommandName(child.Name) {
debug.Panicf("illegal command name `%s`", cmd.Name)
}
if cmd.children == nil {
cmd.children = []*Command{}
}
if child.parent != nil {
debug.Panicf("command `%s` has been child of `%s`", child.Name, child.parent.Name)
}
if cmd.findChild(child.Name) != nil {
debug.Panicf("repeat register child `%s` for command `%s`", child.Name, cmd.Name)
}
if child.Aliases != nil {
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
} | go | {
"resource": ""
} |
q13639 | RegisterFunc | train | func (cmd *Command) RegisterFunc(name string, fn CommandFunc, argvFn ArgvFunc) *Command {
return cmd.Register(&Command{Name: name, Fn: fn, Argv: argvFn})
} | go | {
"resource": ""
} |
q13640 | RegisterTree | train | func (cmd *Command) RegisterTree(forest ...*CommandTree) {
for _, tree := range forest {
cmd.Register(tree.command)
if tree.forest != nil && len(tree.forest) > 0 {
tree.command.RegisterTree(tree.forest...)
}
}
} | go | {
"resource": ""
} |
q13641 | RunWith | train | func (cmd *Command) RunWith(args []string, writer io.Writer, resp http.ResponseWriter, httpMethods ...string) error {
fds := []uintptr{}
if writer == nil {
writer = colorable.NewColorableStdout()
fds = append(fds, os.Stdout.Fd())
}
clr := color.Color{}
colorSwitch(&clr, writer, fds...)
var ctx *Context
var suggestion string
ctx, suggestion, err := cmd.prepare(clr, args, writer, resp, httpMethods...)
if err == ExitError {
return nil
}
if err != nil {
if cmd.OnRootPrepareError != nil {
err = cmd.OnRootPrepareError(err)
}
if err != nil {
return wrapErr(err, suggestion, clr)
}
return nil
}
if ctx.command.NoHook {
return ctx.command.Fn(ctx)
}
funcs := []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
} | go | {
"resource": ""
} |
q13642 | Usage | train | func (cmd *Command) Usage(ctx *Context) string {
if cmd.UsageFn != nil {
return cmd.UsageFn()
}
return cmd.defaultUsageFn(ctx)
} | go | {
"resource": ""
} |
q13643 | Root | train | func (cmd *Command) Root() *Command {
ancestor := cmd
for ancestor.parent != nil {
ancestor = ancestor.parent
}
return ancestor
} | go | {
"resource": ""
} |
q13644 | Route | train | func (cmd *Command) Route(router []string) *Command {
child, end := cmd.SubRoute(router)
if end != len(router) {
return nil
}
return child
} | go | {
"resource": ""
} |
q13645 | SubRoute | train | func (cmd *Command) SubRoute(router []string) (*Command, int) {
cur := cmd
for i, name := range router {
child := cur.findChild(name)
if child == nil {
return cur, i
}
cur = child
}
return cur, len(router)
} | go | {
"resource": ""
} |
q13646 | findChild | train | func (cmd *Command) findChild(name string) *Command {
if cmd.nochild() {
return nil
}
for _, child := range cmd.children {
if child.Name == name {
return child
}
if child.Aliases != nil {
for _, alias := range child.Aliases {
if alias == name {
return child
}
}
}
}
return nil
} | go | {
"resource": ""
} |
q13647 | ListChildren | train | func (cmd *Command) ListChildren() []string {
if cmd.nochild() {
return []string{}
}
ret := make([]string, 0, len(cmd.children))
for _, child := range cmd.children {
ret = append(ret, child.Name)
}
return ret
} | go | {
"resource": ""
} |
q13648 | ChildrenDescriptions | train | func (cmd *Command) ChildrenDescriptions(prefix, indent string) string {
if cmd.nochild() {
return ""
}
buff := bytes.NewBufferString("")
length := 0
for _, child := range cmd.children {
if len(child.Name) > length {
length = len(child.Name)
}
}
format := fmt.Sprintf("%s%%-%ds%s%%s%%s\n", prefix, length, indent)
for _, child := range cmd.children {
aliases := ""
if child.Aliases != nil && len(child.Aliases) > 0 {
aliasesBuff := bytes.NewBufferString("(aliases ")
aliasesBuff.WriteString(strings.Join(child.Aliases, ","))
aliasesBuff.WriteString(")")
aliases = aliasesBuff.String()
}
fmt.Fprintf(buff, format, child.Name, child.Desc, aliases)
}
return buff.String()
} | go | {
"resource": ""
} |
q13649 | Suggestions | train | func (cmd *Command) Suggestions(path string) []string {
if cmd.parent != nil {
return cmd.Root().Suggestions(path)
}
var (
cmds = []*Command{cmd}
targets = []string{}
)
for len(cmds) > 0 {
if cmds[0].nochild() {
cmds = cmds[1:]
} else {
for _, child := range cmds[0].children {
targets = append(targets, child.Path())
}
cmds = append(cmds[0].children, cmds[1:]...)
}
}
dists := []editDistanceRank{}
for i, size := 0, 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)]
} | go | {
"resource": ""
} |
q13650 | SetReader | train | func (r *Reader) SetReader(reader io.Reader) {
r.Close()
r.reader = reader
if file, ok := reader.(*os.File); ok {
r.filename = file.Name()
} else {
r.filename = ""
}
} | go | {
"resource": ""
} |
q13651 | Read | train | func (r Reader) Read(data []byte) (n int, err error) {
if r.reader == nil {
return os.Stdin.Read(data)
}
return r.reader.Read(data)
} | go | {
"resource": ""
} |
q13652 | SetWriter | train | func (w *Writer) SetWriter(writer io.Writer) {
w.Close()
w.writer = writer
if file, ok := w.writer.(*os.File); ok {
w.filename = file.Name()
} else {
w.filename = ""
}
} | go | {
"resource": ""
} |
q13653 | Write | train | func (w *Writer) Write(data []byte) (n int, err error) {
if w.writer == nil {
if w.filename == "" {
w.writer = os.Stdout
w.filename = os.Stdout.Name()
} else {
file, err := os.Create(w.filename)
if err != nil {
return 0, err
}
w.writer = file
}
}
return w.writer.Write(data)
} | go | {
"resource": ""
} |
q13654 | NewLog | train | func NewLog(level string) (*log.Logger, error) {
lvl, err := colog.ParseLevel(level)
if err != nil {
return nil, err
}
cl := colog.NewCoLog(os.Stderr, "", log.Lshortfile|log.Ldate|log.Ltime)
cl.SetMinLevel(lvl)
cl.SetDefaultLevel(lvl)
lg := cl.NewLogger()
return lg, nil
} | go | {
"resource": ""
} |
q13655 | RegisterFlagParser | train | func RegisterFlagParser(name string, creator FlagParserCreator) {
if _, ok := parserCreators[name]; ok {
panic("RegisterFlagParser has registered: " + name)
}
parserCreators[name] = creator
} | go | {
"resource": ""
} |
q13656 | LaunchEditor | train | func LaunchEditor(editor string) (content []byte, err error) {
return launchEditorWithFilename(editor, randomFilename())
} | go | {
"resource": ""
} |
q13657 | NOpt | train | func (ctx *Context) NOpt() int {
if ctx.flagSet == nil || ctx.flagSet.flagSlice == nil {
return 0
}
n := 0
for _, fl := range ctx.flagSet.flagSlice {
if fl.isSet {
n++
}
}
return n
} | go | {
"resource": ""
} |
q13658 | Argv | train | func (ctx *Context) Argv() interface{} {
if ctx.argvList == nil || len(ctx.argvList) == 0 {
return nil
}
return ctx.argvList[0]
} | go | {
"resource": ""
} |
q13659 | RootArgv | train | func (ctx *Context) RootArgv() interface{} {
if isEmptyArgvList(ctx.argvList) {
return nil
}
index := len(ctx.argvList) - 1
return ctx.argvList[index]
} | go | {
"resource": ""
} |
q13660 | GetArgvList | train | func (ctx *Context) GetArgvList(curr interface{}, parents ...interface{}) error {
if isEmptyArgvList(ctx.argvList) {
return argvError{isEmpty: true}
}
for i, argv := range append([]interface{}{curr}, parents...) {
if argv == nil {
continue
}
if i >= len(ctx.argvList) {
return argvError{isOutOfRange: true}
}
if ctx.argvList[i] == nil {
return argvError{ith: i, msg: "source is nil"}
}
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
} | go | {
"resource": ""
} |
q13661 | GetArgvAt | train | func (ctx *Context) GetArgvAt(argv interface{}, i int) error {
if isEmptyArgvList(ctx.argvList) {
return argvError{isEmpty: true}
}
if argv == nil {
return errors.New("argv is nil")
}
if i >= len(ctx.argvList) {
return argvError{isOutOfRange: true}
}
if ctx.argvList[i] == nil {
return argvError{ith: 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)
} | go | {
"resource": ""
} |
q13662 | IsSet | train | func (ctx *Context) IsSet(flag string, aliasFlags ...string) bool {
fl, ok := ctx.flagSet.flagMap[flag]
if ok {
return fl.isSet
}
for _, alias := range aliasFlags {
if fl, ok := ctx.flagSet.flagMap[alias]; ok {
return fl.isSet
}
}
return false
} | go | {
"resource": ""
} |
q13663 | FormValues | train | func (ctx *Context) FormValues() url.Values {
if ctx.flagSet == nil {
debug.Panicf("ctx.flagSet == nil")
}
return ctx.flagSet.values
} | go | {
"resource": ""
} |
q13664 | Writer | train | func (ctx *Context) Writer() io.Writer {
if ctx.writer == nil {
ctx.writer = colorable.NewColorableStdout()
}
return ctx.writer
} | go | {
"resource": ""
} |
q13665 | String | train | func (ctx *Context) String(format string, args ...interface{}) *Context {
fmt.Fprintf(ctx.Writer(), format, args...)
return ctx
} | go | {
"resource": ""
} |
q13666 | JSON | train | func (ctx *Context) JSON(obj interface{}) *Context {
data, err := json.Marshal(obj)
if err == nil {
fmt.Fprint(ctx.Writer(), string(data))
}
return ctx
} | go | {
"resource": ""
} |
q13667 | JSONIndent | train | func (ctx *Context) JSONIndent(obj interface{}, prefix, indent string) *Context {
data, err := json.MarshalIndent(obj, prefix, indent)
if err == nil {
fmt.Fprint(ctx.Writer(), string(data))
}
return ctx
} | go | {
"resource": ""
} |
q13668 | JSONIndentln | train | func (ctx *Context) JSONIndentln(obj interface{}, prefix, indent string) *Context {
return ctx.JSONIndent(obj, prefix, indent).String("\n")
} | go | {
"resource": ""
} |
q13669 | Run | train | func Run(argv interface{}, fn CommandFunc, descs ...string) int {
return RunWithArgs(argv, os.Args, fn, descs...)
} | go | {
"resource": ""
} |
q13670 | RunWithArgs | train | func RunWithArgs(argv interface{}, args []string, fn CommandFunc, descs ...string) int {
desc := ""
if len(descs) > 0 {
desc = strings.Join(descs, "\n")
}
err := (&Command{
Name: args[0],
Desc: desc,
Argv: func() interface{} { return argv },
CanSubRoute: true,
Fn: fn,
}).Run(args[1:])
if err != nil {
fmt.Fprintln(os.Stderr, err)
return 1
}
return 0
} | go | {
"resource": ""
} |
q13671 | Root | train | func Root(root *Command, forest ...*CommandTree) *Command {
root.RegisterTree(forest...)
return root
} | go | {
"resource": ""
} |
q13672 | Tree | train | func Tree(cmd *Command, forest ...*CommandTree) *CommandTree {
return &CommandTree{
command: cmd,
forest: forest,
}
} | go | {
"resource": ""
} |
q13673 | Parse | train | func Parse(args []string, argv interface{}) error {
clr := color.Color{}
fset := parseArgv(args, argv, clr)
return fset.err
} | go | {
"resource": ""
} |
q13674 | Basename | train | func Basename(s string) string {
n := strings.LastIndexByte(s, '.')
if n > 0 {
return s[:n]
}
return s
} | go | {
"resource": ""
} |
q13675 | AbortOn | train | func AbortOn(errCase string, e error) {
if e != nil {
fmt.Fprintf(os.Stderr, "[%s] %s, %s: %v\n",
color.White(progname), color.Red("Error"), errCase, e)
os.Exit(1)
}
} | go | {
"resource": ""
} |
q13676 | Verbose | train | func Verbose(levelSet int, format string, args ...interface{}) {
if Opts.Verbose >= levelSet {
fmt.Fprintf(os.Stderr, "[%s] ", color.White(progname))
fmt.Fprintf(os.Stderr, format+"\n", args...)
}
} | go | {
"resource": ""
} |
q13677 | RegisterHTTP | train | func (cmd *Command) RegisterHTTP(ctxs ...*Context) error {
clr := color.Color{}
clr.Disable()
if len(ctxs) > 0 {
clr = ctxs[0].color
}
if cmd.routersMap == nil {
cmd.routersMap = make(map[string]string)
}
commands := []*Command{cmd}
for len(commands) > 0 {
c := commands[0]
commands = commands[1:]
if c.HTTPRouters != nil {
for _, r := range c.HTTPRouters {
if _, 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
} | go | {
"resource": ""
} |
q13678 | ServeHTTP | train | func (cmd *Command) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
return
}
var (
path = r.URL.Path
found = false
)
if cmd.routersMap != nil {
path, found = cmd.routersMap[path]
}
if !found {
path = strings.TrimPrefix(r.URL.Path, "/")
path = strings.TrimSuffix(path, "/")
}
router := strings.Split(path, "/")
args := make([]string, 0, len(r.Form)*2+len(router))
for _, r := range router {
args = append(args, r)
}
for key, values := range r.Form {
if len(key) == 0 || len(values) == 0 {
continue
}
if !strings.HasPrefix(key, dashOne) {
if len(key) == 1 {
key = dashOne + key
} else {
key = dashTwo + key
}
}
args = append(args, key, values[len(values)-1])
}
debug.Debugf("agent: %s", r.UserAgent())
debug.Debugf("path: %s", path)
debug.Debugf("args: %q", args)
buf := 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.StatusNotFound
case methodNotAllowedError:
statusCode = http.StatusMethodNotAllowed
default:
statusCode = http.StatusInternalServerError
}
}
debug.Debugf("resp: %s", buf.String())
w.WriteHeader(statusCode)
w.Write(buf.Bytes())
} | go | {
"resource": ""
} |
q13679 | ListenAndServeHTTP | train | func (cmd *Command) ListenAndServeHTTP(addr string) error {
cmd.SetIsServer(true)
return http.ListenAndServe(addr, cmd)
} | go | {
"resource": ""
} |
q13680 | Serve | train | func (cmd *Command) Serve(listeners ...net.Listener) (err error) {
cmd.SetIsServer(true)
var g sync.WaitGroup
for _, ln := range listeners {
g.Add(1)
go func(ln net.Listener) {
if e := http.Serve(ln, cmd); e != nil {
panic(e.Error())
}
g.Done()
}(ln)
}
g.Wait()
return
} | go | {
"resource": ""
} |
q13681 | RPC | train | func (cmd *Command) RPC(httpc *http.Client, ctx *Context) error {
addr := "http://rpc/" + ctx.Command().pathWithSep("/")
method := "POST"
if cmd.HTTPMethods != nil && len(cmd.HTTPMethods) > 0 {
method = cmd.HTTPMethods[0]
}
var body io.Reader
if values := ctx.FormValues(); values != 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.Body.Close()
_, err = io.Copy(ctx, resp.Body)
return err
} | go | {
"resource": ""
} |
q13682 | InstallBashCompletion | train | func InstallBashCompletion(root *cli.Command) error {
if root.Name == "" {
return fmt.Errorf("root command's name is empty")
}
compFilename := "." + root.Name + "_compeltion"
compFilepath := filepath.Join(os.Getenv("HOME"), compFilename)
compFile, err := os.OpenFile(compFilepath, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0666)
if err != nil {
return err
}
buff, err := genBashCompletion(root)
if err != nil {
return err
}
if _, err := compFile.Write(buff.Bytes()); err != nil {
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
}
}
if dstFile == nil {
return fmt.Errorf("no destination bash file")
}
data, err := ioutil.ReadAll(dstFile)
if err != nil {
return err
}
subslice := fmt.Sprintf("[ -f ~/%s ] && . ~/%s", compFilename, compFilename)
if !bytes.Contains(data, []byte(subslice)) {
_, err = dstFile.WriteString("\n#Auto-generated by cli\n" + subslice)
}
return err
} | go | {
"resource": ""
} |
q13683 | Validate | train | func (argv *argT) Validate(ctx *cli.Context) error {
if argv.Age < 0 || argv.Age > 300 {
return fmt.Errorf("age %d out of range", argv.Age)
}
if argv.Gender != "male" && argv.Gender != "female" {
return fmt.Errorf("invalid gender %s", ctx.Color().Yellow(argv.Gender))
}
return nil
} | go | {
"resource": ""
} |
q13684 | New | train | func New() *NUID {
n := &NUID{
seq: prand.Int63n(maxSeq),
inc: minInc + prand.Int63n(maxInc-minInc),
pre: make([]byte, preLen),
}
n.RandomizePrefix()
return n
} | go | {
"resource": ""
} |
q13685 | Next | train | func Next() string {
globalNUID.Lock()
nuid := globalNUID.Next()
globalNUID.Unlock()
return nuid
} | go | {
"resource": ""
} |
q13686 | Next | train | func (n *NUID) Next() string {
// Increment and capture.
n.seq += n.inc
if n.seq >= maxSeq {
n.RandomizePrefix()
n.resetSequential()
}
seq := n.seq
// Copy prefix
var b [totalLen]byte
bs := b[:preLen]
copy(bs, n.pre)
// 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[:])
} | go | {
"resource": ""
} |
q13687 | resetSequential | train | func (n *NUID) resetSequential() {
n.seq = prand.Int63n(maxSeq)
n.inc = minInc + prand.Int63n(maxInc-minInc)
} | go | {
"resource": ""
} |
q13688 | AddCmd | train | func (c *Cmd) AddCmd(cmd *Cmd) {
if c.children == nil {
c.children = make(map[string]*Cmd)
}
c.children[cmd.Name] = cmd
} | go | {
"resource": ""
} |
q13689 | Children | train | func (c *Cmd) Children() []*Cmd {
var cmds []*Cmd
for _, cmd := range c.children {
cmds = append(cmds, cmd)
}
sort.Sort(cmdSorter(cmds))
return cmds
} | go | {
"resource": ""
} |
q13690 | HelpText | train | func (c Cmd) HelpText() string {
var b bytes.Buffer
p := func(s ...interface{}) {
fmt.Fprintln(&b)
if len(s) > 0 {
fmt.Fprintln(&b, s...)
}
}
if c.LongHelp != "" {
p(c.LongHelp)
} else if c.Help != "" {
p(c.Help)
} else if c.Name != "" {
p(c.Name, "has no help")
}
if c.hasSubcommand() {
p("Commands:")
w := tabwriter.NewWriter(&b, 0, 4, 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()
} | go | {
"resource": ""
} |
q13691 | findChildCmd | train | func (c *Cmd) findChildCmd(name string) *Cmd {
// find perfect matches first
if cmd, ok := c.children[name]; ok {
return cmd
}
// find alias matching the name
for _, cmd := range c.children {
for _, alias := range cmd.Aliases {
if alias == name {
return cmd
}
}
}
return nil
} | go | {
"resource": ""
} |
q13692 | FindCmd | train | func (c Cmd) FindCmd(args []string) (*Cmd, []string) {
var cmd *Cmd
for i, arg := range args {
if cmd1 := c.findChildCmd(arg); cmd1 != nil {
cmd = cmd1
c = *cmd
continue
}
return cmd, args[i:]
}
return cmd, nil
} | go | {
"resource": ""
} |
q13693 | NewWithConfig | train | func NewWithConfig(conf *readline.Config) *Shell {
rl, err := readline.NewEx(conf)
if err != nil {
log.Println("Shell or operating system not supported.")
log.Fatal(err)
}
return NewWithReadline(rl)
} | go | {
"resource": ""
} |
q13694 | NewWithReadline | train | func NewWithReadline(rl *readline.Instance) *Shell {
shell := &Shell{
rootCmd: &Cmd{},
reader: &shellReader{
scanner: rl,
prompt: rl.Config.Prompt,
multiPrompt: defaultMultiPrompt,
showPrompt: true,
buf: &bytes.Buffer{},
completer: readline.NewPrefixCompleter(),
},
writer: rl.Config.Stdout,
autoHelp: true,
}
shell.Actions = &shellActionsImpl{Shell: shell}
shell.progressBar = newProgressBar(shell)
addDefaultFuncs(shell)
return shell
} | go | {
"resource": ""
} |
q13695 | Active | train | func (s *Shell) Active() bool {
s.activeMutex.RLock()
defer s.activeMutex.RUnlock()
return s.active
} | go | {
"resource": ""
} |
q13696 | CustomCompleter | train | func (s *Shell) CustomCompleter(completer readline.AutoCompleter) {
s.customCompleter = true
s.setCompleter(completer)
} | go | {
"resource": ""
} |
q13697 | SetHistoryPath | train | func (s *Shell) SetHistoryPath(path string) {
// Using scanner.SetHistoryPath doesn't initialize things properly and
// history file 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)
} | go | {
"resource": ""
} |
q13698 | SetHomeHistoryPath | train | func (s *Shell) SetHomeHistoryPath(path string) {
home := os.Getenv("HOME")
if runtime.GOOS == "windows" {
home = os.Getenv("USERPROFILE")
}
abspath := filepath.Join(home, path)
s.SetHistoryPath(abspath)
} | go | {
"resource": ""
} |
q13699 | SetPager | train | func (s *Shell) SetPager(pager string, args []string) {
s.pager = pager
s.pagerArgs = args
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.