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
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
148,900 |
magefile/mage
|
mage/main.go
|
Magefiles
|
func Magefiles(magePath, goos, goarch, goCmd string, stderr io.Writer, isDebug bool) ([]string, error) {
start := time.Now()
defer func() {
debug.Println("time to scan for Magefiles:", time.Since(start))
}()
fail := func(err error) ([]string, error) {
return nil, err
}
env, err := internal.EnvWithGOOS(goos, goarch)
if err != nil {
return nil, err
}
debug.Println("getting all non-mage files in", magePath)
// // first, grab all the files with no build tags specified.. this is actually
// // our exclude list of things without the mage build tag.
cmd := exec.Command(goCmd, "list", "-e", "-f", `{{join .GoFiles "||"}}`)
cmd.Env = env
if isDebug {
cmd.Stderr = stderr
}
cmd.Dir = magePath
b, err := cmd.Output()
if err != nil {
return fail(fmt.Errorf("failed to list non-mage gofiles: %v", err))
}
list := strings.TrimSpace(string(b))
debug.Println("found non-mage files", list)
exclude := map[string]bool{}
for _, f := range strings.Split(list, "||") {
if f != "" {
debug.Printf("marked file as non-mage: %q", f)
exclude[f] = true
}
}
debug.Println("getting all files plus mage files")
cmd = exec.Command(goCmd, "list", "-tags=mage", "-e", "-f", `{{join .GoFiles "||"}}`)
cmd.Env = env
if isDebug {
cmd.Stderr = stderr
}
cmd.Dir = magePath
b, err = cmd.Output()
if err != nil {
return fail(fmt.Errorf("failed to list mage gofiles: %v", err))
}
list = strings.TrimSpace(string(b))
files := []string{}
for _, f := range strings.Split(list, "||") {
if f != "" && !exclude[f] {
files = append(files, f)
}
}
for i := range files {
files[i] = filepath.Join(magePath, files[i])
}
return files, nil
}
|
go
|
func Magefiles(magePath, goos, goarch, goCmd string, stderr io.Writer, isDebug bool) ([]string, error) {
start := time.Now()
defer func() {
debug.Println("time to scan for Magefiles:", time.Since(start))
}()
fail := func(err error) ([]string, error) {
return nil, err
}
env, err := internal.EnvWithGOOS(goos, goarch)
if err != nil {
return nil, err
}
debug.Println("getting all non-mage files in", magePath)
// // first, grab all the files with no build tags specified.. this is actually
// // our exclude list of things without the mage build tag.
cmd := exec.Command(goCmd, "list", "-e", "-f", `{{join .GoFiles "||"}}`)
cmd.Env = env
if isDebug {
cmd.Stderr = stderr
}
cmd.Dir = magePath
b, err := cmd.Output()
if err != nil {
return fail(fmt.Errorf("failed to list non-mage gofiles: %v", err))
}
list := strings.TrimSpace(string(b))
debug.Println("found non-mage files", list)
exclude := map[string]bool{}
for _, f := range strings.Split(list, "||") {
if f != "" {
debug.Printf("marked file as non-mage: %q", f)
exclude[f] = true
}
}
debug.Println("getting all files plus mage files")
cmd = exec.Command(goCmd, "list", "-tags=mage", "-e", "-f", `{{join .GoFiles "||"}}`)
cmd.Env = env
if isDebug {
cmd.Stderr = stderr
}
cmd.Dir = magePath
b, err = cmd.Output()
if err != nil {
return fail(fmt.Errorf("failed to list mage gofiles: %v", err))
}
list = strings.TrimSpace(string(b))
files := []string{}
for _, f := range strings.Split(list, "||") {
if f != "" && !exclude[f] {
files = append(files, f)
}
}
for i := range files {
files[i] = filepath.Join(magePath, files[i])
}
return files, nil
}
|
[
"func",
"Magefiles",
"(",
"magePath",
",",
"goos",
",",
"goarch",
",",
"goCmd",
"string",
",",
"stderr",
"io",
".",
"Writer",
",",
"isDebug",
"bool",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"time",
".",
"Since",
"(",
"start",
")",
")",
"\n",
"}",
"(",
")",
"\n",
"fail",
":=",
"func",
"(",
"err",
"error",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"env",
",",
"err",
":=",
"internal",
".",
"EnvWithGOOS",
"(",
"goos",
",",
"goarch",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"magePath",
")",
"\n",
"// // first, grab all the files with no build tags specified.. this is actually",
"// // our exclude list of things without the mage build tag.",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"goCmd",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"`{{join .GoFiles \"||\"}}`",
")",
"\n",
"cmd",
".",
"Env",
"=",
"env",
"\n",
"if",
"isDebug",
"{",
"cmd",
".",
"Stderr",
"=",
"stderr",
"\n",
"}",
"\n",
"cmd",
".",
"Dir",
"=",
"magePath",
"\n",
"b",
",",
"err",
":=",
"cmd",
".",
"Output",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fail",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"list",
":=",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"b",
")",
")",
"\n",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"list",
")",
"\n",
"exclude",
":=",
"map",
"[",
"string",
"]",
"bool",
"{",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"strings",
".",
"Split",
"(",
"list",
",",
"\"",
"\"",
")",
"{",
"if",
"f",
"!=",
"\"",
"\"",
"{",
"debug",
".",
"Printf",
"(",
"\"",
"\"",
",",
"f",
")",
"\n",
"exclude",
"[",
"f",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"debug",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"goCmd",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"`{{join .GoFiles \"||\"}}`",
")",
"\n",
"cmd",
".",
"Env",
"=",
"env",
"\n\n",
"if",
"isDebug",
"{",
"cmd",
".",
"Stderr",
"=",
"stderr",
"\n",
"}",
"\n",
"cmd",
".",
"Dir",
"=",
"magePath",
"\n",
"b",
",",
"err",
"=",
"cmd",
".",
"Output",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fail",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n\n",
"list",
"=",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"b",
")",
")",
"\n",
"files",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"strings",
".",
"Split",
"(",
"list",
",",
"\"",
"\"",
")",
"{",
"if",
"f",
"!=",
"\"",
"\"",
"&&",
"!",
"exclude",
"[",
"f",
"]",
"{",
"files",
"=",
"append",
"(",
"files",
",",
"f",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"files",
"{",
"files",
"[",
"i",
"]",
"=",
"filepath",
".",
"Join",
"(",
"magePath",
",",
"files",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"return",
"files",
",",
"nil",
"\n",
"}"
] |
// Magefiles returns the list of magefiles in dir.
|
[
"Magefiles",
"returns",
"the",
"list",
"of",
"magefiles",
"in",
"dir",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/mage/main.go#L411-L471
|
148,901 |
magefile/mage
|
mage/main.go
|
Compile
|
func Compile(goos, goarch, magePath, goCmd, compileTo string, gofiles []string, isDebug bool, stderr, stdout io.Writer) error {
debug.Println("compiling to", compileTo)
debug.Println("compiling using gocmd:", goCmd)
if isDebug {
internal.RunDebug(goCmd, "version")
internal.RunDebug(goCmd, "env")
}
environ, err := internal.EnvWithGOOS(goos, goarch)
if err != nil {
return err
}
// strip off the path since we're setting the path in the build command
for i := range gofiles {
gofiles[i] = filepath.Base(gofiles[i])
}
debug.Printf("running %s build -o %s %s", goCmd, compileTo, strings.Join(gofiles, " "))
c := exec.Command(goCmd, append([]string{"build", "-o", compileTo}, gofiles...)...)
c.Env = environ
c.Stderr = stderr
c.Stdout = stdout
c.Dir = magePath
start := time.Now()
err = c.Run()
debug.Println("time to compile Magefile:", time.Since(start))
if err != nil {
return errors.New("error compiling magefiles")
}
return nil
}
|
go
|
func Compile(goos, goarch, magePath, goCmd, compileTo string, gofiles []string, isDebug bool, stderr, stdout io.Writer) error {
debug.Println("compiling to", compileTo)
debug.Println("compiling using gocmd:", goCmd)
if isDebug {
internal.RunDebug(goCmd, "version")
internal.RunDebug(goCmd, "env")
}
environ, err := internal.EnvWithGOOS(goos, goarch)
if err != nil {
return err
}
// strip off the path since we're setting the path in the build command
for i := range gofiles {
gofiles[i] = filepath.Base(gofiles[i])
}
debug.Printf("running %s build -o %s %s", goCmd, compileTo, strings.Join(gofiles, " "))
c := exec.Command(goCmd, append([]string{"build", "-o", compileTo}, gofiles...)...)
c.Env = environ
c.Stderr = stderr
c.Stdout = stdout
c.Dir = magePath
start := time.Now()
err = c.Run()
debug.Println("time to compile Magefile:", time.Since(start))
if err != nil {
return errors.New("error compiling magefiles")
}
return nil
}
|
[
"func",
"Compile",
"(",
"goos",
",",
"goarch",
",",
"magePath",
",",
"goCmd",
",",
"compileTo",
"string",
",",
"gofiles",
"[",
"]",
"string",
",",
"isDebug",
"bool",
",",
"stderr",
",",
"stdout",
"io",
".",
"Writer",
")",
"error",
"{",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"compileTo",
")",
"\n",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"goCmd",
")",
"\n",
"if",
"isDebug",
"{",
"internal",
".",
"RunDebug",
"(",
"goCmd",
",",
"\"",
"\"",
")",
"\n",
"internal",
".",
"RunDebug",
"(",
"goCmd",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"environ",
",",
"err",
":=",
"internal",
".",
"EnvWithGOOS",
"(",
"goos",
",",
"goarch",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"// strip off the path since we're setting the path in the build command",
"for",
"i",
":=",
"range",
"gofiles",
"{",
"gofiles",
"[",
"i",
"]",
"=",
"filepath",
".",
"Base",
"(",
"gofiles",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"debug",
".",
"Printf",
"(",
"\"",
"\"",
",",
"goCmd",
",",
"compileTo",
",",
"strings",
".",
"Join",
"(",
"gofiles",
",",
"\"",
"\"",
")",
")",
"\n",
"c",
":=",
"exec",
".",
"Command",
"(",
"goCmd",
",",
"append",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"compileTo",
"}",
",",
"gofiles",
"...",
")",
"...",
")",
"\n",
"c",
".",
"Env",
"=",
"environ",
"\n",
"c",
".",
"Stderr",
"=",
"stderr",
"\n",
"c",
".",
"Stdout",
"=",
"stdout",
"\n",
"c",
".",
"Dir",
"=",
"magePath",
"\n",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"err",
"=",
"c",
".",
"Run",
"(",
")",
"\n",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"time",
".",
"Since",
"(",
"start",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Compile uses the go tool to compile the files into an executable at path.
|
[
"Compile",
"uses",
"the",
"go",
"tool",
"to",
"compile",
"the",
"files",
"into",
"an",
"executable",
"at",
"path",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/mage/main.go#L474-L502
|
148,902 |
magefile/mage
|
mage/main.go
|
GenerateMainfile
|
func GenerateMainfile(binaryName, path string, info *parse.PkgInfo) error {
debug.Println("Creating mainfile at", path)
f, err := os.Create(path)
if err != nil {
return fmt.Errorf("error creating generated mainfile: %v", err)
}
defer f.Close()
data := mainfileTemplateData{
Description: info.Description,
Funcs: info.Funcs,
Aliases: info.Aliases,
Imports: info.Imports,
BinaryName: binaryName,
}
if info.DefaultFunc != nil {
data.DefaultFunc = *info.DefaultFunc
}
debug.Println("writing new file at", path)
if err := mainfileTemplate.Execute(f, data); err != nil {
return fmt.Errorf("can't execute mainfile template: %v", err)
}
if err := f.Close(); err != nil {
return fmt.Errorf("error closing generated mainfile: %v", err)
}
// we set an old modtime on the generated mainfile so that the go tool
// won't think it has changed more recently than the compiled binary.
longAgo := time.Now().Add(-time.Hour * 24 * 365 * 10)
if err := os.Chtimes(path, longAgo, longAgo); err != nil {
return fmt.Errorf("error setting old modtime on generated mainfile: %v", err)
}
return nil
}
|
go
|
func GenerateMainfile(binaryName, path string, info *parse.PkgInfo) error {
debug.Println("Creating mainfile at", path)
f, err := os.Create(path)
if err != nil {
return fmt.Errorf("error creating generated mainfile: %v", err)
}
defer f.Close()
data := mainfileTemplateData{
Description: info.Description,
Funcs: info.Funcs,
Aliases: info.Aliases,
Imports: info.Imports,
BinaryName: binaryName,
}
if info.DefaultFunc != nil {
data.DefaultFunc = *info.DefaultFunc
}
debug.Println("writing new file at", path)
if err := mainfileTemplate.Execute(f, data); err != nil {
return fmt.Errorf("can't execute mainfile template: %v", err)
}
if err := f.Close(); err != nil {
return fmt.Errorf("error closing generated mainfile: %v", err)
}
// we set an old modtime on the generated mainfile so that the go tool
// won't think it has changed more recently than the compiled binary.
longAgo := time.Now().Add(-time.Hour * 24 * 365 * 10)
if err := os.Chtimes(path, longAgo, longAgo); err != nil {
return fmt.Errorf("error setting old modtime on generated mainfile: %v", err)
}
return nil
}
|
[
"func",
"GenerateMainfile",
"(",
"binaryName",
",",
"path",
"string",
",",
"info",
"*",
"parse",
".",
"PkgInfo",
")",
"error",
"{",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"path",
")",
"\n\n",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"data",
":=",
"mainfileTemplateData",
"{",
"Description",
":",
"info",
".",
"Description",
",",
"Funcs",
":",
"info",
".",
"Funcs",
",",
"Aliases",
":",
"info",
".",
"Aliases",
",",
"Imports",
":",
"info",
".",
"Imports",
",",
"BinaryName",
":",
"binaryName",
",",
"}",
"\n\n",
"if",
"info",
".",
"DefaultFunc",
"!=",
"nil",
"{",
"data",
".",
"DefaultFunc",
"=",
"*",
"info",
".",
"DefaultFunc",
"\n",
"}",
"\n\n",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"if",
"err",
":=",
"mainfileTemplate",
".",
"Execute",
"(",
"f",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"f",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"// we set an old modtime on the generated mainfile so that the go tool",
"// won't think it has changed more recently than the compiled binary.",
"longAgo",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"-",
"time",
".",
"Hour",
"*",
"24",
"*",
"365",
"*",
"10",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"Chtimes",
"(",
"path",
",",
"longAgo",
",",
"longAgo",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// GenerateMainfile generates the mage mainfile at path.
|
[
"GenerateMainfile",
"generates",
"the",
"mage",
"mainfile",
"at",
"path",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/mage/main.go#L505-L539
|
148,903 |
magefile/mage
|
mage/main.go
|
ExeName
|
func ExeName(goCmd, cacheDir string, files []string) (string, error) {
var hashes []string
for _, s := range files {
h, err := hashFile(s)
if err != nil {
return "", err
}
hashes = append(hashes, h)
}
// hash the mainfile template to ensure if it gets updated, we make a new
// binary.
hashes = append(hashes, fmt.Sprintf("%x", sha1.Sum([]byte(mageMainfileTplString))))
sort.Strings(hashes)
ver, err := internal.OutputDebug(goCmd, "version")
if err != nil {
return "", err
}
hash := sha1.Sum([]byte(strings.Join(hashes, "") + magicRebuildKey + ver))
filename := fmt.Sprintf("%x", hash)
out := filepath.Join(cacheDir, filename)
if runtime.GOOS == "windows" {
out += ".exe"
}
return out, nil
}
|
go
|
func ExeName(goCmd, cacheDir string, files []string) (string, error) {
var hashes []string
for _, s := range files {
h, err := hashFile(s)
if err != nil {
return "", err
}
hashes = append(hashes, h)
}
// hash the mainfile template to ensure if it gets updated, we make a new
// binary.
hashes = append(hashes, fmt.Sprintf("%x", sha1.Sum([]byte(mageMainfileTplString))))
sort.Strings(hashes)
ver, err := internal.OutputDebug(goCmd, "version")
if err != nil {
return "", err
}
hash := sha1.Sum([]byte(strings.Join(hashes, "") + magicRebuildKey + ver))
filename := fmt.Sprintf("%x", hash)
out := filepath.Join(cacheDir, filename)
if runtime.GOOS == "windows" {
out += ".exe"
}
return out, nil
}
|
[
"func",
"ExeName",
"(",
"goCmd",
",",
"cacheDir",
"string",
",",
"files",
"[",
"]",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"hashes",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"files",
"{",
"h",
",",
"err",
":=",
"hashFile",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"hashes",
"=",
"append",
"(",
"hashes",
",",
"h",
")",
"\n",
"}",
"\n",
"// hash the mainfile template to ensure if it gets updated, we make a new",
"// binary.",
"hashes",
"=",
"append",
"(",
"hashes",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"sha1",
".",
"Sum",
"(",
"[",
"]",
"byte",
"(",
"mageMainfileTplString",
")",
")",
")",
")",
"\n",
"sort",
".",
"Strings",
"(",
"hashes",
")",
"\n",
"ver",
",",
"err",
":=",
"internal",
".",
"OutputDebug",
"(",
"goCmd",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"hash",
":=",
"sha1",
".",
"Sum",
"(",
"[",
"]",
"byte",
"(",
"strings",
".",
"Join",
"(",
"hashes",
",",
"\"",
"\"",
")",
"+",
"magicRebuildKey",
"+",
"ver",
")",
")",
"\n",
"filename",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"hash",
")",
"\n\n",
"out",
":=",
"filepath",
".",
"Join",
"(",
"cacheDir",
",",
"filename",
")",
"\n",
"if",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"{",
"out",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// ExeName reports the executable filename that this version of Mage would
// create for the given magefiles.
|
[
"ExeName",
"reports",
"the",
"executable",
"filename",
"that",
"this",
"version",
"of",
"Mage",
"would",
"create",
"for",
"the",
"given",
"magefiles",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/mage/main.go#L543-L568
|
148,904 |
magefile/mage
|
mage/main.go
|
RunCompiled
|
func RunCompiled(inv Invocation, exePath string, errlog *log.Logger) int {
debug.Println("running binary", exePath)
c := exec.Command(exePath, inv.Args...)
c.Stderr = inv.Stderr
c.Stdout = inv.Stdout
c.Stdin = inv.Stdin
c.Dir = inv.Dir
// intentionally pass through unaltered os.Environ here.. your magefile has
// to deal with it.
c.Env = os.Environ()
if inv.Verbose {
c.Env = append(c.Env, "MAGEFILE_VERBOSE=1")
}
if inv.List {
c.Env = append(c.Env, "MAGEFILE_LIST=1")
}
if inv.Help {
c.Env = append(c.Env, "MAGEFILE_HELP=1")
}
if inv.Debug {
c.Env = append(c.Env, "MAGEFILE_DEBUG=1")
}
if inv.GoCmd != "" {
c.Env = append(c.Env, fmt.Sprintf("MAGEFILE_GOCMD=%s", inv.GoCmd))
}
if inv.Timeout > 0 {
c.Env = append(c.Env, fmt.Sprintf("MAGEFILE_TIMEOUT=%s", inv.Timeout.String()))
}
debug.Print("running magefile with mage vars:\n", strings.Join(filter(c.Env, "MAGEFILE"), "\n"))
err := c.Run()
if !sh.CmdRan(err) {
errlog.Printf("failed to run compiled magefile: %v", err)
}
return sh.ExitStatus(err)
}
|
go
|
func RunCompiled(inv Invocation, exePath string, errlog *log.Logger) int {
debug.Println("running binary", exePath)
c := exec.Command(exePath, inv.Args...)
c.Stderr = inv.Stderr
c.Stdout = inv.Stdout
c.Stdin = inv.Stdin
c.Dir = inv.Dir
// intentionally pass through unaltered os.Environ here.. your magefile has
// to deal with it.
c.Env = os.Environ()
if inv.Verbose {
c.Env = append(c.Env, "MAGEFILE_VERBOSE=1")
}
if inv.List {
c.Env = append(c.Env, "MAGEFILE_LIST=1")
}
if inv.Help {
c.Env = append(c.Env, "MAGEFILE_HELP=1")
}
if inv.Debug {
c.Env = append(c.Env, "MAGEFILE_DEBUG=1")
}
if inv.GoCmd != "" {
c.Env = append(c.Env, fmt.Sprintf("MAGEFILE_GOCMD=%s", inv.GoCmd))
}
if inv.Timeout > 0 {
c.Env = append(c.Env, fmt.Sprintf("MAGEFILE_TIMEOUT=%s", inv.Timeout.String()))
}
debug.Print("running magefile with mage vars:\n", strings.Join(filter(c.Env, "MAGEFILE"), "\n"))
err := c.Run()
if !sh.CmdRan(err) {
errlog.Printf("failed to run compiled magefile: %v", err)
}
return sh.ExitStatus(err)
}
|
[
"func",
"RunCompiled",
"(",
"inv",
"Invocation",
",",
"exePath",
"string",
",",
"errlog",
"*",
"log",
".",
"Logger",
")",
"int",
"{",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"exePath",
")",
"\n",
"c",
":=",
"exec",
".",
"Command",
"(",
"exePath",
",",
"inv",
".",
"Args",
"...",
")",
"\n",
"c",
".",
"Stderr",
"=",
"inv",
".",
"Stderr",
"\n",
"c",
".",
"Stdout",
"=",
"inv",
".",
"Stdout",
"\n",
"c",
".",
"Stdin",
"=",
"inv",
".",
"Stdin",
"\n",
"c",
".",
"Dir",
"=",
"inv",
".",
"Dir",
"\n",
"// intentionally pass through unaltered os.Environ here.. your magefile has",
"// to deal with it.",
"c",
".",
"Env",
"=",
"os",
".",
"Environ",
"(",
")",
"\n",
"if",
"inv",
".",
"Verbose",
"{",
"c",
".",
"Env",
"=",
"append",
"(",
"c",
".",
"Env",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"inv",
".",
"List",
"{",
"c",
".",
"Env",
"=",
"append",
"(",
"c",
".",
"Env",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"inv",
".",
"Help",
"{",
"c",
".",
"Env",
"=",
"append",
"(",
"c",
".",
"Env",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"inv",
".",
"Debug",
"{",
"c",
".",
"Env",
"=",
"append",
"(",
"c",
".",
"Env",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"inv",
".",
"GoCmd",
"!=",
"\"",
"\"",
"{",
"c",
".",
"Env",
"=",
"append",
"(",
"c",
".",
"Env",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"inv",
".",
"GoCmd",
")",
")",
"\n",
"}",
"\n",
"if",
"inv",
".",
"Timeout",
">",
"0",
"{",
"c",
".",
"Env",
"=",
"append",
"(",
"c",
".",
"Env",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"inv",
".",
"Timeout",
".",
"String",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"debug",
".",
"Print",
"(",
"\"",
"\\n",
"\"",
",",
"strings",
".",
"Join",
"(",
"filter",
"(",
"c",
".",
"Env",
",",
"\"",
"\"",
")",
",",
"\"",
"\\n",
"\"",
")",
")",
"\n",
"err",
":=",
"c",
".",
"Run",
"(",
")",
"\n",
"if",
"!",
"sh",
".",
"CmdRan",
"(",
"err",
")",
"{",
"errlog",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"sh",
".",
"ExitStatus",
"(",
"err",
")",
"\n",
"}"
] |
// RunCompiled runs an already-compiled mage command with the given args,
|
[
"RunCompiled",
"runs",
"an",
"already",
"-",
"compiled",
"mage",
"command",
"with",
"the",
"given",
"args"
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/mage/main.go#L600-L634
|
148,905 |
magefile/mage
|
mage/main.go
|
removeContents
|
func removeContents(dir string) error {
debug.Println("removing all files in", dir)
files, err := ioutil.ReadDir(dir)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
for _, f := range files {
if f.IsDir() {
continue
}
err = os.Remove(filepath.Join(dir, f.Name()))
if err != nil {
return err
}
}
return nil
}
|
go
|
func removeContents(dir string) error {
debug.Println("removing all files in", dir)
files, err := ioutil.ReadDir(dir)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
for _, f := range files {
if f.IsDir() {
continue
}
err = os.Remove(filepath.Join(dir, f.Name()))
if err != nil {
return err
}
}
return nil
}
|
[
"func",
"removeContents",
"(",
"dir",
"string",
")",
"error",
"{",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"dir",
")",
"\n",
"files",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"dir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"files",
"{",
"if",
"f",
".",
"IsDir",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"os",
".",
"Remove",
"(",
"filepath",
".",
"Join",
"(",
"dir",
",",
"f",
".",
"Name",
"(",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n\n",
"}"
] |
// removeContents removes all files but not any subdirectories in the given
// directory.
|
[
"removeContents",
"removes",
"all",
"files",
"but",
"not",
"any",
"subdirectories",
"in",
"the",
"given",
"directory",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/mage/main.go#L648-L668
|
148,906 |
magefile/mage
|
magefile.go
|
Install
|
func Install() error {
name := "mage"
if runtime.GOOS == "windows" {
name += ".exe"
}
gocmd := mg.GoCmd()
// use GOBIN if set in the environment, otherwise fall back to first path
// in GOPATH environment string
bin, err := sh.Output(gocmd, "env", "GOBIN")
if err != nil {
return fmt.Errorf("can't determine GOBIN: %v", err)
}
if bin == "" {
gopath, err := sh.Output(gocmd, "env", "GOPATH")
if err != nil {
return fmt.Errorf("can't determine GOPATH: %v", err)
}
paths := strings.Split(gopath, string([]rune{os.PathListSeparator}))
bin = filepath.Join(paths[0], "bin")
}
// specifically don't mkdirall, if you have an invalid gopath in the first
// place, that's not on us to fix.
if err := os.Mkdir(bin, 0700); err != nil && !os.IsExist(err) {
return fmt.Errorf("failed to create %q: %v", bin, err)
}
path := filepath.Join(bin, name)
// we use go build here because if someone built with go get, then `go
// install` turns into a no-op, and `go install -a` fails on people's
// machines that have go installed in a non-writeable directory (such as
// normal OS installs in /usr/bin)
return sh.RunV(gocmd, "build", "-o", path, "-ldflags="+flags(), "github.com/magefile/mage")
}
|
go
|
func Install() error {
name := "mage"
if runtime.GOOS == "windows" {
name += ".exe"
}
gocmd := mg.GoCmd()
// use GOBIN if set in the environment, otherwise fall back to first path
// in GOPATH environment string
bin, err := sh.Output(gocmd, "env", "GOBIN")
if err != nil {
return fmt.Errorf("can't determine GOBIN: %v", err)
}
if bin == "" {
gopath, err := sh.Output(gocmd, "env", "GOPATH")
if err != nil {
return fmt.Errorf("can't determine GOPATH: %v", err)
}
paths := strings.Split(gopath, string([]rune{os.PathListSeparator}))
bin = filepath.Join(paths[0], "bin")
}
// specifically don't mkdirall, if you have an invalid gopath in the first
// place, that's not on us to fix.
if err := os.Mkdir(bin, 0700); err != nil && !os.IsExist(err) {
return fmt.Errorf("failed to create %q: %v", bin, err)
}
path := filepath.Join(bin, name)
// we use go build here because if someone built with go get, then `go
// install` turns into a no-op, and `go install -a` fails on people's
// machines that have go installed in a non-writeable directory (such as
// normal OS installs in /usr/bin)
return sh.RunV(gocmd, "build", "-o", path, "-ldflags="+flags(), "github.com/magefile/mage")
}
|
[
"func",
"Install",
"(",
")",
"error",
"{",
"name",
":=",
"\"",
"\"",
"\n",
"if",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"{",
"name",
"+=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"gocmd",
":=",
"mg",
".",
"GoCmd",
"(",
")",
"\n",
"// use GOBIN if set in the environment, otherwise fall back to first path",
"// in GOPATH environment string",
"bin",
",",
"err",
":=",
"sh",
".",
"Output",
"(",
"gocmd",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"bin",
"==",
"\"",
"\"",
"{",
"gopath",
",",
"err",
":=",
"sh",
".",
"Output",
"(",
"gocmd",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"paths",
":=",
"strings",
".",
"Split",
"(",
"gopath",
",",
"string",
"(",
"[",
"]",
"rune",
"{",
"os",
".",
"PathListSeparator",
"}",
")",
")",
"\n",
"bin",
"=",
"filepath",
".",
"Join",
"(",
"paths",
"[",
"0",
"]",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// specifically don't mkdirall, if you have an invalid gopath in the first",
"// place, that's not on us to fix.",
"if",
"err",
":=",
"os",
".",
"Mkdir",
"(",
"bin",
",",
"0700",
")",
";",
"err",
"!=",
"nil",
"&&",
"!",
"os",
".",
"IsExist",
"(",
"err",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"bin",
",",
"err",
")",
"\n",
"}",
"\n",
"path",
":=",
"filepath",
".",
"Join",
"(",
"bin",
",",
"name",
")",
"\n\n",
"// we use go build here because if someone built with go get, then `go",
"// install` turns into a no-op, and `go install -a` fails on people's",
"// machines that have go installed in a non-writeable directory (such as",
"// normal OS installs in /usr/bin)",
"return",
"sh",
".",
"RunV",
"(",
"gocmd",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"path",
",",
"\"",
"\"",
"+",
"flags",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// Runs "go install" for mage. This generates the version info the binary.
|
[
"Runs",
"go",
"install",
"for",
"mage",
".",
"This",
"generates",
"the",
"version",
"info",
"the",
"binary",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/magefile.go#L23-L56
|
148,907 |
magefile/mage
|
magefile.go
|
Release
|
func Release() (err error) {
tag := os.Getenv("TAG")
if !releaseTag.MatchString(tag) {
return errors.New("TAG environment variable must be in semver v1.x.x format, but was " + tag)
}
if err := sh.RunV("git", "tag", "-a", tag, "-m", tag); err != nil {
return err
}
if err := sh.RunV("git", "push", "origin", tag); err != nil {
return err
}
defer func() {
if err != nil {
sh.RunV("git", "tag", "--delete", "$TAG")
sh.RunV("git", "push", "--delete", "origin", "$TAG")
}
}()
return sh.RunV("goreleaser")
}
|
go
|
func Release() (err error) {
tag := os.Getenv("TAG")
if !releaseTag.MatchString(tag) {
return errors.New("TAG environment variable must be in semver v1.x.x format, but was " + tag)
}
if err := sh.RunV("git", "tag", "-a", tag, "-m", tag); err != nil {
return err
}
if err := sh.RunV("git", "push", "origin", tag); err != nil {
return err
}
defer func() {
if err != nil {
sh.RunV("git", "tag", "--delete", "$TAG")
sh.RunV("git", "push", "--delete", "origin", "$TAG")
}
}()
return sh.RunV("goreleaser")
}
|
[
"func",
"Release",
"(",
")",
"(",
"err",
"error",
")",
"{",
"tag",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"!",
"releaseTag",
".",
"MatchString",
"(",
"tag",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"tag",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"sh",
".",
"RunV",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"tag",
",",
"\"",
"\"",
",",
"tag",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"sh",
".",
"RunV",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"tag",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"sh",
".",
"RunV",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"sh",
".",
"RunV",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"sh",
".",
"RunV",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// Generates a new release. Expects the TAG environment variable to be set,
// which will create a new tag with that name.
|
[
"Generates",
"a",
"new",
"release",
".",
"Expects",
"the",
"TAG",
"environment",
"variable",
"to",
"be",
"set",
"which",
"will",
"create",
"a",
"new",
"tag",
"with",
"that",
"name",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/magefile.go#L62-L81
|
148,908 |
magefile/mage
|
parse/parse.go
|
ID
|
func (f Function) ID() string {
path := "<current>"
if f.ImportPath != "" {
path = f.ImportPath
}
receiver := ""
if f.Receiver != "" {
receiver = f.Receiver + "."
}
return fmt.Sprintf("%s.%s%s", path, receiver, f.Name)
}
|
go
|
func (f Function) ID() string {
path := "<current>"
if f.ImportPath != "" {
path = f.ImportPath
}
receiver := ""
if f.Receiver != "" {
receiver = f.Receiver + "."
}
return fmt.Sprintf("%s.%s%s", path, receiver, f.Name)
}
|
[
"func",
"(",
"f",
"Function",
")",
"ID",
"(",
")",
"string",
"{",
"path",
":=",
"\"",
"\"",
"\n",
"if",
"f",
".",
"ImportPath",
"!=",
"\"",
"\"",
"{",
"path",
"=",
"f",
".",
"ImportPath",
"\n",
"}",
"\n",
"receiver",
":=",
"\"",
"\"",
"\n",
"if",
"f",
".",
"Receiver",
"!=",
"\"",
"\"",
"{",
"receiver",
"=",
"f",
".",
"Receiver",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"path",
",",
"receiver",
",",
"f",
".",
"Name",
")",
"\n",
"}"
] |
// ID returns user-readable information about where this function is defined.
|
[
"ID",
"returns",
"user",
"-",
"readable",
"information",
"about",
"where",
"this",
"function",
"is",
"defined",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/parse/parse.go#L54-L64
|
148,909 |
magefile/mage
|
parse/parse.go
|
TargetName
|
func (f Function) TargetName() string {
var names []string
for _, s := range []string{f.PkgAlias, f.Receiver, f.Name} {
if s != "" {
names = append(names, s)
}
}
return strings.Join(names, ":")
}
|
go
|
func (f Function) TargetName() string {
var names []string
for _, s := range []string{f.PkgAlias, f.Receiver, f.Name} {
if s != "" {
names = append(names, s)
}
}
return strings.Join(names, ":")
}
|
[
"func",
"(",
"f",
"Function",
")",
"TargetName",
"(",
")",
"string",
"{",
"var",
"names",
"[",
"]",
"string",
"\n\n",
"for",
"_",
",",
"s",
":=",
"range",
"[",
"]",
"string",
"{",
"f",
".",
"PkgAlias",
",",
"f",
".",
"Receiver",
",",
"f",
".",
"Name",
"}",
"{",
"if",
"s",
"!=",
"\"",
"\"",
"{",
"names",
"=",
"append",
"(",
"names",
",",
"s",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"names",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// TargetName returns the name of the target as it should appear when used from
// the mage cli. It is always lowercase.
|
[
"TargetName",
"returns",
"the",
"name",
"of",
"the",
"target",
"as",
"it",
"should",
"appear",
"when",
"used",
"from",
"the",
"mage",
"cli",
".",
"It",
"is",
"always",
"lowercase",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/parse/parse.go#L68-L77
|
148,910 |
magefile/mage
|
parse/parse.go
|
PrimaryPackage
|
func PrimaryPackage(gocmd, path string, files []string) (*PkgInfo, error) {
info, err := Package(path, files)
if err != nil {
return nil, err
}
if err := setImports(gocmd, info); err != nil {
return nil, err
}
setDefault(info)
setAliases(info)
return info, nil
}
|
go
|
func PrimaryPackage(gocmd, path string, files []string) (*PkgInfo, error) {
info, err := Package(path, files)
if err != nil {
return nil, err
}
if err := setImports(gocmd, info); err != nil {
return nil, err
}
setDefault(info)
setAliases(info)
return info, nil
}
|
[
"func",
"PrimaryPackage",
"(",
"gocmd",
",",
"path",
"string",
",",
"files",
"[",
"]",
"string",
")",
"(",
"*",
"PkgInfo",
",",
"error",
")",
"{",
"info",
",",
"err",
":=",
"Package",
"(",
"path",
",",
"files",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"setImports",
"(",
"gocmd",
",",
"info",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"setDefault",
"(",
"info",
")",
"\n",
"setAliases",
"(",
"info",
")",
"\n",
"return",
"info",
",",
"nil",
"\n",
"}"
] |
// PrimaryPackage parses a package. If files is non-empty, it will only parse the files given.
|
[
"PrimaryPackage",
"parses",
"a",
"package",
".",
"If",
"files",
"is",
"non",
"-",
"empty",
"it",
"will",
"only",
"parse",
"the",
"files",
"given",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/parse/parse.go#L129-L142
|
148,911 |
magefile/mage
|
parse/parse.go
|
Package
|
func Package(path string, files []string) (*PkgInfo, error) {
start := time.Now()
defer func() {
debug.Println("time parse Magefiles:", time.Since(start))
}()
fset := token.NewFileSet()
pkg, err := getPackage(path, files, fset)
if err != nil {
return nil, err
}
p := doc.New(pkg, "./", 0)
pi := &PkgInfo{
AstPkg: pkg,
DocPkg: p,
Description: toOneLine(p.Doc),
}
setNamespaces(pi)
setFuncs(pi)
hasDupes, names := checkDupeTargets(pi)
if hasDupes {
msg := "Build targets must be case insensitive, thus the following targets conflict:\n"
for _, v := range names {
if len(v) > 1 {
msg += " " + strings.Join(v, ", ") + "\n"
}
}
return nil, errors.New(msg)
}
return pi, nil
}
|
go
|
func Package(path string, files []string) (*PkgInfo, error) {
start := time.Now()
defer func() {
debug.Println("time parse Magefiles:", time.Since(start))
}()
fset := token.NewFileSet()
pkg, err := getPackage(path, files, fset)
if err != nil {
return nil, err
}
p := doc.New(pkg, "./", 0)
pi := &PkgInfo{
AstPkg: pkg,
DocPkg: p,
Description: toOneLine(p.Doc),
}
setNamespaces(pi)
setFuncs(pi)
hasDupes, names := checkDupeTargets(pi)
if hasDupes {
msg := "Build targets must be case insensitive, thus the following targets conflict:\n"
for _, v := range names {
if len(v) > 1 {
msg += " " + strings.Join(v, ", ") + "\n"
}
}
return nil, errors.New(msg)
}
return pi, nil
}
|
[
"func",
"Package",
"(",
"path",
"string",
",",
"files",
"[",
"]",
"string",
")",
"(",
"*",
"PkgInfo",
",",
"error",
")",
"{",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"debug",
".",
"Println",
"(",
"\"",
"\"",
",",
"time",
".",
"Since",
"(",
"start",
")",
")",
"\n",
"}",
"(",
")",
"\n",
"fset",
":=",
"token",
".",
"NewFileSet",
"(",
")",
"\n",
"pkg",
",",
"err",
":=",
"getPackage",
"(",
"path",
",",
"files",
",",
"fset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"p",
":=",
"doc",
".",
"New",
"(",
"pkg",
",",
"\"",
"\"",
",",
"0",
")",
"\n",
"pi",
":=",
"&",
"PkgInfo",
"{",
"AstPkg",
":",
"pkg",
",",
"DocPkg",
":",
"p",
",",
"Description",
":",
"toOneLine",
"(",
"p",
".",
"Doc",
")",
",",
"}",
"\n\n",
"setNamespaces",
"(",
"pi",
")",
"\n",
"setFuncs",
"(",
"pi",
")",
"\n\n",
"hasDupes",
",",
"names",
":=",
"checkDupeTargets",
"(",
"pi",
")",
"\n",
"if",
"hasDupes",
"{",
"msg",
":=",
"\"",
"\\n",
"\"",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"names",
"{",
"if",
"len",
"(",
"v",
")",
">",
"1",
"{",
"msg",
"+=",
"\"",
"\"",
"+",
"strings",
".",
"Join",
"(",
"v",
",",
"\"",
"\"",
")",
"+",
"\"",
"\\n",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"msg",
")",
"\n",
"}",
"\n\n",
"return",
"pi",
",",
"nil",
"\n",
"}"
] |
// Package compiles information about a mage package.
|
[
"Package",
"compiles",
"information",
"about",
"a",
"mage",
"package",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/parse/parse.go#L186-L218
|
148,912 |
magefile/mage
|
parse/parse.go
|
checkDupeTargets
|
func checkDupeTargets(info *PkgInfo) (hasDupes bool, names map[string][]string) {
names = map[string][]string{}
lowers := map[string]bool{}
for _, f := range info.Funcs {
low := strings.ToLower(f.Name)
if f.Receiver != "" {
low = strings.ToLower(f.Receiver) + ":" + low
}
if lowers[low] {
hasDupes = true
}
lowers[low] = true
names[low] = append(names[low], f.Name)
}
return hasDupes, names
}
|
go
|
func checkDupeTargets(info *PkgInfo) (hasDupes bool, names map[string][]string) {
names = map[string][]string{}
lowers := map[string]bool{}
for _, f := range info.Funcs {
low := strings.ToLower(f.Name)
if f.Receiver != "" {
low = strings.ToLower(f.Receiver) + ":" + low
}
if lowers[low] {
hasDupes = true
}
lowers[low] = true
names[low] = append(names[low], f.Name)
}
return hasDupes, names
}
|
[
"func",
"checkDupeTargets",
"(",
"info",
"*",
"PkgInfo",
")",
"(",
"hasDupes",
"bool",
",",
"names",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"{",
"names",
"=",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"}",
"\n",
"lowers",
":=",
"map",
"[",
"string",
"]",
"bool",
"{",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"info",
".",
"Funcs",
"{",
"low",
":=",
"strings",
".",
"ToLower",
"(",
"f",
".",
"Name",
")",
"\n",
"if",
"f",
".",
"Receiver",
"!=",
"\"",
"\"",
"{",
"low",
"=",
"strings",
".",
"ToLower",
"(",
"f",
".",
"Receiver",
")",
"+",
"\"",
"\"",
"+",
"low",
"\n",
"}",
"\n",
"if",
"lowers",
"[",
"low",
"]",
"{",
"hasDupes",
"=",
"true",
"\n",
"}",
"\n",
"lowers",
"[",
"low",
"]",
"=",
"true",
"\n",
"names",
"[",
"low",
"]",
"=",
"append",
"(",
"names",
"[",
"low",
"]",
",",
"f",
".",
"Name",
")",
"\n",
"}",
"\n",
"return",
"hasDupes",
",",
"names",
"\n",
"}"
] |
// checkDupeTargets checks a package for duplicate target names.
|
[
"checkDupeTargets",
"checks",
"a",
"package",
"for",
"duplicate",
"target",
"names",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/parse/parse.go#L463-L478
|
148,913 |
magefile/mage
|
parse/parse.go
|
sanitizeSynopsis
|
func sanitizeSynopsis(f *doc.Func) string {
synopsis := doc.Synopsis(f.Doc)
// If the synopsis begins with the function name, remove it. This is done to
// not repeat the text.
// From:
// clean Clean removes the temporarily generated files
// To:
// clean removes the temporarily generated files
if syns := strings.Split(synopsis, " "); strings.EqualFold(f.Name, syns[0]) {
return strings.Join(syns[1:], " ")
}
return synopsis
}
|
go
|
func sanitizeSynopsis(f *doc.Func) string {
synopsis := doc.Synopsis(f.Doc)
// If the synopsis begins with the function name, remove it. This is done to
// not repeat the text.
// From:
// clean Clean removes the temporarily generated files
// To:
// clean removes the temporarily generated files
if syns := strings.Split(synopsis, " "); strings.EqualFold(f.Name, syns[0]) {
return strings.Join(syns[1:], " ")
}
return synopsis
}
|
[
"func",
"sanitizeSynopsis",
"(",
"f",
"*",
"doc",
".",
"Func",
")",
"string",
"{",
"synopsis",
":=",
"doc",
".",
"Synopsis",
"(",
"f",
".",
"Doc",
")",
"\n\n",
"// If the synopsis begins with the function name, remove it. This is done to",
"// not repeat the text.",
"// From:",
"// clean\tClean removes the temporarily generated files",
"// To:",
"// clean \tremoves the temporarily generated files",
"if",
"syns",
":=",
"strings",
".",
"Split",
"(",
"synopsis",
",",
"\"",
"\"",
")",
";",
"strings",
".",
"EqualFold",
"(",
"f",
".",
"Name",
",",
"syns",
"[",
"0",
"]",
")",
"{",
"return",
"strings",
".",
"Join",
"(",
"syns",
"[",
"1",
":",
"]",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"synopsis",
"\n",
"}"
] |
// sanitizeSynopsis sanitizes function Doc to create a summary.
|
[
"sanitizeSynopsis",
"sanitizes",
"function",
"Doc",
"to",
"create",
"a",
"summary",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/parse/parse.go#L481-L495
|
148,914 |
magefile/mage
|
parse/parse.go
|
getPackage
|
func getPackage(path string, files []string, fset *token.FileSet) (*ast.Package, error) {
var filter func(f os.FileInfo) bool
if len(files) > 0 {
fm := make(map[string]bool, len(files))
for _, f := range files {
fm[f] = true
}
filter = func(f os.FileInfo) bool {
return fm[f.Name()]
}
}
pkgs, err := parser.ParseDir(fset, path, filter, parser.ParseComments)
if err != nil {
return nil, fmt.Errorf("failed to parse directory: %v", err)
}
for name, pkg := range pkgs {
if !strings.HasSuffix(name, "_test") {
return pkg, nil
}
}
return nil, fmt.Errorf("no non-test packages found in %s", path)
}
|
go
|
func getPackage(path string, files []string, fset *token.FileSet) (*ast.Package, error) {
var filter func(f os.FileInfo) bool
if len(files) > 0 {
fm := make(map[string]bool, len(files))
for _, f := range files {
fm[f] = true
}
filter = func(f os.FileInfo) bool {
return fm[f.Name()]
}
}
pkgs, err := parser.ParseDir(fset, path, filter, parser.ParseComments)
if err != nil {
return nil, fmt.Errorf("failed to parse directory: %v", err)
}
for name, pkg := range pkgs {
if !strings.HasSuffix(name, "_test") {
return pkg, nil
}
}
return nil, fmt.Errorf("no non-test packages found in %s", path)
}
|
[
"func",
"getPackage",
"(",
"path",
"string",
",",
"files",
"[",
"]",
"string",
",",
"fset",
"*",
"token",
".",
"FileSet",
")",
"(",
"*",
"ast",
".",
"Package",
",",
"error",
")",
"{",
"var",
"filter",
"func",
"(",
"f",
"os",
".",
"FileInfo",
")",
"bool",
"\n",
"if",
"len",
"(",
"files",
")",
">",
"0",
"{",
"fm",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
",",
"len",
"(",
"files",
")",
")",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"files",
"{",
"fm",
"[",
"f",
"]",
"=",
"true",
"\n",
"}",
"\n\n",
"filter",
"=",
"func",
"(",
"f",
"os",
".",
"FileInfo",
")",
"bool",
"{",
"return",
"fm",
"[",
"f",
".",
"Name",
"(",
")",
"]",
"\n",
"}",
"\n",
"}",
"\n\n",
"pkgs",
",",
"err",
":=",
"parser",
".",
"ParseDir",
"(",
"fset",
",",
"path",
",",
"filter",
",",
"parser",
".",
"ParseComments",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"name",
",",
"pkg",
":=",
"range",
"pkgs",
"{",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"name",
",",
"\"",
"\"",
")",
"{",
"return",
"pkg",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"}"
] |
// getPackage returns the non-test package at the given path.
|
[
"getPackage",
"returns",
"the",
"non",
"-",
"test",
"package",
"at",
"the",
"given",
"path",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/parse/parse.go#L657-L681
|
148,915 |
magefile/mage
|
mg/errors.go
|
Fatal
|
func Fatal(code int, args ...interface{}) error {
return fatalErr{
code: code,
error: errors.New(fmt.Sprint(args...)),
}
}
|
go
|
func Fatal(code int, args ...interface{}) error {
return fatalErr{
code: code,
error: errors.New(fmt.Sprint(args...)),
}
}
|
[
"func",
"Fatal",
"(",
"code",
"int",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"fatalErr",
"{",
"code",
":",
"code",
",",
"error",
":",
"errors",
".",
"New",
"(",
"fmt",
".",
"Sprint",
"(",
"args",
"...",
")",
")",
",",
"}",
"\n",
"}"
] |
// Fatal returns an error that will cause mage to print out the
// given args and exit with the given exit code.
|
[
"Fatal",
"returns",
"an",
"error",
"that",
"will",
"cause",
"mage",
"to",
"print",
"out",
"the",
"given",
"args",
"and",
"exit",
"with",
"the",
"given",
"exit",
"code",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/mg/errors.go#L23-L28
|
148,916 |
magefile/mage
|
mg/errors.go
|
Fatalf
|
func Fatalf(code int, format string, args ...interface{}) error {
return fatalErr{
code: code,
error: fmt.Errorf(format, args...),
}
}
|
go
|
func Fatalf(code int, format string, args ...interface{}) error {
return fatalErr{
code: code,
error: fmt.Errorf(format, args...),
}
}
|
[
"func",
"Fatalf",
"(",
"code",
"int",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"fatalErr",
"{",
"code",
":",
"code",
",",
"error",
":",
"fmt",
".",
"Errorf",
"(",
"format",
",",
"args",
"...",
")",
",",
"}",
"\n",
"}"
] |
// Fatalf returns an error that will cause mage to print out the
// given message and exit with the given exit code.
|
[
"Fatalf",
"returns",
"an",
"error",
"that",
"will",
"cause",
"mage",
"to",
"print",
"out",
"the",
"given",
"message",
"and",
"exit",
"with",
"the",
"given",
"exit",
"code",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/mg/errors.go#L32-L37
|
148,917 |
magefile/mage
|
target/target.go
|
Dir
|
func Dir(dst string, sources ...string) (bool, error) {
stat, err := os.Stat(os.ExpandEnv(dst))
if os.IsNotExist(err) {
return true, nil
}
if err != nil {
return false, err
}
srcTime := stat.ModTime()
if stat.IsDir() {
srcTime, err = calDirModTimeRecursive(dst, stat)
if err != nil {
return false, err
}
}
dt, err := loadTargets(expand(sources))
if err != nil {
return false, err
}
t, err := dt.modTimeDir()
if err != nil {
return false, err
}
if t.After(srcTime) {
return true, nil
}
return false, nil
}
|
go
|
func Dir(dst string, sources ...string) (bool, error) {
stat, err := os.Stat(os.ExpandEnv(dst))
if os.IsNotExist(err) {
return true, nil
}
if err != nil {
return false, err
}
srcTime := stat.ModTime()
if stat.IsDir() {
srcTime, err = calDirModTimeRecursive(dst, stat)
if err != nil {
return false, err
}
}
dt, err := loadTargets(expand(sources))
if err != nil {
return false, err
}
t, err := dt.modTimeDir()
if err != nil {
return false, err
}
if t.After(srcTime) {
return true, nil
}
return false, nil
}
|
[
"func",
"Dir",
"(",
"dst",
"string",
",",
"sources",
"...",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"stat",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"os",
".",
"ExpandEnv",
"(",
"dst",
")",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"srcTime",
":=",
"stat",
".",
"ModTime",
"(",
")",
"\n",
"if",
"stat",
".",
"IsDir",
"(",
")",
"{",
"srcTime",
",",
"err",
"=",
"calDirModTimeRecursive",
"(",
"dst",
",",
"stat",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"dt",
",",
"err",
":=",
"loadTargets",
"(",
"expand",
"(",
"sources",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"t",
",",
"err",
":=",
"dt",
".",
"modTimeDir",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"t",
".",
"After",
"(",
"srcTime",
")",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] |
// Dir reports whether any of the sources have been modified more recently than
// the destination. If a source or destination is a directory, modtimes of
// files under those directories are compared instead. If the destination file
// doesn't exist, it always returns true and nil. It's an error if any of the
// sources don't exist.
|
[
"Dir",
"reports",
"whether",
"any",
"of",
"the",
"sources",
"have",
"been",
"modified",
"more",
"recently",
"than",
"the",
"destination",
".",
"If",
"a",
"source",
"or",
"destination",
"is",
"a",
"directory",
"modtimes",
"of",
"files",
"under",
"those",
"directories",
"are",
"compared",
"instead",
".",
"If",
"the",
"destination",
"file",
"doesn",
"t",
"exist",
"it",
"always",
"returns",
"true",
"and",
"nil",
".",
"It",
"s",
"an",
"error",
"if",
"any",
"of",
"the",
"sources",
"don",
"t",
"exist",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/target/target.go#L79-L106
|
148,918 |
magefile/mage
|
sh/cmd.go
|
OutCmd
|
func OutCmd(cmd string, args ...string) func(args ...string) (string, error) {
return func(args2 ...string) (string, error) {
return Output(cmd, append(args, args2...)...)
}
}
|
go
|
func OutCmd(cmd string, args ...string) func(args ...string) (string, error) {
return func(args2 ...string) (string, error) {
return Output(cmd, append(args, args2...)...)
}
}
|
[
"func",
"OutCmd",
"(",
"cmd",
"string",
",",
"args",
"...",
"string",
")",
"func",
"(",
"args",
"...",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"func",
"(",
"args2",
"...",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"Output",
"(",
"cmd",
",",
"append",
"(",
"args",
",",
"args2",
"...",
")",
"...",
")",
"\n",
"}",
"\n",
"}"
] |
// OutCmd is like RunCmd except the command returns the output of the
// command.
|
[
"OutCmd",
"is",
"like",
"RunCmd",
"except",
"the",
"command",
"returns",
"the",
"output",
"of",
"the",
"command",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/sh/cmd.go#L42-L46
|
148,919 |
magefile/mage
|
sh/cmd.go
|
Run
|
func Run(cmd string, args ...string) error {
return RunWith(nil, cmd, args...)
}
|
go
|
func Run(cmd string, args ...string) error {
return RunWith(nil, cmd, args...)
}
|
[
"func",
"Run",
"(",
"cmd",
"string",
",",
"args",
"...",
"string",
")",
"error",
"{",
"return",
"RunWith",
"(",
"nil",
",",
"cmd",
",",
"args",
"...",
")",
"\n",
"}"
] |
// Run is like RunWith, but doesn't specify any environment variables.
|
[
"Run",
"is",
"like",
"RunWith",
"but",
"doesn",
"t",
"specify",
"any",
"environment",
"variables",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/sh/cmd.go#L49-L51
|
148,920 |
magefile/mage
|
sh/cmd.go
|
RunV
|
func RunV(cmd string, args ...string) error {
_, err := Exec(nil, os.Stdout, os.Stderr, cmd, args...)
return err
}
|
go
|
func RunV(cmd string, args ...string) error {
_, err := Exec(nil, os.Stdout, os.Stderr, cmd, args...)
return err
}
|
[
"func",
"RunV",
"(",
"cmd",
"string",
",",
"args",
"...",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"Exec",
"(",
"nil",
",",
"os",
".",
"Stdout",
",",
"os",
".",
"Stderr",
",",
"cmd",
",",
"args",
"...",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// RunV is like Run, but always sends the command's stdout to os.Stdout.
|
[
"RunV",
"is",
"like",
"Run",
"but",
"always",
"sends",
"the",
"command",
"s",
"stdout",
"to",
"os",
".",
"Stdout",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/sh/cmd.go#L54-L57
|
148,921 |
magefile/mage
|
sh/cmd.go
|
RunWith
|
func RunWith(env map[string]string, cmd string, args ...string) error {
var output io.Writer
if mg.Verbose() {
output = os.Stdout
}
_, err := Exec(env, output, os.Stderr, cmd, args...)
return err
}
|
go
|
func RunWith(env map[string]string, cmd string, args ...string) error {
var output io.Writer
if mg.Verbose() {
output = os.Stdout
}
_, err := Exec(env, output, os.Stderr, cmd, args...)
return err
}
|
[
"func",
"RunWith",
"(",
"env",
"map",
"[",
"string",
"]",
"string",
",",
"cmd",
"string",
",",
"args",
"...",
"string",
")",
"error",
"{",
"var",
"output",
"io",
".",
"Writer",
"\n",
"if",
"mg",
".",
"Verbose",
"(",
")",
"{",
"output",
"=",
"os",
".",
"Stdout",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"Exec",
"(",
"env",
",",
"output",
",",
"os",
".",
"Stderr",
",",
"cmd",
",",
"args",
"...",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// RunWith runs the given command, directing stderr to this program's stderr and
// printing stdout to stdout if mage was run with -v. It adds adds env to the
// environment variables for the command being run. Environment variables should
// be in the format name=value.
|
[
"RunWith",
"runs",
"the",
"given",
"command",
"directing",
"stderr",
"to",
"this",
"program",
"s",
"stderr",
"and",
"printing",
"stdout",
"to",
"stdout",
"if",
"mage",
"was",
"run",
"with",
"-",
"v",
".",
"It",
"adds",
"adds",
"env",
"to",
"the",
"environment",
"variables",
"for",
"the",
"command",
"being",
"run",
".",
"Environment",
"variables",
"should",
"be",
"in",
"the",
"format",
"name",
"=",
"value",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/sh/cmd.go#L63-L70
|
148,922 |
magefile/mage
|
sh/cmd.go
|
Output
|
func Output(cmd string, args ...string) (string, error) {
buf := &bytes.Buffer{}
_, err := Exec(nil, buf, os.Stderr, cmd, args...)
return strings.TrimSuffix(buf.String(), "\n"), err
}
|
go
|
func Output(cmd string, args ...string) (string, error) {
buf := &bytes.Buffer{}
_, err := Exec(nil, buf, os.Stderr, cmd, args...)
return strings.TrimSuffix(buf.String(), "\n"), err
}
|
[
"func",
"Output",
"(",
"cmd",
"string",
",",
"args",
"...",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"buf",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"_",
",",
"err",
":=",
"Exec",
"(",
"nil",
",",
"buf",
",",
"os",
".",
"Stderr",
",",
"cmd",
",",
"args",
"...",
")",
"\n",
"return",
"strings",
".",
"TrimSuffix",
"(",
"buf",
".",
"String",
"(",
")",
",",
"\"",
"\\n",
"\"",
")",
",",
"err",
"\n",
"}"
] |
// Output runs the command and returns the text from stdout.
|
[
"Output",
"runs",
"the",
"command",
"and",
"returns",
"the",
"text",
"from",
"stdout",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/sh/cmd.go#L73-L77
|
148,923 |
magefile/mage
|
sh/cmd.go
|
OutputWith
|
func OutputWith(env map[string]string, cmd string, args ...string) (string, error) {
buf := &bytes.Buffer{}
_, err := Exec(env, buf, os.Stderr, cmd, args...)
return strings.TrimSuffix(buf.String(), "\n"), err
}
|
go
|
func OutputWith(env map[string]string, cmd string, args ...string) (string, error) {
buf := &bytes.Buffer{}
_, err := Exec(env, buf, os.Stderr, cmd, args...)
return strings.TrimSuffix(buf.String(), "\n"), err
}
|
[
"func",
"OutputWith",
"(",
"env",
"map",
"[",
"string",
"]",
"string",
",",
"cmd",
"string",
",",
"args",
"...",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"buf",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"_",
",",
"err",
":=",
"Exec",
"(",
"env",
",",
"buf",
",",
"os",
".",
"Stderr",
",",
"cmd",
",",
"args",
"...",
")",
"\n",
"return",
"strings",
".",
"TrimSuffix",
"(",
"buf",
".",
"String",
"(",
")",
",",
"\"",
"\\n",
"\"",
")",
",",
"err",
"\n",
"}"
] |
// OutputWith is like RunWith, but returns what is written to stdout.
|
[
"OutputWith",
"is",
"like",
"RunWith",
"but",
"returns",
"what",
"is",
"written",
"to",
"stdout",
"."
] |
5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed
|
https://github.com/magefile/mage/blob/5bc3a8ab86d5a23d6eb3bdbcd60e79ac4d9ad0ed/sh/cmd.go#L80-L84
|
148,924 |
appleboy/gin-jwt
|
auth_jwt.go
|
New
|
func New(m *GinJWTMiddleware) (*GinJWTMiddleware, error) {
if err := m.MiddlewareInit(); err != nil {
return nil, err
}
return m, nil
}
|
go
|
func New(m *GinJWTMiddleware) (*GinJWTMiddleware, error) {
if err := m.MiddlewareInit(); err != nil {
return nil, err
}
return m, nil
}
|
[
"func",
"New",
"(",
"m",
"*",
"GinJWTMiddleware",
")",
"(",
"*",
"GinJWTMiddleware",
",",
"error",
")",
"{",
"if",
"err",
":=",
"m",
".",
"MiddlewareInit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// New for check error with GinJWTMiddleware
|
[
"New",
"for",
"check",
"error",
"with",
"GinJWTMiddleware"
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L193-L199
|
148,925 |
appleboy/gin-jwt
|
auth_jwt.go
|
MiddlewareInit
|
func (mw *GinJWTMiddleware) MiddlewareInit() error {
if mw.TokenLookup == "" {
mw.TokenLookup = "header:Authorization"
}
if mw.SigningAlgorithm == "" {
mw.SigningAlgorithm = "HS256"
}
if mw.Timeout == 0 {
mw.Timeout = time.Hour
}
if mw.TimeFunc == nil {
mw.TimeFunc = time.Now
}
mw.TokenHeadName = strings.TrimSpace(mw.TokenHeadName)
if len(mw.TokenHeadName) == 0 {
mw.TokenHeadName = "Bearer"
}
if mw.Authorizator == nil {
mw.Authorizator = func(data interface{}, c *gin.Context) bool {
return true
}
}
if mw.Unauthorized == nil {
mw.Unauthorized = func(c *gin.Context, code int, message string) {
c.JSON(code, gin.H{
"code": code,
"message": message,
})
}
}
if mw.LoginResponse == nil {
mw.LoginResponse = func(c *gin.Context, code int, token string, expire time.Time) {
c.JSON(http.StatusOK, gin.H{
"code": http.StatusOK,
"token": token,
"expire": expire.Format(time.RFC3339),
})
}
}
if mw.RefreshResponse == nil {
mw.RefreshResponse = func(c *gin.Context, code int, token string, expire time.Time) {
c.JSON(http.StatusOK, gin.H{
"code": http.StatusOK,
"token": token,
"expire": expire.Format(time.RFC3339),
})
}
}
if mw.IdentityKey == "" {
mw.IdentityKey = IdentityKey
}
if mw.IdentityHandler == nil {
mw.IdentityHandler = func(c *gin.Context) interface{} {
claims := ExtractClaims(c)
return claims[mw.IdentityKey]
}
}
if mw.HTTPStatusMessageFunc == nil {
mw.HTTPStatusMessageFunc = func(e error, c *gin.Context) string {
return e.Error()
}
}
if mw.Realm == "" {
mw.Realm = "gin jwt"
}
if mw.CookieName == "" {
mw.CookieName = "jwt"
}
if mw.usingPublicKeyAlgo() {
return mw.readKeys()
}
if mw.Key == nil {
return ErrMissingSecretKey
}
return nil
}
|
go
|
func (mw *GinJWTMiddleware) MiddlewareInit() error {
if mw.TokenLookup == "" {
mw.TokenLookup = "header:Authorization"
}
if mw.SigningAlgorithm == "" {
mw.SigningAlgorithm = "HS256"
}
if mw.Timeout == 0 {
mw.Timeout = time.Hour
}
if mw.TimeFunc == nil {
mw.TimeFunc = time.Now
}
mw.TokenHeadName = strings.TrimSpace(mw.TokenHeadName)
if len(mw.TokenHeadName) == 0 {
mw.TokenHeadName = "Bearer"
}
if mw.Authorizator == nil {
mw.Authorizator = func(data interface{}, c *gin.Context) bool {
return true
}
}
if mw.Unauthorized == nil {
mw.Unauthorized = func(c *gin.Context, code int, message string) {
c.JSON(code, gin.H{
"code": code,
"message": message,
})
}
}
if mw.LoginResponse == nil {
mw.LoginResponse = func(c *gin.Context, code int, token string, expire time.Time) {
c.JSON(http.StatusOK, gin.H{
"code": http.StatusOK,
"token": token,
"expire": expire.Format(time.RFC3339),
})
}
}
if mw.RefreshResponse == nil {
mw.RefreshResponse = func(c *gin.Context, code int, token string, expire time.Time) {
c.JSON(http.StatusOK, gin.H{
"code": http.StatusOK,
"token": token,
"expire": expire.Format(time.RFC3339),
})
}
}
if mw.IdentityKey == "" {
mw.IdentityKey = IdentityKey
}
if mw.IdentityHandler == nil {
mw.IdentityHandler = func(c *gin.Context) interface{} {
claims := ExtractClaims(c)
return claims[mw.IdentityKey]
}
}
if mw.HTTPStatusMessageFunc == nil {
mw.HTTPStatusMessageFunc = func(e error, c *gin.Context) string {
return e.Error()
}
}
if mw.Realm == "" {
mw.Realm = "gin jwt"
}
if mw.CookieName == "" {
mw.CookieName = "jwt"
}
if mw.usingPublicKeyAlgo() {
return mw.readKeys()
}
if mw.Key == nil {
return ErrMissingSecretKey
}
return nil
}
|
[
"func",
"(",
"mw",
"*",
"GinJWTMiddleware",
")",
"MiddlewareInit",
"(",
")",
"error",
"{",
"if",
"mw",
".",
"TokenLookup",
"==",
"\"",
"\"",
"{",
"mw",
".",
"TokenLookup",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"SigningAlgorithm",
"==",
"\"",
"\"",
"{",
"mw",
".",
"SigningAlgorithm",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"Timeout",
"==",
"0",
"{",
"mw",
".",
"Timeout",
"=",
"time",
".",
"Hour",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"TimeFunc",
"==",
"nil",
"{",
"mw",
".",
"TimeFunc",
"=",
"time",
".",
"Now",
"\n",
"}",
"\n\n",
"mw",
".",
"TokenHeadName",
"=",
"strings",
".",
"TrimSpace",
"(",
"mw",
".",
"TokenHeadName",
")",
"\n",
"if",
"len",
"(",
"mw",
".",
"TokenHeadName",
")",
"==",
"0",
"{",
"mw",
".",
"TokenHeadName",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"Authorizator",
"==",
"nil",
"{",
"mw",
".",
"Authorizator",
"=",
"func",
"(",
"data",
"interface",
"{",
"}",
",",
"c",
"*",
"gin",
".",
"Context",
")",
"bool",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"Unauthorized",
"==",
"nil",
"{",
"mw",
".",
"Unauthorized",
"=",
"func",
"(",
"c",
"*",
"gin",
".",
"Context",
",",
"code",
"int",
",",
"message",
"string",
")",
"{",
"c",
".",
"JSON",
"(",
"code",
",",
"gin",
".",
"H",
"{",
"\"",
"\"",
":",
"code",
",",
"\"",
"\"",
":",
"message",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"LoginResponse",
"==",
"nil",
"{",
"mw",
".",
"LoginResponse",
"=",
"func",
"(",
"c",
"*",
"gin",
".",
"Context",
",",
"code",
"int",
",",
"token",
"string",
",",
"expire",
"time",
".",
"Time",
")",
"{",
"c",
".",
"JSON",
"(",
"http",
".",
"StatusOK",
",",
"gin",
".",
"H",
"{",
"\"",
"\"",
":",
"http",
".",
"StatusOK",
",",
"\"",
"\"",
":",
"token",
",",
"\"",
"\"",
":",
"expire",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"RefreshResponse",
"==",
"nil",
"{",
"mw",
".",
"RefreshResponse",
"=",
"func",
"(",
"c",
"*",
"gin",
".",
"Context",
",",
"code",
"int",
",",
"token",
"string",
",",
"expire",
"time",
".",
"Time",
")",
"{",
"c",
".",
"JSON",
"(",
"http",
".",
"StatusOK",
",",
"gin",
".",
"H",
"{",
"\"",
"\"",
":",
"http",
".",
"StatusOK",
",",
"\"",
"\"",
":",
"token",
",",
"\"",
"\"",
":",
"expire",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"IdentityKey",
"==",
"\"",
"\"",
"{",
"mw",
".",
"IdentityKey",
"=",
"IdentityKey",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"IdentityHandler",
"==",
"nil",
"{",
"mw",
".",
"IdentityHandler",
"=",
"func",
"(",
"c",
"*",
"gin",
".",
"Context",
")",
"interface",
"{",
"}",
"{",
"claims",
":=",
"ExtractClaims",
"(",
"c",
")",
"\n",
"return",
"claims",
"[",
"mw",
".",
"IdentityKey",
"]",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"HTTPStatusMessageFunc",
"==",
"nil",
"{",
"mw",
".",
"HTTPStatusMessageFunc",
"=",
"func",
"(",
"e",
"error",
",",
"c",
"*",
"gin",
".",
"Context",
")",
"string",
"{",
"return",
"e",
".",
"Error",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"Realm",
"==",
"\"",
"\"",
"{",
"mw",
".",
"Realm",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"CookieName",
"==",
"\"",
"\"",
"{",
"mw",
".",
"CookieName",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"usingPublicKeyAlgo",
"(",
")",
"{",
"return",
"mw",
".",
"readKeys",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"Key",
"==",
"nil",
"{",
"return",
"ErrMissingSecretKey",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// MiddlewareInit initialize jwt configs.
|
[
"MiddlewareInit",
"initialize",
"jwt",
"configs",
"."
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L248-L339
|
148,926 |
appleboy/gin-jwt
|
auth_jwt.go
|
MiddlewareFunc
|
func (mw *GinJWTMiddleware) MiddlewareFunc() gin.HandlerFunc {
return func(c *gin.Context) {
mw.middlewareImpl(c)
}
}
|
go
|
func (mw *GinJWTMiddleware) MiddlewareFunc() gin.HandlerFunc {
return func(c *gin.Context) {
mw.middlewareImpl(c)
}
}
|
[
"func",
"(",
"mw",
"*",
"GinJWTMiddleware",
")",
"MiddlewareFunc",
"(",
")",
"gin",
".",
"HandlerFunc",
"{",
"return",
"func",
"(",
"c",
"*",
"gin",
".",
"Context",
")",
"{",
"mw",
".",
"middlewareImpl",
"(",
"c",
")",
"\n",
"}",
"\n",
"}"
] |
// MiddlewareFunc makes GinJWTMiddleware implement the Middleware interface.
|
[
"MiddlewareFunc",
"makes",
"GinJWTMiddleware",
"implement",
"the",
"Middleware",
"interface",
"."
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L342-L346
|
148,927 |
appleboy/gin-jwt
|
auth_jwt.go
|
GetClaimsFromJWT
|
func (mw *GinJWTMiddleware) GetClaimsFromJWT(c *gin.Context) (MapClaims, error) {
token, err := mw.ParseToken(c)
if err != nil {
return nil, err
}
if mw.SendAuthorization {
if v, ok := c.Get("JWT_TOKEN"); ok {
c.Header("Authorization", mw.TokenHeadName+" "+v.(string))
}
}
claims := MapClaims{}
for key, value := range token.Claims.(jwt.MapClaims) {
claims[key] = value
}
return claims, nil
}
|
go
|
func (mw *GinJWTMiddleware) GetClaimsFromJWT(c *gin.Context) (MapClaims, error) {
token, err := mw.ParseToken(c)
if err != nil {
return nil, err
}
if mw.SendAuthorization {
if v, ok := c.Get("JWT_TOKEN"); ok {
c.Header("Authorization", mw.TokenHeadName+" "+v.(string))
}
}
claims := MapClaims{}
for key, value := range token.Claims.(jwt.MapClaims) {
claims[key] = value
}
return claims, nil
}
|
[
"func",
"(",
"mw",
"*",
"GinJWTMiddleware",
")",
"GetClaimsFromJWT",
"(",
"c",
"*",
"gin",
".",
"Context",
")",
"(",
"MapClaims",
",",
"error",
")",
"{",
"token",
",",
"err",
":=",
"mw",
".",
"ParseToken",
"(",
"c",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"mw",
".",
"SendAuthorization",
"{",
"if",
"v",
",",
"ok",
":=",
"c",
".",
"Get",
"(",
"\"",
"\"",
")",
";",
"ok",
"{",
"c",
".",
"Header",
"(",
"\"",
"\"",
",",
"mw",
".",
"TokenHeadName",
"+",
"\"",
"\"",
"+",
"v",
".",
"(",
"string",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"claims",
":=",
"MapClaims",
"{",
"}",
"\n",
"for",
"key",
",",
"value",
":=",
"range",
"token",
".",
"Claims",
".",
"(",
"jwt",
".",
"MapClaims",
")",
"{",
"claims",
"[",
"key",
"]",
"=",
"value",
"\n",
"}",
"\n\n",
"return",
"claims",
",",
"nil",
"\n",
"}"
] |
// GetClaimsFromJWT get claims from JWT token
|
[
"GetClaimsFromJWT",
"get",
"claims",
"from",
"JWT",
"token"
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L386-L405
|
148,928 |
appleboy/gin-jwt
|
auth_jwt.go
|
RefreshToken
|
func (mw *GinJWTMiddleware) RefreshToken(c *gin.Context) (string, time.Time, error) {
claims, err := mw.CheckIfTokenExpire(c)
if err != nil {
return "", time.Now(), err
}
// Create the token
newToken := jwt.New(jwt.GetSigningMethod(mw.SigningAlgorithm))
newClaims := newToken.Claims.(jwt.MapClaims)
for key := range claims {
newClaims[key] = claims[key]
}
expire := mw.TimeFunc().Add(mw.Timeout)
newClaims["exp"] = expire.Unix()
newClaims["orig_iat"] = mw.TimeFunc().Unix()
tokenString, err := mw.signedString(newToken)
if err != nil {
return "", time.Now(), err
}
// set cookie
if mw.SendCookie {
maxage := int(expire.Unix() - time.Now().Unix())
c.SetCookie(
mw.CookieName,
tokenString,
maxage,
"/",
mw.CookieDomain,
mw.SecureCookie,
mw.CookieHTTPOnly,
)
}
return tokenString, expire, nil
}
|
go
|
func (mw *GinJWTMiddleware) RefreshToken(c *gin.Context) (string, time.Time, error) {
claims, err := mw.CheckIfTokenExpire(c)
if err != nil {
return "", time.Now(), err
}
// Create the token
newToken := jwt.New(jwt.GetSigningMethod(mw.SigningAlgorithm))
newClaims := newToken.Claims.(jwt.MapClaims)
for key := range claims {
newClaims[key] = claims[key]
}
expire := mw.TimeFunc().Add(mw.Timeout)
newClaims["exp"] = expire.Unix()
newClaims["orig_iat"] = mw.TimeFunc().Unix()
tokenString, err := mw.signedString(newToken)
if err != nil {
return "", time.Now(), err
}
// set cookie
if mw.SendCookie {
maxage := int(expire.Unix() - time.Now().Unix())
c.SetCookie(
mw.CookieName,
tokenString,
maxage,
"/",
mw.CookieDomain,
mw.SecureCookie,
mw.CookieHTTPOnly,
)
}
return tokenString, expire, nil
}
|
[
"func",
"(",
"mw",
"*",
"GinJWTMiddleware",
")",
"RefreshToken",
"(",
"c",
"*",
"gin",
".",
"Context",
")",
"(",
"string",
",",
"time",
".",
"Time",
",",
"error",
")",
"{",
"claims",
",",
"err",
":=",
"mw",
".",
"CheckIfTokenExpire",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"time",
".",
"Now",
"(",
")",
",",
"err",
"\n",
"}",
"\n\n",
"// Create the token",
"newToken",
":=",
"jwt",
".",
"New",
"(",
"jwt",
".",
"GetSigningMethod",
"(",
"mw",
".",
"SigningAlgorithm",
")",
")",
"\n",
"newClaims",
":=",
"newToken",
".",
"Claims",
".",
"(",
"jwt",
".",
"MapClaims",
")",
"\n\n",
"for",
"key",
":=",
"range",
"claims",
"{",
"newClaims",
"[",
"key",
"]",
"=",
"claims",
"[",
"key",
"]",
"\n",
"}",
"\n\n",
"expire",
":=",
"mw",
".",
"TimeFunc",
"(",
")",
".",
"Add",
"(",
"mw",
".",
"Timeout",
")",
"\n",
"newClaims",
"[",
"\"",
"\"",
"]",
"=",
"expire",
".",
"Unix",
"(",
")",
"\n",
"newClaims",
"[",
"\"",
"\"",
"]",
"=",
"mw",
".",
"TimeFunc",
"(",
")",
".",
"Unix",
"(",
")",
"\n",
"tokenString",
",",
"err",
":=",
"mw",
".",
"signedString",
"(",
"newToken",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"time",
".",
"Now",
"(",
")",
",",
"err",
"\n",
"}",
"\n\n",
"// set cookie",
"if",
"mw",
".",
"SendCookie",
"{",
"maxage",
":=",
"int",
"(",
"expire",
".",
"Unix",
"(",
")",
"-",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
")",
"\n",
"c",
".",
"SetCookie",
"(",
"mw",
".",
"CookieName",
",",
"tokenString",
",",
"maxage",
",",
"\"",
"\"",
",",
"mw",
".",
"CookieDomain",
",",
"mw",
".",
"SecureCookie",
",",
"mw",
".",
"CookieHTTPOnly",
",",
")",
"\n",
"}",
"\n\n",
"return",
"tokenString",
",",
"expire",
",",
"nil",
"\n",
"}"
] |
// RefreshToken refresh token and check if token is expired
|
[
"RefreshToken",
"refresh",
"token",
"and",
"check",
"if",
"token",
"is",
"expired"
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L485-L523
|
148,929 |
appleboy/gin-jwt
|
auth_jwt.go
|
CheckIfTokenExpire
|
func (mw *GinJWTMiddleware) CheckIfTokenExpire(c *gin.Context) (jwt.MapClaims, error) {
token, err := mw.ParseToken(c)
if err != nil {
// If we receive an error, and the error is anything other than a single
// ValidationErrorExpired, we want to return the error.
// If the error is just ValidationErrorExpired, we want to continue, as we can still
// refresh the token if it's within the MaxRefresh time.
// (see https://github.com/appleboy/gin-jwt/issues/176)
validationErr, ok := err.(*jwt.ValidationError)
if !ok || validationErr.Errors != jwt.ValidationErrorExpired {
return nil, err
}
}
claims := token.Claims.(jwt.MapClaims)
origIat := int64(claims["orig_iat"].(float64))
if origIat < mw.TimeFunc().Add(-mw.MaxRefresh).Unix() {
return nil, ErrExpiredToken
}
return claims, nil
}
|
go
|
func (mw *GinJWTMiddleware) CheckIfTokenExpire(c *gin.Context) (jwt.MapClaims, error) {
token, err := mw.ParseToken(c)
if err != nil {
// If we receive an error, and the error is anything other than a single
// ValidationErrorExpired, we want to return the error.
// If the error is just ValidationErrorExpired, we want to continue, as we can still
// refresh the token if it's within the MaxRefresh time.
// (see https://github.com/appleboy/gin-jwt/issues/176)
validationErr, ok := err.(*jwt.ValidationError)
if !ok || validationErr.Errors != jwt.ValidationErrorExpired {
return nil, err
}
}
claims := token.Claims.(jwt.MapClaims)
origIat := int64(claims["orig_iat"].(float64))
if origIat < mw.TimeFunc().Add(-mw.MaxRefresh).Unix() {
return nil, ErrExpiredToken
}
return claims, nil
}
|
[
"func",
"(",
"mw",
"*",
"GinJWTMiddleware",
")",
"CheckIfTokenExpire",
"(",
"c",
"*",
"gin",
".",
"Context",
")",
"(",
"jwt",
".",
"MapClaims",
",",
"error",
")",
"{",
"token",
",",
"err",
":=",
"mw",
".",
"ParseToken",
"(",
"c",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"// If we receive an error, and the error is anything other than a single",
"// ValidationErrorExpired, we want to return the error.",
"// If the error is just ValidationErrorExpired, we want to continue, as we can still",
"// refresh the token if it's within the MaxRefresh time.",
"// (see https://github.com/appleboy/gin-jwt/issues/176)",
"validationErr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"jwt",
".",
"ValidationError",
")",
"\n",
"if",
"!",
"ok",
"||",
"validationErr",
".",
"Errors",
"!=",
"jwt",
".",
"ValidationErrorExpired",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"claims",
":=",
"token",
".",
"Claims",
".",
"(",
"jwt",
".",
"MapClaims",
")",
"\n\n",
"origIat",
":=",
"int64",
"(",
"claims",
"[",
"\"",
"\"",
"]",
".",
"(",
"float64",
")",
")",
"\n\n",
"if",
"origIat",
"<",
"mw",
".",
"TimeFunc",
"(",
")",
".",
"Add",
"(",
"-",
"mw",
".",
"MaxRefresh",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"nil",
",",
"ErrExpiredToken",
"\n",
"}",
"\n\n",
"return",
"claims",
",",
"nil",
"\n",
"}"
] |
// CheckIfTokenExpire check if token expire
|
[
"CheckIfTokenExpire",
"check",
"if",
"token",
"expire"
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L526-L550
|
148,930 |
appleboy/gin-jwt
|
auth_jwt.go
|
TokenGenerator
|
func (mw *GinJWTMiddleware) TokenGenerator(data interface{}) (string, time.Time, error) {
token := jwt.New(jwt.GetSigningMethod(mw.SigningAlgorithm))
claims := token.Claims.(jwt.MapClaims)
if mw.PayloadFunc != nil {
for key, value := range mw.PayloadFunc(data) {
claims[key] = value
}
}
expire := mw.TimeFunc().UTC().Add(mw.Timeout)
claims["exp"] = expire.Unix()
claims["orig_iat"] = mw.TimeFunc().Unix()
tokenString, err := mw.signedString(token)
if err != nil {
return "", time.Time{}, err
}
return tokenString, expire, nil
}
|
go
|
func (mw *GinJWTMiddleware) TokenGenerator(data interface{}) (string, time.Time, error) {
token := jwt.New(jwt.GetSigningMethod(mw.SigningAlgorithm))
claims := token.Claims.(jwt.MapClaims)
if mw.PayloadFunc != nil {
for key, value := range mw.PayloadFunc(data) {
claims[key] = value
}
}
expire := mw.TimeFunc().UTC().Add(mw.Timeout)
claims["exp"] = expire.Unix()
claims["orig_iat"] = mw.TimeFunc().Unix()
tokenString, err := mw.signedString(token)
if err != nil {
return "", time.Time{}, err
}
return tokenString, expire, nil
}
|
[
"func",
"(",
"mw",
"*",
"GinJWTMiddleware",
")",
"TokenGenerator",
"(",
"data",
"interface",
"{",
"}",
")",
"(",
"string",
",",
"time",
".",
"Time",
",",
"error",
")",
"{",
"token",
":=",
"jwt",
".",
"New",
"(",
"jwt",
".",
"GetSigningMethod",
"(",
"mw",
".",
"SigningAlgorithm",
")",
")",
"\n",
"claims",
":=",
"token",
".",
"Claims",
".",
"(",
"jwt",
".",
"MapClaims",
")",
"\n\n",
"if",
"mw",
".",
"PayloadFunc",
"!=",
"nil",
"{",
"for",
"key",
",",
"value",
":=",
"range",
"mw",
".",
"PayloadFunc",
"(",
"data",
")",
"{",
"claims",
"[",
"key",
"]",
"=",
"value",
"\n",
"}",
"\n",
"}",
"\n\n",
"expire",
":=",
"mw",
".",
"TimeFunc",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"mw",
".",
"Timeout",
")",
"\n",
"claims",
"[",
"\"",
"\"",
"]",
"=",
"expire",
".",
"Unix",
"(",
")",
"\n",
"claims",
"[",
"\"",
"\"",
"]",
"=",
"mw",
".",
"TimeFunc",
"(",
")",
".",
"Unix",
"(",
")",
"\n",
"tokenString",
",",
"err",
":=",
"mw",
".",
"signedString",
"(",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"time",
".",
"Time",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"tokenString",
",",
"expire",
",",
"nil",
"\n",
"}"
] |
// TokenGenerator method that clients can use to get a jwt token.
|
[
"TokenGenerator",
"method",
"that",
"clients",
"can",
"use",
"to",
"get",
"a",
"jwt",
"token",
"."
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L553-L572
|
148,931 |
appleboy/gin-jwt
|
auth_jwt.go
|
ParseToken
|
func (mw *GinJWTMiddleware) ParseToken(c *gin.Context) (*jwt.Token, error) {
var token string
var err error
methods := strings.Split(mw.TokenLookup, ",")
for _, method := range methods {
if len(token) > 0 {
break
}
parts := strings.Split(strings.TrimSpace(method), ":")
k := strings.TrimSpace(parts[0])
v := strings.TrimSpace(parts[1])
switch k {
case "header":
token, err = mw.jwtFromHeader(c, v)
case "query":
token, err = mw.jwtFromQuery(c, v)
case "cookie":
token, err = mw.jwtFromCookie(c, v)
case "param":
token, err = mw.jwtFromParam(c, v)
}
}
if err != nil {
return nil, err
}
return jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
if jwt.GetSigningMethod(mw.SigningAlgorithm) != t.Method {
return nil, ErrInvalidSigningAlgorithm
}
if mw.usingPublicKeyAlgo() {
return mw.pubKey, nil
}
// save token string if vaild
c.Set("JWT_TOKEN", token)
return mw.Key, nil
})
}
|
go
|
func (mw *GinJWTMiddleware) ParseToken(c *gin.Context) (*jwt.Token, error) {
var token string
var err error
methods := strings.Split(mw.TokenLookup, ",")
for _, method := range methods {
if len(token) > 0 {
break
}
parts := strings.Split(strings.TrimSpace(method), ":")
k := strings.TrimSpace(parts[0])
v := strings.TrimSpace(parts[1])
switch k {
case "header":
token, err = mw.jwtFromHeader(c, v)
case "query":
token, err = mw.jwtFromQuery(c, v)
case "cookie":
token, err = mw.jwtFromCookie(c, v)
case "param":
token, err = mw.jwtFromParam(c, v)
}
}
if err != nil {
return nil, err
}
return jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
if jwt.GetSigningMethod(mw.SigningAlgorithm) != t.Method {
return nil, ErrInvalidSigningAlgorithm
}
if mw.usingPublicKeyAlgo() {
return mw.pubKey, nil
}
// save token string if vaild
c.Set("JWT_TOKEN", token)
return mw.Key, nil
})
}
|
[
"func",
"(",
"mw",
"*",
"GinJWTMiddleware",
")",
"ParseToken",
"(",
"c",
"*",
"gin",
".",
"Context",
")",
"(",
"*",
"jwt",
".",
"Token",
",",
"error",
")",
"{",
"var",
"token",
"string",
"\n",
"var",
"err",
"error",
"\n\n",
"methods",
":=",
"strings",
".",
"Split",
"(",
"mw",
".",
"TokenLookup",
",",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"method",
":=",
"range",
"methods",
"{",
"if",
"len",
"(",
"token",
")",
">",
"0",
"{",
"break",
"\n",
"}",
"\n",
"parts",
":=",
"strings",
".",
"Split",
"(",
"strings",
".",
"TrimSpace",
"(",
"method",
")",
",",
"\"",
"\"",
")",
"\n",
"k",
":=",
"strings",
".",
"TrimSpace",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"v",
":=",
"strings",
".",
"TrimSpace",
"(",
"parts",
"[",
"1",
"]",
")",
"\n",
"switch",
"k",
"{",
"case",
"\"",
"\"",
":",
"token",
",",
"err",
"=",
"mw",
".",
"jwtFromHeader",
"(",
"c",
",",
"v",
")",
"\n",
"case",
"\"",
"\"",
":",
"token",
",",
"err",
"=",
"mw",
".",
"jwtFromQuery",
"(",
"c",
",",
"v",
")",
"\n",
"case",
"\"",
"\"",
":",
"token",
",",
"err",
"=",
"mw",
".",
"jwtFromCookie",
"(",
"c",
",",
"v",
")",
"\n",
"case",
"\"",
"\"",
":",
"token",
",",
"err",
"=",
"mw",
".",
"jwtFromParam",
"(",
"c",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"jwt",
".",
"Parse",
"(",
"token",
",",
"func",
"(",
"t",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"jwt",
".",
"GetSigningMethod",
"(",
"mw",
".",
"SigningAlgorithm",
")",
"!=",
"t",
".",
"Method",
"{",
"return",
"nil",
",",
"ErrInvalidSigningAlgorithm",
"\n",
"}",
"\n",
"if",
"mw",
".",
"usingPublicKeyAlgo",
"(",
")",
"{",
"return",
"mw",
".",
"pubKey",
",",
"nil",
"\n",
"}",
"\n\n",
"// save token string if vaild",
"c",
".",
"Set",
"(",
"\"",
"\"",
",",
"token",
")",
"\n\n",
"return",
"mw",
".",
"Key",
",",
"nil",
"\n",
"}",
")",
"\n",
"}"
] |
// ParseToken parse jwt token from gin context
|
[
"ParseToken",
"parse",
"jwt",
"token",
"from",
"gin",
"context"
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L620-L661
|
148,932 |
appleboy/gin-jwt
|
auth_jwt.go
|
ParseTokenString
|
func (mw *GinJWTMiddleware) ParseTokenString(token string) (*jwt.Token, error) {
return jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
if jwt.GetSigningMethod(mw.SigningAlgorithm) != t.Method {
return nil, ErrInvalidSigningAlgorithm
}
if mw.usingPublicKeyAlgo() {
return mw.pubKey, nil
}
return mw.Key, nil
})
}
|
go
|
func (mw *GinJWTMiddleware) ParseTokenString(token string) (*jwt.Token, error) {
return jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
if jwt.GetSigningMethod(mw.SigningAlgorithm) != t.Method {
return nil, ErrInvalidSigningAlgorithm
}
if mw.usingPublicKeyAlgo() {
return mw.pubKey, nil
}
return mw.Key, nil
})
}
|
[
"func",
"(",
"mw",
"*",
"GinJWTMiddleware",
")",
"ParseTokenString",
"(",
"token",
"string",
")",
"(",
"*",
"jwt",
".",
"Token",
",",
"error",
")",
"{",
"return",
"jwt",
".",
"Parse",
"(",
"token",
",",
"func",
"(",
"t",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"jwt",
".",
"GetSigningMethod",
"(",
"mw",
".",
"SigningAlgorithm",
")",
"!=",
"t",
".",
"Method",
"{",
"return",
"nil",
",",
"ErrInvalidSigningAlgorithm",
"\n",
"}",
"\n",
"if",
"mw",
".",
"usingPublicKeyAlgo",
"(",
")",
"{",
"return",
"mw",
".",
"pubKey",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"mw",
".",
"Key",
",",
"nil",
"\n",
"}",
")",
"\n",
"}"
] |
// ParseTokenString parse jwt token string
|
[
"ParseTokenString",
"parse",
"jwt",
"token",
"string"
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L664-L675
|
148,933 |
appleboy/gin-jwt
|
auth_jwt.go
|
ExtractClaims
|
func ExtractClaims(c *gin.Context) MapClaims {
claims, exists := c.Get("JWT_PAYLOAD")
if !exists {
return make(MapClaims)
}
return claims.(MapClaims)
}
|
go
|
func ExtractClaims(c *gin.Context) MapClaims {
claims, exists := c.Get("JWT_PAYLOAD")
if !exists {
return make(MapClaims)
}
return claims.(MapClaims)
}
|
[
"func",
"ExtractClaims",
"(",
"c",
"*",
"gin",
".",
"Context",
")",
"MapClaims",
"{",
"claims",
",",
"exists",
":=",
"c",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"!",
"exists",
"{",
"return",
"make",
"(",
"MapClaims",
")",
"\n",
"}",
"\n\n",
"return",
"claims",
".",
"(",
"MapClaims",
")",
"\n",
"}"
] |
// ExtractClaims help to extract the JWT claims
|
[
"ExtractClaims",
"help",
"to",
"extract",
"the",
"JWT",
"claims"
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L687-L694
|
148,934 |
appleboy/gin-jwt
|
auth_jwt.go
|
ExtractClaimsFromToken
|
func ExtractClaimsFromToken(token *jwt.Token) MapClaims {
if token == nil {
return make(MapClaims)
}
claims := MapClaims{}
for key, value := range token.Claims.(jwt.MapClaims) {
claims[key] = value
}
return claims
}
|
go
|
func ExtractClaimsFromToken(token *jwt.Token) MapClaims {
if token == nil {
return make(MapClaims)
}
claims := MapClaims{}
for key, value := range token.Claims.(jwt.MapClaims) {
claims[key] = value
}
return claims
}
|
[
"func",
"ExtractClaimsFromToken",
"(",
"token",
"*",
"jwt",
".",
"Token",
")",
"MapClaims",
"{",
"if",
"token",
"==",
"nil",
"{",
"return",
"make",
"(",
"MapClaims",
")",
"\n",
"}",
"\n\n",
"claims",
":=",
"MapClaims",
"{",
"}",
"\n",
"for",
"key",
",",
"value",
":=",
"range",
"token",
".",
"Claims",
".",
"(",
"jwt",
".",
"MapClaims",
")",
"{",
"claims",
"[",
"key",
"]",
"=",
"value",
"\n",
"}",
"\n\n",
"return",
"claims",
"\n",
"}"
] |
// ExtractClaimsFromToken help to extract the JWT claims from token
|
[
"ExtractClaimsFromToken",
"help",
"to",
"extract",
"the",
"JWT",
"claims",
"from",
"token"
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L697-L708
|
148,935 |
appleboy/gin-jwt
|
auth_jwt.go
|
GetToken
|
func GetToken(c *gin.Context) string {
token, exists := c.Get("JWT_TOKEN")
if !exists {
return ""
}
return token.(string)
}
|
go
|
func GetToken(c *gin.Context) string {
token, exists := c.Get("JWT_TOKEN")
if !exists {
return ""
}
return token.(string)
}
|
[
"func",
"GetToken",
"(",
"c",
"*",
"gin",
".",
"Context",
")",
"string",
"{",
"token",
",",
"exists",
":=",
"c",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"!",
"exists",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"token",
".",
"(",
"string",
")",
"\n",
"}"
] |
// GetToken help to get the JWT token string
|
[
"GetToken",
"help",
"to",
"get",
"the",
"JWT",
"token",
"string"
] |
633d983b91f09beefb1128c4558d4642a379c602
|
https://github.com/appleboy/gin-jwt/blob/633d983b91f09beefb1128c4558d4642a379c602/auth_jwt.go#L711-L718
|
148,936 |
brianvoe/gofakeit
|
user_agent.go
|
UserAgent
|
func UserAgent() string {
randNum := randIntRange(0, 4)
switch randNum {
case 0:
return ChromeUserAgent()
case 1:
return FirefoxUserAgent()
case 2:
return SafariUserAgent()
case 3:
return OperaUserAgent()
default:
return ChromeUserAgent()
}
}
|
go
|
func UserAgent() string {
randNum := randIntRange(0, 4)
switch randNum {
case 0:
return ChromeUserAgent()
case 1:
return FirefoxUserAgent()
case 2:
return SafariUserAgent()
case 3:
return OperaUserAgent()
default:
return ChromeUserAgent()
}
}
|
[
"func",
"UserAgent",
"(",
")",
"string",
"{",
"randNum",
":=",
"randIntRange",
"(",
"0",
",",
"4",
")",
"\n",
"switch",
"randNum",
"{",
"case",
"0",
":",
"return",
"ChromeUserAgent",
"(",
")",
"\n",
"case",
"1",
":",
"return",
"FirefoxUserAgent",
"(",
")",
"\n",
"case",
"2",
":",
"return",
"SafariUserAgent",
"(",
")",
"\n",
"case",
"3",
":",
"return",
"OperaUserAgent",
"(",
")",
"\n",
"default",
":",
"return",
"ChromeUserAgent",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// UserAgent will generate a random broswer user agent
|
[
"UserAgent",
"will",
"generate",
"a",
"random",
"broswer",
"user",
"agent"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/user_agent.go#L6-L20
|
148,937 |
brianvoe/gofakeit
|
user_agent.go
|
ChromeUserAgent
|
func ChromeUserAgent() string {
randNum1 := strconv.Itoa(randIntRange(531, 536)) + strconv.Itoa(randIntRange(0, 2))
randNum2 := strconv.Itoa(randIntRange(36, 40))
randNum3 := strconv.Itoa(randIntRange(800, 899))
return "Mozilla/5.0 " + "(" + randomPlatform() + ") AppleWebKit/" + randNum1 + " (KHTML, like Gecko) Chrome/" + randNum2 + ".0." + randNum3 + ".0 Mobile Safari/" + randNum1
}
|
go
|
func ChromeUserAgent() string {
randNum1 := strconv.Itoa(randIntRange(531, 536)) + strconv.Itoa(randIntRange(0, 2))
randNum2 := strconv.Itoa(randIntRange(36, 40))
randNum3 := strconv.Itoa(randIntRange(800, 899))
return "Mozilla/5.0 " + "(" + randomPlatform() + ") AppleWebKit/" + randNum1 + " (KHTML, like Gecko) Chrome/" + randNum2 + ".0." + randNum3 + ".0 Mobile Safari/" + randNum1
}
|
[
"func",
"ChromeUserAgent",
"(",
")",
"string",
"{",
"randNum1",
":=",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"531",
",",
"536",
")",
")",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"0",
",",
"2",
")",
")",
"\n",
"randNum2",
":=",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"36",
",",
"40",
")",
")",
"\n",
"randNum3",
":=",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"800",
",",
"899",
")",
")",
"\n",
"return",
"\"",
"\"",
"+",
"\"",
"\"",
"+",
"randomPlatform",
"(",
")",
"+",
"\"",
"\"",
"+",
"randNum1",
"+",
"\"",
"\"",
"+",
"randNum2",
"+",
"\"",
"\"",
"+",
"randNum3",
"+",
"\"",
"\"",
"+",
"randNum1",
"\n",
"}"
] |
// ChromeUserAgent will generate a random chrome browser user agent string
|
[
"ChromeUserAgent",
"will",
"generate",
"a",
"random",
"chrome",
"browser",
"user",
"agent",
"string"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/user_agent.go#L23-L28
|
148,938 |
brianvoe/gofakeit
|
user_agent.go
|
FirefoxUserAgent
|
func FirefoxUserAgent() string {
ver := "Gecko/" + Date().Format("2006-02-01") + " Firefox/" + strconv.Itoa(randIntRange(35, 37)) + ".0"
platforms := []string{
"(" + windowsPlatformToken() + "; " + "en-US" + "; rv:1.9." + strconv.Itoa(randIntRange(0, 3)) + ".20) " + ver,
"(" + linuxPlatformToken() + "; rv:" + strconv.Itoa(randIntRange(5, 8)) + ".0) " + ver,
"(" + macPlatformToken() + " rv:" + strconv.Itoa(randIntRange(2, 7)) + ".0) " + ver,
}
return "Mozilla/5.0 " + RandString(platforms)
}
|
go
|
func FirefoxUserAgent() string {
ver := "Gecko/" + Date().Format("2006-02-01") + " Firefox/" + strconv.Itoa(randIntRange(35, 37)) + ".0"
platforms := []string{
"(" + windowsPlatformToken() + "; " + "en-US" + "; rv:1.9." + strconv.Itoa(randIntRange(0, 3)) + ".20) " + ver,
"(" + linuxPlatformToken() + "; rv:" + strconv.Itoa(randIntRange(5, 8)) + ".0) " + ver,
"(" + macPlatformToken() + " rv:" + strconv.Itoa(randIntRange(2, 7)) + ".0) " + ver,
}
return "Mozilla/5.0 " + RandString(platforms)
}
|
[
"func",
"FirefoxUserAgent",
"(",
")",
"string",
"{",
"ver",
":=",
"\"",
"\"",
"+",
"Date",
"(",
")",
".",
"Format",
"(",
"\"",
"\"",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"35",
",",
"37",
")",
")",
"+",
"\"",
"\"",
"\n",
"platforms",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
"+",
"windowsPlatformToken",
"(",
")",
"+",
"\"",
"\"",
"+",
"\"",
"\"",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"0",
",",
"3",
")",
")",
"+",
"\"",
"\"",
"+",
"ver",
",",
"\"",
"\"",
"+",
"linuxPlatformToken",
"(",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"5",
",",
"8",
")",
")",
"+",
"\"",
"\"",
"+",
"ver",
",",
"\"",
"\"",
"+",
"macPlatformToken",
"(",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"2",
",",
"7",
")",
")",
"+",
"\"",
"\"",
"+",
"ver",
",",
"}",
"\n\n",
"return",
"\"",
"\"",
"+",
"RandString",
"(",
"platforms",
")",
"\n",
"}"
] |
// FirefoxUserAgent will generate a random firefox broswer user agent string
|
[
"FirefoxUserAgent",
"will",
"generate",
"a",
"random",
"firefox",
"broswer",
"user",
"agent",
"string"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/user_agent.go#L31-L40
|
148,939 |
brianvoe/gofakeit
|
user_agent.go
|
SafariUserAgent
|
func SafariUserAgent() string {
randNum := strconv.Itoa(randIntRange(531, 536)) + "." + strconv.Itoa(randIntRange(1, 51)) + "." + strconv.Itoa(randIntRange(1, 8))
ver := strconv.Itoa(randIntRange(4, 6)) + "." + strconv.Itoa(randIntRange(0, 2))
mobileDevices := []string{
"iPhone; CPU iPhone OS",
"iPad; CPU OS",
}
platforms := []string{
"(Windows; U; " + windowsPlatformToken() + ") AppleWebKit/" + randNum + " (KHTML, like Gecko) Version/" + ver + " Safari/" + randNum,
"(" + macPlatformToken() + " rv:" + strconv.Itoa(randIntRange(4, 7)) + ".0; en-US) AppleWebKit/" + randNum + " (KHTML, like Gecko) Version/" + ver + " Safari/" + randNum,
"(" + RandString(mobileDevices) + " " + strconv.Itoa(randIntRange(7, 9)) + "_" + strconv.Itoa(randIntRange(0, 3)) + "_" + strconv.Itoa(randIntRange(1, 3)) + " like Mac OS X; " + "en-US" + ") AppleWebKit/" + randNum + " (KHTML, like Gecko) Version/" + strconv.Itoa(randIntRange(3, 5)) + ".0.5 Mobile/8B" + strconv.Itoa(randIntRange(111, 120)) + " Safari/6" + randNum,
}
return "Mozilla/5.0 " + RandString(platforms)
}
|
go
|
func SafariUserAgent() string {
randNum := strconv.Itoa(randIntRange(531, 536)) + "." + strconv.Itoa(randIntRange(1, 51)) + "." + strconv.Itoa(randIntRange(1, 8))
ver := strconv.Itoa(randIntRange(4, 6)) + "." + strconv.Itoa(randIntRange(0, 2))
mobileDevices := []string{
"iPhone; CPU iPhone OS",
"iPad; CPU OS",
}
platforms := []string{
"(Windows; U; " + windowsPlatformToken() + ") AppleWebKit/" + randNum + " (KHTML, like Gecko) Version/" + ver + " Safari/" + randNum,
"(" + macPlatformToken() + " rv:" + strconv.Itoa(randIntRange(4, 7)) + ".0; en-US) AppleWebKit/" + randNum + " (KHTML, like Gecko) Version/" + ver + " Safari/" + randNum,
"(" + RandString(mobileDevices) + " " + strconv.Itoa(randIntRange(7, 9)) + "_" + strconv.Itoa(randIntRange(0, 3)) + "_" + strconv.Itoa(randIntRange(1, 3)) + " like Mac OS X; " + "en-US" + ") AppleWebKit/" + randNum + " (KHTML, like Gecko) Version/" + strconv.Itoa(randIntRange(3, 5)) + ".0.5 Mobile/8B" + strconv.Itoa(randIntRange(111, 120)) + " Safari/6" + randNum,
}
return "Mozilla/5.0 " + RandString(platforms)
}
|
[
"func",
"SafariUserAgent",
"(",
")",
"string",
"{",
"randNum",
":=",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"531",
",",
"536",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"1",
",",
"51",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"1",
",",
"8",
")",
")",
"\n",
"ver",
":=",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"4",
",",
"6",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"0",
",",
"2",
")",
")",
"\n\n",
"mobileDevices",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"}",
"\n\n",
"platforms",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
"+",
"windowsPlatformToken",
"(",
")",
"+",
"\"",
"\"",
"+",
"randNum",
"+",
"\"",
"\"",
"+",
"ver",
"+",
"\"",
"\"",
"+",
"randNum",
",",
"\"",
"\"",
"+",
"macPlatformToken",
"(",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"4",
",",
"7",
")",
")",
"+",
"\"",
"\"",
"+",
"randNum",
"+",
"\"",
"\"",
"+",
"ver",
"+",
"\"",
"\"",
"+",
"randNum",
",",
"\"",
"\"",
"+",
"RandString",
"(",
"mobileDevices",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"7",
",",
"9",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"0",
",",
"3",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"1",
",",
"3",
")",
")",
"+",
"\"",
"\"",
"+",
"\"",
"\"",
"+",
"\"",
"\"",
"+",
"randNum",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"3",
",",
"5",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"111",
",",
"120",
")",
")",
"+",
"\"",
"\"",
"+",
"randNum",
",",
"}",
"\n\n",
"return",
"\"",
"\"",
"+",
"RandString",
"(",
"platforms",
")",
"\n",
"}"
] |
// SafariUserAgent will generate a random safari browser user agent string
|
[
"SafariUserAgent",
"will",
"generate",
"a",
"random",
"safari",
"browser",
"user",
"agent",
"string"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/user_agent.go#L43-L59
|
148,940 |
brianvoe/gofakeit
|
user_agent.go
|
OperaUserAgent
|
func OperaUserAgent() string {
platform := "(" + randomPlatform() + "; en-US) Presto/2." + strconv.Itoa(randIntRange(8, 13)) + "." + strconv.Itoa(randIntRange(160, 355)) + " Version/" + strconv.Itoa(randIntRange(10, 13)) + ".00"
return "Opera/" + strconv.Itoa(randIntRange(8, 10)) + "." + strconv.Itoa(randIntRange(10, 99)) + " " + platform
}
|
go
|
func OperaUserAgent() string {
platform := "(" + randomPlatform() + "; en-US) Presto/2." + strconv.Itoa(randIntRange(8, 13)) + "." + strconv.Itoa(randIntRange(160, 355)) + " Version/" + strconv.Itoa(randIntRange(10, 13)) + ".00"
return "Opera/" + strconv.Itoa(randIntRange(8, 10)) + "." + strconv.Itoa(randIntRange(10, 99)) + " " + platform
}
|
[
"func",
"OperaUserAgent",
"(",
")",
"string",
"{",
"platform",
":=",
"\"",
"\"",
"+",
"randomPlatform",
"(",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"8",
",",
"13",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"160",
",",
"355",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"10",
",",
"13",
")",
")",
"+",
"\"",
"\"",
"\n\n",
"return",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"8",
",",
"10",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"10",
",",
"99",
")",
")",
"+",
"\"",
"\"",
"+",
"platform",
"\n",
"}"
] |
// OperaUserAgent will generate a random opera browser user agent string
|
[
"OperaUserAgent",
"will",
"generate",
"a",
"random",
"opera",
"browser",
"user",
"agent",
"string"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/user_agent.go#L62-L66
|
148,941 |
brianvoe/gofakeit
|
user_agent.go
|
macPlatformToken
|
func macPlatformToken() string {
return "Macintosh; " + getRandValue([]string{"computer", "mac_processor"}) + " Mac OS X 10_" + strconv.Itoa(randIntRange(5, 9)) + "_" + strconv.Itoa(randIntRange(0, 10))
}
|
go
|
func macPlatformToken() string {
return "Macintosh; " + getRandValue([]string{"computer", "mac_processor"}) + " Mac OS X 10_" + strconv.Itoa(randIntRange(5, 9)) + "_" + strconv.Itoa(randIntRange(0, 10))
}
|
[
"func",
"macPlatformToken",
"(",
")",
"string",
"{",
"return",
"\"",
"\"",
"+",
"getRandValue",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"5",
",",
"9",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"0",
",",
"10",
")",
")",
"\n",
"}"
] |
// macPlatformToken will generate a random mac platform
|
[
"macPlatformToken",
"will",
"generate",
"a",
"random",
"mac",
"platform"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/user_agent.go#L74-L76
|
148,942 |
brianvoe/gofakeit
|
address.go
|
Address
|
func Address() *AddressInfo {
street := Street()
city := City()
state := State()
zip := Zip()
return &AddressInfo{
Address: street + ", " + city + ", " + state + " " + zip,
Street: street,
City: city,
State: state,
Zip: zip,
Country: Country(),
Latitude: Latitude(),
Longitude: Longitude(),
}
}
|
go
|
func Address() *AddressInfo {
street := Street()
city := City()
state := State()
zip := Zip()
return &AddressInfo{
Address: street + ", " + city + ", " + state + " " + zip,
Street: street,
City: city,
State: state,
Zip: zip,
Country: Country(),
Latitude: Latitude(),
Longitude: Longitude(),
}
}
|
[
"func",
"Address",
"(",
")",
"*",
"AddressInfo",
"{",
"street",
":=",
"Street",
"(",
")",
"\n",
"city",
":=",
"City",
"(",
")",
"\n",
"state",
":=",
"State",
"(",
")",
"\n",
"zip",
":=",
"Zip",
"(",
")",
"\n\n",
"return",
"&",
"AddressInfo",
"{",
"Address",
":",
"street",
"+",
"\"",
"\"",
"+",
"city",
"+",
"\"",
"\"",
"+",
"state",
"+",
"\"",
"\"",
"+",
"zip",
",",
"Street",
":",
"street",
",",
"City",
":",
"city",
",",
"State",
":",
"state",
",",
"Zip",
":",
"zip",
",",
"Country",
":",
"Country",
"(",
")",
",",
"Latitude",
":",
"Latitude",
"(",
")",
",",
"Longitude",
":",
"Longitude",
"(",
")",
",",
"}",
"\n",
"}"
] |
// Address will generate a struct of address information
|
[
"Address",
"will",
"generate",
"a",
"struct",
"of",
"address",
"information"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/address.go#L22-L38
|
148,943 |
brianvoe/gofakeit
|
address.go
|
Street
|
func Street() (street string) {
switch randInt := randIntRange(1, 2); randInt {
case 1:
street = StreetNumber() + " " + StreetPrefix() + " " + StreetName() + StreetSuffix()
case 2:
street = StreetNumber() + " " + StreetName() + StreetSuffix()
}
return
}
|
go
|
func Street() (street string) {
switch randInt := randIntRange(1, 2); randInt {
case 1:
street = StreetNumber() + " " + StreetPrefix() + " " + StreetName() + StreetSuffix()
case 2:
street = StreetNumber() + " " + StreetName() + StreetSuffix()
}
return
}
|
[
"func",
"Street",
"(",
")",
"(",
"street",
"string",
")",
"{",
"switch",
"randInt",
":=",
"randIntRange",
"(",
"1",
",",
"2",
")",
";",
"randInt",
"{",
"case",
"1",
":",
"street",
"=",
"StreetNumber",
"(",
")",
"+",
"\"",
"\"",
"+",
"StreetPrefix",
"(",
")",
"+",
"\"",
"\"",
"+",
"StreetName",
"(",
")",
"+",
"StreetSuffix",
"(",
")",
"\n",
"case",
"2",
":",
"street",
"=",
"StreetNumber",
"(",
")",
"+",
"\"",
"\"",
"+",
"StreetName",
"(",
")",
"+",
"StreetSuffix",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Street will generate a random address street string
|
[
"Street",
"will",
"generate",
"a",
"random",
"address",
"street",
"string"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/address.go#L41-L50
|
148,944 |
brianvoe/gofakeit
|
address.go
|
City
|
func City() (city string) {
switch randInt := randIntRange(1, 3); randInt {
case 1:
city = FirstName() + StreetSuffix()
case 2:
city = LastName() + StreetSuffix()
case 3:
city = StreetPrefix() + " " + LastName()
}
return
}
|
go
|
func City() (city string) {
switch randInt := randIntRange(1, 3); randInt {
case 1:
city = FirstName() + StreetSuffix()
case 2:
city = LastName() + StreetSuffix()
case 3:
city = StreetPrefix() + " " + LastName()
}
return
}
|
[
"func",
"City",
"(",
")",
"(",
"city",
"string",
")",
"{",
"switch",
"randInt",
":=",
"randIntRange",
"(",
"1",
",",
"3",
")",
";",
"randInt",
"{",
"case",
"1",
":",
"city",
"=",
"FirstName",
"(",
")",
"+",
"StreetSuffix",
"(",
")",
"\n",
"case",
"2",
":",
"city",
"=",
"LastName",
"(",
")",
"+",
"StreetSuffix",
"(",
")",
"\n",
"case",
"3",
":",
"city",
"=",
"StreetPrefix",
"(",
")",
"+",
"\"",
"\"",
"+",
"LastName",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// City will generate a random city string
|
[
"City",
"will",
"generate",
"a",
"random",
"city",
"string"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/address.go#L73-L84
|
148,945 |
brianvoe/gofakeit
|
address.go
|
LongitudeInRange
|
func LongitudeInRange(min, max float64) (float64, error) {
if min > max || min < -180 || min > 180 || max < -180 || max > 180 {
return 0, errors.New("input range is invalid")
}
return randFloat64Range(min, max), nil
}
|
go
|
func LongitudeInRange(min, max float64) (float64, error) {
if min > max || min < -180 || min > 180 || max < -180 || max > 180 {
return 0, errors.New("input range is invalid")
}
return randFloat64Range(min, max), nil
}
|
[
"func",
"LongitudeInRange",
"(",
"min",
",",
"max",
"float64",
")",
"(",
"float64",
",",
"error",
")",
"{",
"if",
"min",
">",
"max",
"||",
"min",
"<",
"-",
"180",
"||",
"min",
">",
"180",
"||",
"max",
"<",
"-",
"180",
"||",
"max",
">",
"180",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"randFloat64Range",
"(",
"min",
",",
"max",
")",
",",
"nil",
"\n",
"}"
] |
// LongitudeInRange will generate a random longitude within the input range
|
[
"LongitudeInRange",
"will",
"generate",
"a",
"random",
"longitude",
"within",
"the",
"input",
"range"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/address.go#L126-L131
|
148,946 |
brianvoe/gofakeit
|
misc.go
|
getRandValue
|
func getRandValue(dataVal []string) string {
if !dataCheck(dataVal) {
return ""
}
return data.Data[dataVal[0]][dataVal[1]][rand.Intn(len(data.Data[dataVal[0]][dataVal[1]]))]
}
|
go
|
func getRandValue(dataVal []string) string {
if !dataCheck(dataVal) {
return ""
}
return data.Data[dataVal[0]][dataVal[1]][rand.Intn(len(data.Data[dataVal[0]][dataVal[1]]))]
}
|
[
"func",
"getRandValue",
"(",
"dataVal",
"[",
"]",
"string",
")",
"string",
"{",
"if",
"!",
"dataCheck",
"(",
"dataVal",
")",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"data",
".",
"Data",
"[",
"dataVal",
"[",
"0",
"]",
"]",
"[",
"dataVal",
"[",
"1",
"]",
"]",
"[",
"rand",
".",
"Intn",
"(",
"len",
"(",
"data",
".",
"Data",
"[",
"dataVal",
"[",
"0",
"]",
"]",
"[",
"dataVal",
"[",
"1",
"]",
"]",
")",
")",
"]",
"\n",
"}"
] |
// Get Random Value
|
[
"Get",
"Random",
"Value"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/misc.go#L41-L46
|
148,947 |
brianvoe/gofakeit
|
misc.go
|
getRandIntValue
|
func getRandIntValue(dataVal []string) int {
if !intDataCheck(dataVal) {
return 0
}
return data.IntData[dataVal[0]][dataVal[1]][rand.Intn(len(data.IntData[dataVal[0]][dataVal[1]]))]
}
|
go
|
func getRandIntValue(dataVal []string) int {
if !intDataCheck(dataVal) {
return 0
}
return data.IntData[dataVal[0]][dataVal[1]][rand.Intn(len(data.IntData[dataVal[0]][dataVal[1]]))]
}
|
[
"func",
"getRandIntValue",
"(",
"dataVal",
"[",
"]",
"string",
")",
"int",
"{",
"if",
"!",
"intDataCheck",
"(",
"dataVal",
")",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"data",
".",
"IntData",
"[",
"dataVal",
"[",
"0",
"]",
"]",
"[",
"dataVal",
"[",
"1",
"]",
"]",
"[",
"rand",
".",
"Intn",
"(",
"len",
"(",
"data",
".",
"IntData",
"[",
"dataVal",
"[",
"0",
"]",
"]",
"[",
"dataVal",
"[",
"1",
"]",
"]",
")",
")",
"]",
"\n",
"}"
] |
// Get Random Integer Value
|
[
"Get",
"Random",
"Integer",
"Value"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/misc.go#L49-L54
|
148,948 |
brianvoe/gofakeit
|
misc.go
|
replaceWithLetters
|
func replaceWithLetters(str string) string {
if str == "" {
return str
}
bytestr := []byte(str)
for i := 0; i < len(bytestr); i++ {
if bytestr[i] == questionmark {
bytestr[i] = byte(randLetter())
}
}
return string(bytestr)
}
|
go
|
func replaceWithLetters(str string) string {
if str == "" {
return str
}
bytestr := []byte(str)
for i := 0; i < len(bytestr); i++ {
if bytestr[i] == questionmark {
bytestr[i] = byte(randLetter())
}
}
return string(bytestr)
}
|
[
"func",
"replaceWithLetters",
"(",
"str",
"string",
")",
"string",
"{",
"if",
"str",
"==",
"\"",
"\"",
"{",
"return",
"str",
"\n",
"}",
"\n",
"bytestr",
":=",
"[",
"]",
"byte",
"(",
"str",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"bytestr",
")",
";",
"i",
"++",
"{",
"if",
"bytestr",
"[",
"i",
"]",
"==",
"questionmark",
"{",
"bytestr",
"[",
"i",
"]",
"=",
"byte",
"(",
"randLetter",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"string",
"(",
"bytestr",
")",
"\n",
"}"
] |
// Replace ? with ASCII lowercase letters
|
[
"Replace",
"?",
"with",
"ASCII",
"lowercase",
"letters"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/misc.go#L75-L87
|
148,949 |
brianvoe/gofakeit
|
misc.go
|
randIntRange
|
func randIntRange(min, max int) int {
if min == max {
return min
}
return rand.Intn((max+1)-min) + min
}
|
go
|
func randIntRange(min, max int) int {
if min == max {
return min
}
return rand.Intn((max+1)-min) + min
}
|
[
"func",
"randIntRange",
"(",
"min",
",",
"max",
"int",
")",
"int",
"{",
"if",
"min",
"==",
"max",
"{",
"return",
"min",
"\n",
"}",
"\n",
"return",
"rand",
".",
"Intn",
"(",
"(",
"max",
"+",
"1",
")",
"-",
"min",
")",
"+",
"min",
"\n",
"}"
] |
// Generate random integer between min and max
|
[
"Generate",
"random",
"integer",
"between",
"min",
"and",
"max"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/misc.go#L100-L105
|
148,950 |
brianvoe/gofakeit
|
misc.go
|
Categories
|
func Categories() map[string][]string {
types := make(map[string][]string)
for category, subCategoriesMap := range data.Data {
subCategories := make([]string, 0)
for subType := range subCategoriesMap {
subCategories = append(subCategories, subType)
}
types[category] = subCategories
}
return types
}
|
go
|
func Categories() map[string][]string {
types := make(map[string][]string)
for category, subCategoriesMap := range data.Data {
subCategories := make([]string, 0)
for subType := range subCategoriesMap {
subCategories = append(subCategories, subType)
}
types[category] = subCategories
}
return types
}
|
[
"func",
"Categories",
"(",
")",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"types",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n",
"for",
"category",
",",
"subCategoriesMap",
":=",
"range",
"data",
".",
"Data",
"{",
"subCategories",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"for",
"subType",
":=",
"range",
"subCategoriesMap",
"{",
"subCategories",
"=",
"append",
"(",
"subCategories",
",",
"subType",
")",
"\n",
"}",
"\n",
"types",
"[",
"category",
"]",
"=",
"subCategories",
"\n",
"}",
"\n",
"return",
"types",
"\n",
"}"
] |
// Categories will return a map string array of available data categories and sub categories
|
[
"Categories",
"will",
"return",
"a",
"map",
"string",
"array",
"of",
"available",
"data",
"categories",
"and",
"sub",
"categories"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/misc.go#L122-L132
|
148,951 |
brianvoe/gofakeit
|
password.go
|
Password
|
func Password(lower bool, upper bool, numeric bool, special bool, space bool, num int) string {
// Make sure the num minimun is at least 5
if num < 5 {
num = 5
}
i := 0
b := make([]byte, num)
var passString string
if lower {
passString += lowerStr
b[i] = lowerStr[rand.Int63()%int64(len(lowerStr))]
i++
}
if upper {
passString += upperStr
b[i] = upperStr[rand.Int63()%int64(len(upperStr))]
i++
}
if numeric {
passString += numericStr
b[i] = numericStr[rand.Int63()%int64(len(numericStr))]
i++
}
if special {
passString += specialStr
b[i] = specialStr[rand.Int63()%int64(len(specialStr))]
i++
}
if space {
passString += spaceStr
b[i] = spaceStr[rand.Int63()%int64(len(spaceStr))]
i++
}
// Set default if empty
if passString == "" {
passString = lowerStr + numericStr
}
// Loop through and add it up
for i <= num-1 {
b[i] = passString[rand.Int63()%int64(len(passString))]
i++
}
// Shuffle bytes
for i := range b {
j := rand.Intn(i + 1)
b[i], b[j] = b[j], b[i]
}
return string(b)
}
|
go
|
func Password(lower bool, upper bool, numeric bool, special bool, space bool, num int) string {
// Make sure the num minimun is at least 5
if num < 5 {
num = 5
}
i := 0
b := make([]byte, num)
var passString string
if lower {
passString += lowerStr
b[i] = lowerStr[rand.Int63()%int64(len(lowerStr))]
i++
}
if upper {
passString += upperStr
b[i] = upperStr[rand.Int63()%int64(len(upperStr))]
i++
}
if numeric {
passString += numericStr
b[i] = numericStr[rand.Int63()%int64(len(numericStr))]
i++
}
if special {
passString += specialStr
b[i] = specialStr[rand.Int63()%int64(len(specialStr))]
i++
}
if space {
passString += spaceStr
b[i] = spaceStr[rand.Int63()%int64(len(spaceStr))]
i++
}
// Set default if empty
if passString == "" {
passString = lowerStr + numericStr
}
// Loop through and add it up
for i <= num-1 {
b[i] = passString[rand.Int63()%int64(len(passString))]
i++
}
// Shuffle bytes
for i := range b {
j := rand.Intn(i + 1)
b[i], b[j] = b[j], b[i]
}
return string(b)
}
|
[
"func",
"Password",
"(",
"lower",
"bool",
",",
"upper",
"bool",
",",
"numeric",
"bool",
",",
"special",
"bool",
",",
"space",
"bool",
",",
"num",
"int",
")",
"string",
"{",
"// Make sure the num minimun is at least 5",
"if",
"num",
"<",
"5",
"{",
"num",
"=",
"5",
"\n",
"}",
"\n",
"i",
":=",
"0",
"\n",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"num",
")",
"\n",
"var",
"passString",
"string",
"\n\n",
"if",
"lower",
"{",
"passString",
"+=",
"lowerStr",
"\n",
"b",
"[",
"i",
"]",
"=",
"lowerStr",
"[",
"rand",
".",
"Int63",
"(",
")",
"%",
"int64",
"(",
"len",
"(",
"lowerStr",
")",
")",
"]",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"if",
"upper",
"{",
"passString",
"+=",
"upperStr",
"\n",
"b",
"[",
"i",
"]",
"=",
"upperStr",
"[",
"rand",
".",
"Int63",
"(",
")",
"%",
"int64",
"(",
"len",
"(",
"upperStr",
")",
")",
"]",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"if",
"numeric",
"{",
"passString",
"+=",
"numericStr",
"\n",
"b",
"[",
"i",
"]",
"=",
"numericStr",
"[",
"rand",
".",
"Int63",
"(",
")",
"%",
"int64",
"(",
"len",
"(",
"numericStr",
")",
")",
"]",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"if",
"special",
"{",
"passString",
"+=",
"specialStr",
"\n",
"b",
"[",
"i",
"]",
"=",
"specialStr",
"[",
"rand",
".",
"Int63",
"(",
")",
"%",
"int64",
"(",
"len",
"(",
"specialStr",
")",
")",
"]",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"if",
"space",
"{",
"passString",
"+=",
"spaceStr",
"\n",
"b",
"[",
"i",
"]",
"=",
"spaceStr",
"[",
"rand",
".",
"Int63",
"(",
")",
"%",
"int64",
"(",
"len",
"(",
"spaceStr",
")",
")",
"]",
"\n",
"i",
"++",
"\n",
"}",
"\n\n",
"// Set default if empty",
"if",
"passString",
"==",
"\"",
"\"",
"{",
"passString",
"=",
"lowerStr",
"+",
"numericStr",
"\n",
"}",
"\n\n",
"// Loop through and add it up",
"for",
"i",
"<=",
"num",
"-",
"1",
"{",
"b",
"[",
"i",
"]",
"=",
"passString",
"[",
"rand",
".",
"Int63",
"(",
")",
"%",
"int64",
"(",
"len",
"(",
"passString",
")",
")",
"]",
"\n",
"i",
"++",
"\n",
"}",
"\n\n",
"// Shuffle bytes",
"for",
"i",
":=",
"range",
"b",
"{",
"j",
":=",
"rand",
".",
"Intn",
"(",
"i",
"+",
"1",
")",
"\n",
"b",
"[",
"i",
"]",
",",
"b",
"[",
"j",
"]",
"=",
"b",
"[",
"j",
"]",
",",
"b",
"[",
"i",
"]",
"\n",
"}",
"\n\n",
"return",
"string",
"(",
"b",
")",
"\n",
"}"
] |
// Password will generate a random password
// Minimum number length of 5 if less than
|
[
"Password",
"will",
"generate",
"a",
"random",
"password",
"Minimum",
"number",
"length",
"of",
"5",
"if",
"less",
"than"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/password.go#L15-L68
|
148,952 |
brianvoe/gofakeit
|
currency.go
|
Currency
|
func Currency() *CurrencyInfo {
index := rand.Intn(len(data.Data["currency"]["short"]))
return &CurrencyInfo{
Short: data.Data["currency"]["short"][index],
Long: data.Data["currency"]["long"][index],
}
}
|
go
|
func Currency() *CurrencyInfo {
index := rand.Intn(len(data.Data["currency"]["short"]))
return &CurrencyInfo{
Short: data.Data["currency"]["short"][index],
Long: data.Data["currency"]["long"][index],
}
}
|
[
"func",
"Currency",
"(",
")",
"*",
"CurrencyInfo",
"{",
"index",
":=",
"rand",
".",
"Intn",
"(",
"len",
"(",
"data",
".",
"Data",
"[",
"\"",
"\"",
"]",
"[",
"\"",
"\"",
"]",
")",
")",
"\n",
"return",
"&",
"CurrencyInfo",
"{",
"Short",
":",
"data",
".",
"Data",
"[",
"\"",
"\"",
"]",
"[",
"\"",
"\"",
"]",
"[",
"index",
"]",
",",
"Long",
":",
"data",
".",
"Data",
"[",
"\"",
"\"",
"]",
"[",
"\"",
"\"",
"]",
"[",
"index",
"]",
",",
"}",
"\n",
"}"
] |
// Currency will generate a struct with random currency information
|
[
"Currency",
"will",
"generate",
"a",
"struct",
"with",
"random",
"currency",
"information"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/currency.go#L17-L23
|
148,953 |
brianvoe/gofakeit
|
currency.go
|
Price
|
func Price(min, max float64) float64 {
return math.Floor(randFloat64Range(min, max)*100) / 100
}
|
go
|
func Price(min, max float64) float64 {
return math.Floor(randFloat64Range(min, max)*100) / 100
}
|
[
"func",
"Price",
"(",
"min",
",",
"max",
"float64",
")",
"float64",
"{",
"return",
"math",
".",
"Floor",
"(",
"randFloat64Range",
"(",
"min",
",",
"max",
")",
"*",
"100",
")",
"/",
"100",
"\n",
"}"
] |
// Price will take in a min and max value and return a formatted price
|
[
"Price",
"will",
"take",
"in",
"a",
"min",
"and",
"max",
"value",
"and",
"return",
"a",
"formatted",
"price"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/currency.go#L36-L38
|
148,954 |
brianvoe/gofakeit
|
words.go
|
Paragraph
|
func Paragraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string {
return paragraphGenerator(paragrapOptions{paragraphCount, sentenceCount, wordCount, separator}, Sentence)
}
|
go
|
func Paragraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string {
return paragraphGenerator(paragrapOptions{paragraphCount, sentenceCount, wordCount, separator}, Sentence)
}
|
[
"func",
"Paragraph",
"(",
"paragraphCount",
"int",
",",
"sentenceCount",
"int",
",",
"wordCount",
"int",
",",
"separator",
"string",
")",
"string",
"{",
"return",
"paragraphGenerator",
"(",
"paragrapOptions",
"{",
"paragraphCount",
",",
"sentenceCount",
",",
"wordCount",
",",
"separator",
"}",
",",
"Sentence",
")",
"\n",
"}"
] |
// Paragraph will generate a random paragraphGenerator
// Set Paragraph Count
// Set Sentence Count
// Set Word Count
// Set Paragraph Separator
|
[
"Paragraph",
"will",
"generate",
"a",
"random",
"paragraphGenerator",
"Set",
"Paragraph",
"Count",
"Set",
"Sentence",
"Count",
"Set",
"Word",
"Count",
"Set",
"Paragraph",
"Separator"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/words.go#L36-L38
|
148,955 |
brianvoe/gofakeit
|
payment.go
|
CreditCard
|
func CreditCard() *CreditCardInfo {
return &CreditCardInfo{
Type: CreditCardType(),
Number: CreditCardNumber(),
Exp: CreditCardExp(),
Cvv: CreditCardCvv(),
}
}
|
go
|
func CreditCard() *CreditCardInfo {
return &CreditCardInfo{
Type: CreditCardType(),
Number: CreditCardNumber(),
Exp: CreditCardExp(),
Cvv: CreditCardCvv(),
}
}
|
[
"func",
"CreditCard",
"(",
")",
"*",
"CreditCardInfo",
"{",
"return",
"&",
"CreditCardInfo",
"{",
"Type",
":",
"CreditCardType",
"(",
")",
",",
"Number",
":",
"CreditCardNumber",
"(",
")",
",",
"Exp",
":",
"CreditCardExp",
"(",
")",
",",
"Cvv",
":",
"CreditCardCvv",
"(",
")",
",",
"}",
"\n",
"}"
] |
// CreditCard will generate a struct full of credit card information
|
[
"CreditCard",
"will",
"generate",
"a",
"struct",
"full",
"of",
"credit",
"card",
"information"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/payment.go#L17-L24
|
148,956 |
brianvoe/gofakeit
|
payment.go
|
CreditCardNumber
|
func CreditCardNumber() int {
integer, _ := strconv.Atoi(replaceWithNumbers(getRandValue([]string{"payment", "number"})))
return integer
}
|
go
|
func CreditCardNumber() int {
integer, _ := strconv.Atoi(replaceWithNumbers(getRandValue([]string{"payment", "number"})))
return integer
}
|
[
"func",
"CreditCardNumber",
"(",
")",
"int",
"{",
"integer",
",",
"_",
":=",
"strconv",
".",
"Atoi",
"(",
"replaceWithNumbers",
"(",
"getRandValue",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
")",
")",
"\n",
"return",
"integer",
"\n",
"}"
] |
// CreditCardNumber will generate a random credit card number int
|
[
"CreditCardNumber",
"will",
"generate",
"a",
"random",
"credit",
"card",
"number",
"int"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/payment.go#L32-L35
|
148,957 |
brianvoe/gofakeit
|
payment.go
|
CreditCardNumberLuhn
|
func CreditCardNumberLuhn() int {
cc := ""
for i := 0; i < 100000; i++ {
cc = replaceWithNumbers(getRandValue([]string{"payment", "number"}))
if luhn(cc) {
break
}
}
integer, _ := strconv.Atoi(cc)
return integer
}
|
go
|
func CreditCardNumberLuhn() int {
cc := ""
for i := 0; i < 100000; i++ {
cc = replaceWithNumbers(getRandValue([]string{"payment", "number"}))
if luhn(cc) {
break
}
}
integer, _ := strconv.Atoi(cc)
return integer
}
|
[
"func",
"CreditCardNumberLuhn",
"(",
")",
"int",
"{",
"cc",
":=",
"\"",
"\"",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"100000",
";",
"i",
"++",
"{",
"cc",
"=",
"replaceWithNumbers",
"(",
"getRandValue",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
")",
"\n",
"if",
"luhn",
"(",
"cc",
")",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"integer",
",",
"_",
":=",
"strconv",
".",
"Atoi",
"(",
"cc",
")",
"\n",
"return",
"integer",
"\n",
"}"
] |
// CreditCardNumberLuhn will generate a random credit card number int that passes luhn test
|
[
"CreditCardNumberLuhn",
"will",
"generate",
"a",
"random",
"credit",
"card",
"number",
"int",
"that",
"passes",
"luhn",
"test"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/payment.go#L38-L48
|
148,958 |
brianvoe/gofakeit
|
payment.go
|
CreditCardExp
|
func CreditCardExp() string {
month := strconv.Itoa(randIntRange(1, 12))
if len(month) == 1 {
month = "0" + month
}
return month + "/" + strconv.Itoa(randIntRange(currentYear+1, currentYear+10))
}
|
go
|
func CreditCardExp() string {
month := strconv.Itoa(randIntRange(1, 12))
if len(month) == 1 {
month = "0" + month
}
return month + "/" + strconv.Itoa(randIntRange(currentYear+1, currentYear+10))
}
|
[
"func",
"CreditCardExp",
"(",
")",
"string",
"{",
"month",
":=",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"1",
",",
"12",
")",
")",
"\n",
"if",
"len",
"(",
"month",
")",
"==",
"1",
"{",
"month",
"=",
"\"",
"\"",
"+",
"month",
"\n",
"}",
"\n",
"return",
"month",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"randIntRange",
"(",
"currentYear",
"+",
"1",
",",
"currentYear",
"+",
"10",
")",
")",
"\n",
"}"
] |
// CreditCardExp will generate a random credit card expiration date string
// Exp date will always be a future date
|
[
"CreditCardExp",
"will",
"generate",
"a",
"random",
"credit",
"card",
"expiration",
"date",
"string",
"Exp",
"date",
"will",
"always",
"be",
"a",
"future",
"date"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/payment.go#L52-L58
|
148,959 |
brianvoe/gofakeit
|
payment.go
|
luhn
|
func luhn(s string) bool {
var t = [...]int{0, 2, 4, 6, 8, 1, 3, 5, 7, 9}
odd := len(s) & 1
var sum int
for i, c := range s {
if c < '0' || c > '9' {
return false
}
if i&1 == odd {
sum += t[c-'0']
} else {
sum += int(c - '0')
}
}
return sum%10 == 0
}
|
go
|
func luhn(s string) bool {
var t = [...]int{0, 2, 4, 6, 8, 1, 3, 5, 7, 9}
odd := len(s) & 1
var sum int
for i, c := range s {
if c < '0' || c > '9' {
return false
}
if i&1 == odd {
sum += t[c-'0']
} else {
sum += int(c - '0')
}
}
return sum%10 == 0
}
|
[
"func",
"luhn",
"(",
"s",
"string",
")",
"bool",
"{",
"var",
"t",
"=",
"[",
"...",
"]",
"int",
"{",
"0",
",",
"2",
",",
"4",
",",
"6",
",",
"8",
",",
"1",
",",
"3",
",",
"5",
",",
"7",
",",
"9",
"}",
"\n",
"odd",
":=",
"len",
"(",
"s",
")",
"&",
"1",
"\n",
"var",
"sum",
"int",
"\n",
"for",
"i",
",",
"c",
":=",
"range",
"s",
"{",
"if",
"c",
"<",
"'0'",
"||",
"c",
">",
"'9'",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"i",
"&",
"1",
"==",
"odd",
"{",
"sum",
"+=",
"t",
"[",
"c",
"-",
"'0'",
"]",
"\n",
"}",
"else",
"{",
"sum",
"+=",
"int",
"(",
"c",
"-",
"'0'",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"sum",
"%",
"10",
"==",
"0",
"\n",
"}"
] |
// luhn check is used for checking if credit card is valid
|
[
"luhn",
"check",
"is",
"used",
"for",
"checking",
"if",
"credit",
"card",
"is",
"valid"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/payment.go#L66-L81
|
148,960 |
brianvoe/gofakeit
|
color.go
|
HexColor
|
func HexColor() string {
color := make([]byte, 6)
hashQuestion := []byte("?#")
for i := 0; i < 6; i++ {
color[i] = hashQuestion[rand.Intn(2)]
}
return "#" + replaceWithLetters(replaceWithNumbers(string(color)))
// color := ""
// for i := 1; i <= 6; i++ {
// color += RandString([]string{"?", "#"})
// }
// // Replace # with number
// color = replaceWithNumbers(color)
// // Replace ? with letter
// for strings.Count(color, "?") > 0 {
// color = strings.Replace(color, "?", RandString(letters), 1)
// }
// return "#" + color
}
|
go
|
func HexColor() string {
color := make([]byte, 6)
hashQuestion := []byte("?#")
for i := 0; i < 6; i++ {
color[i] = hashQuestion[rand.Intn(2)]
}
return "#" + replaceWithLetters(replaceWithNumbers(string(color)))
// color := ""
// for i := 1; i <= 6; i++ {
// color += RandString([]string{"?", "#"})
// }
// // Replace # with number
// color = replaceWithNumbers(color)
// // Replace ? with letter
// for strings.Count(color, "?") > 0 {
// color = strings.Replace(color, "?", RandString(letters), 1)
// }
// return "#" + color
}
|
[
"func",
"HexColor",
"(",
")",
"string",
"{",
"color",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"6",
")",
"\n",
"hashQuestion",
":=",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"6",
";",
"i",
"++",
"{",
"color",
"[",
"i",
"]",
"=",
"hashQuestion",
"[",
"rand",
".",
"Intn",
"(",
"2",
")",
"]",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
"+",
"replaceWithLetters",
"(",
"replaceWithNumbers",
"(",
"string",
"(",
"color",
")",
")",
")",
"\n\n",
"// color := \"\"",
"// for i := 1; i <= 6; i++ {",
"// \tcolor += RandString([]string{\"?\", \"#\"})",
"// }",
"// // Replace # with number",
"// color = replaceWithNumbers(color)",
"// // Replace ? with letter",
"// for strings.Count(color, \"?\") > 0 {",
"// \tcolor = strings.Replace(color, \"?\", RandString(letters), 1)",
"// }",
"// return \"#\" + color",
"}"
] |
// HexColor will generate a random hexadecimal color string
|
[
"HexColor",
"will",
"generate",
"a",
"random",
"hexadecimal",
"color",
"string"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/color.go#L16-L39
|
148,961 |
brianvoe/gofakeit
|
string.go
|
ShuffleStrings
|
func ShuffleStrings(a []string) {
swap := func(i, j int) {
a[i], a[j] = a[j], a[i]
}
//to avoid upgrading to 1.10 I copied the algorithm
n := len(a)
if n <= 1 {
return
}
//if size is > int32 probably it will never finish, or ran out of entropy
i := n - 1
for ; i > 0; i-- {
j := int(rand.Int31n(int32(i + 1)))
swap(i, j)
}
}
|
go
|
func ShuffleStrings(a []string) {
swap := func(i, j int) {
a[i], a[j] = a[j], a[i]
}
//to avoid upgrading to 1.10 I copied the algorithm
n := len(a)
if n <= 1 {
return
}
//if size is > int32 probably it will never finish, or ran out of entropy
i := n - 1
for ; i > 0; i-- {
j := int(rand.Int31n(int32(i + 1)))
swap(i, j)
}
}
|
[
"func",
"ShuffleStrings",
"(",
"a",
"[",
"]",
"string",
")",
"{",
"swap",
":=",
"func",
"(",
"i",
",",
"j",
"int",
")",
"{",
"a",
"[",
"i",
"]",
",",
"a",
"[",
"j",
"]",
"=",
"a",
"[",
"j",
"]",
",",
"a",
"[",
"i",
"]",
"\n",
"}",
"\n",
"//to avoid upgrading to 1.10 I copied the algorithm",
"n",
":=",
"len",
"(",
"a",
")",
"\n",
"if",
"n",
"<=",
"1",
"{",
"return",
"\n",
"}",
"\n\n",
"//if size is > int32 probably it will never finish, or ran out of entropy",
"i",
":=",
"n",
"-",
"1",
"\n",
"for",
";",
"i",
">",
"0",
";",
"i",
"--",
"{",
"j",
":=",
"int",
"(",
"rand",
".",
"Int31n",
"(",
"int32",
"(",
"i",
"+",
"1",
")",
")",
")",
"\n",
"swap",
"(",
"i",
",",
"j",
")",
"\n",
"}",
"\n",
"}"
] |
// ShuffleStrings will randomize a slice of strings
|
[
"ShuffleStrings",
"will",
"randomize",
"a",
"slice",
"of",
"strings"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/string.go#L23-L39
|
148,962 |
brianvoe/gofakeit
|
string.go
|
RandString
|
func RandString(a []string) string {
size := len(a)
if size == 0 {
return ""
}
return a[rand.Intn(size)]
}
|
go
|
func RandString(a []string) string {
size := len(a)
if size == 0 {
return ""
}
return a[rand.Intn(size)]
}
|
[
"func",
"RandString",
"(",
"a",
"[",
"]",
"string",
")",
"string",
"{",
"size",
":=",
"len",
"(",
"a",
")",
"\n",
"if",
"size",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"a",
"[",
"rand",
".",
"Intn",
"(",
"size",
")",
"]",
"\n",
"}"
] |
// RandString will take in a slice of string and return a randomly selected value
|
[
"RandString",
"will",
"take",
"in",
"a",
"slice",
"of",
"string",
"and",
"return",
"a",
"randomly",
"selected",
"value"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/string.go#L42-L48
|
148,963 |
brianvoe/gofakeit
|
vehicle.go
|
Vehicle
|
func Vehicle() *VehicleInfo {
return &VehicleInfo{
VehicleType: VehicleType(),
Fuel: FuelType(),
TransmissionGear: TransmissionGearType(),
Brand: CarMaker(),
Model: CarModel(),
Year: Year(),
}
}
|
go
|
func Vehicle() *VehicleInfo {
return &VehicleInfo{
VehicleType: VehicleType(),
Fuel: FuelType(),
TransmissionGear: TransmissionGearType(),
Brand: CarMaker(),
Model: CarModel(),
Year: Year(),
}
}
|
[
"func",
"Vehicle",
"(",
")",
"*",
"VehicleInfo",
"{",
"return",
"&",
"VehicleInfo",
"{",
"VehicleType",
":",
"VehicleType",
"(",
")",
",",
"Fuel",
":",
"FuelType",
"(",
")",
",",
"TransmissionGear",
":",
"TransmissionGearType",
"(",
")",
",",
"Brand",
":",
"CarMaker",
"(",
")",
",",
"Model",
":",
"CarModel",
"(",
")",
",",
"Year",
":",
"Year",
"(",
")",
",",
"}",
"\n\n",
"}"
] |
// Vehicle will generate a struct with vehicle information
|
[
"Vehicle",
"will",
"generate",
"a",
"struct",
"with",
"vehicle",
"information"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/vehicle.go#L20-L30
|
148,964 |
brianvoe/gofakeit
|
hipster.go
|
HipsterParagraph
|
func HipsterParagraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string {
return paragraphGenerator(paragrapOptions{paragraphCount, sentenceCount, wordCount, separator}, HipsterSentence)
}
|
go
|
func HipsterParagraph(paragraphCount int, sentenceCount int, wordCount int, separator string) string {
return paragraphGenerator(paragrapOptions{paragraphCount, sentenceCount, wordCount, separator}, HipsterSentence)
}
|
[
"func",
"HipsterParagraph",
"(",
"paragraphCount",
"int",
",",
"sentenceCount",
"int",
",",
"wordCount",
"int",
",",
"separator",
"string",
")",
"string",
"{",
"return",
"paragraphGenerator",
"(",
"paragrapOptions",
"{",
"paragraphCount",
",",
"sentenceCount",
",",
"wordCount",
",",
"separator",
"}",
",",
"HipsterSentence",
")",
"\n",
"}"
] |
// HipsterParagraph will generate a random paragraphGenerator
// Set Paragraph Count
// Set Sentence Count
// Set Word Count
// Set Paragraph Separator
|
[
"HipsterParagraph",
"will",
"generate",
"a",
"random",
"paragraphGenerator",
"Set",
"Paragraph",
"Count",
"Set",
"Sentence",
"Count",
"Set",
"Word",
"Count",
"Set",
"Paragraph",
"Separator"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/hipster.go#L18-L20
|
148,965 |
brianvoe/gofakeit
|
hacker.go
|
HackerPhrase
|
func HackerPhrase() string {
words := strings.Split(Generate(getRandValue([]string{"hacker", "phrase"})), " ")
words[0] = strings.Title(words[0])
return strings.Join(words, " ")
}
|
go
|
func HackerPhrase() string {
words := strings.Split(Generate(getRandValue([]string{"hacker", "phrase"})), " ")
words[0] = strings.Title(words[0])
return strings.Join(words, " ")
}
|
[
"func",
"HackerPhrase",
"(",
")",
"string",
"{",
"words",
":=",
"strings",
".",
"Split",
"(",
"Generate",
"(",
"getRandValue",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
")",
",",
"\"",
"\"",
")",
"\n",
"words",
"[",
"0",
"]",
"=",
"strings",
".",
"Title",
"(",
"words",
"[",
"0",
"]",
")",
"\n",
"return",
"strings",
".",
"Join",
"(",
"words",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// HackerPhrase will return a random hacker sentence
|
[
"HackerPhrase",
"will",
"return",
"a",
"random",
"hacker",
"sentence"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/hacker.go#L6-L10
|
148,966 |
brianvoe/gofakeit
|
number.go
|
ShuffleInts
|
func ShuffleInts(a []int) {
for i := range a {
j := rand.Intn(i + 1)
a[i], a[j] = a[j], a[i]
}
}
|
go
|
func ShuffleInts(a []int) {
for i := range a {
j := rand.Intn(i + 1)
a[i], a[j] = a[j], a[i]
}
}
|
[
"func",
"ShuffleInts",
"(",
"a",
"[",
"]",
"int",
")",
"{",
"for",
"i",
":=",
"range",
"a",
"{",
"j",
":=",
"rand",
".",
"Intn",
"(",
"i",
"+",
"1",
")",
"\n",
"a",
"[",
"i",
"]",
",",
"a",
"[",
"j",
"]",
"=",
"a",
"[",
"j",
"]",
",",
"a",
"[",
"i",
"]",
"\n",
"}",
"\n",
"}"
] |
// ShuffleInts will randomize a slice of ints
|
[
"ShuffleInts",
"will",
"randomize",
"a",
"slice",
"of",
"ints"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/number.go#L79-L84
|
148,967 |
brianvoe/gofakeit
|
job.go
|
Job
|
func Job() *JobInfo {
return &JobInfo{
Company: Company(),
Title: JobTitle(),
Descriptor: JobDescriptor(),
Level: JobLevel(),
}
}
|
go
|
func Job() *JobInfo {
return &JobInfo{
Company: Company(),
Title: JobTitle(),
Descriptor: JobDescriptor(),
Level: JobLevel(),
}
}
|
[
"func",
"Job",
"(",
")",
"*",
"JobInfo",
"{",
"return",
"&",
"JobInfo",
"{",
"Company",
":",
"Company",
"(",
")",
",",
"Title",
":",
"JobTitle",
"(",
")",
",",
"Descriptor",
":",
"JobDescriptor",
"(",
")",
",",
"Level",
":",
"JobLevel",
"(",
")",
",",
"}",
"\n",
"}"
] |
// Job will generate a struct with random job information
|
[
"Job",
"will",
"generate",
"a",
"struct",
"with",
"random",
"job",
"information"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/job.go#L12-L19
|
148,968 |
brianvoe/gofakeit
|
contact.go
|
Email
|
func Email() string {
var email string
email = getRandValue([]string{"person", "first"}) + getRandValue([]string{"person", "last"})
email += "@"
email += getRandValue([]string{"person", "last"}) + "." + getRandValue([]string{"internet", "domain_suffix"})
return strings.ToLower(email)
}
|
go
|
func Email() string {
var email string
email = getRandValue([]string{"person", "first"}) + getRandValue([]string{"person", "last"})
email += "@"
email += getRandValue([]string{"person", "last"}) + "." + getRandValue([]string{"internet", "domain_suffix"})
return strings.ToLower(email)
}
|
[
"func",
"Email",
"(",
")",
"string",
"{",
"var",
"email",
"string",
"\n\n",
"email",
"=",
"getRandValue",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"+",
"getRandValue",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"\n",
"email",
"+=",
"\"",
"\"",
"\n",
"email",
"+=",
"getRandValue",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"+",
"\"",
"\"",
"+",
"getRandValue",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"\n\n",
"return",
"strings",
".",
"ToLower",
"(",
"email",
")",
"\n",
"}"
] |
// Email will generate a random email string
|
[
"Email",
"will",
"generate",
"a",
"random",
"email",
"string"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/contact.go#L32-L40
|
148,969 |
brianvoe/gofakeit
|
person.go
|
Person
|
func Person() *PersonInfo {
return &PersonInfo{
FirstName: FirstName(),
LastName: LastName(),
Gender: Gender(),
SSN: SSN(),
Image: ImageURL(300, 300) + "/people",
Job: Job(),
Address: Address(),
Contact: Contact(),
CreditCard: CreditCard(),
}
}
|
go
|
func Person() *PersonInfo {
return &PersonInfo{
FirstName: FirstName(),
LastName: LastName(),
Gender: Gender(),
SSN: SSN(),
Image: ImageURL(300, 300) + "/people",
Job: Job(),
Address: Address(),
Contact: Contact(),
CreditCard: CreditCard(),
}
}
|
[
"func",
"Person",
"(",
")",
"*",
"PersonInfo",
"{",
"return",
"&",
"PersonInfo",
"{",
"FirstName",
":",
"FirstName",
"(",
")",
",",
"LastName",
":",
"LastName",
"(",
")",
",",
"Gender",
":",
"Gender",
"(",
")",
",",
"SSN",
":",
"SSN",
"(",
")",
",",
"Image",
":",
"ImageURL",
"(",
"300",
",",
"300",
")",
"+",
"\"",
"\"",
",",
"Job",
":",
"Job",
"(",
")",
",",
"Address",
":",
"Address",
"(",
")",
",",
"Contact",
":",
"Contact",
"(",
")",
",",
"CreditCard",
":",
"CreditCard",
"(",
")",
",",
"}",
"\n",
"}"
] |
// Person will generate a struct with person information
|
[
"Person",
"will",
"generate",
"a",
"struct",
"with",
"person",
"information"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/person.go#L33-L45
|
148,970 |
brianvoe/gofakeit
|
company.go
|
Company
|
func Company() (company string) {
switch randInt := randIntRange(1, 3); randInt {
case 1:
company = LastName() + ", " + LastName() + " and " + LastName()
case 2:
company = LastName() + "-" + LastName()
case 3:
company = LastName() + " " + CompanySuffix()
}
return
}
|
go
|
func Company() (company string) {
switch randInt := randIntRange(1, 3); randInt {
case 1:
company = LastName() + ", " + LastName() + " and " + LastName()
case 2:
company = LastName() + "-" + LastName()
case 3:
company = LastName() + " " + CompanySuffix()
}
return
}
|
[
"func",
"Company",
"(",
")",
"(",
"company",
"string",
")",
"{",
"switch",
"randInt",
":=",
"randIntRange",
"(",
"1",
",",
"3",
")",
";",
"randInt",
"{",
"case",
"1",
":",
"company",
"=",
"LastName",
"(",
")",
"+",
"\"",
"\"",
"+",
"LastName",
"(",
")",
"+",
"\"",
"\"",
"+",
"LastName",
"(",
")",
"\n",
"case",
"2",
":",
"company",
"=",
"LastName",
"(",
")",
"+",
"\"",
"\"",
"+",
"LastName",
"(",
")",
"\n",
"case",
"3",
":",
"company",
"=",
"LastName",
"(",
")",
"+",
"\"",
"\"",
"+",
"CompanySuffix",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Company will generate a random company name string
|
[
"Company",
"will",
"generate",
"a",
"random",
"company",
"name",
"string"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/company.go#L4-L15
|
148,971 |
brianvoe/gofakeit
|
datetime.go
|
Date
|
func Date() time.Time {
return time.Date(Year(), time.Month(Number(0, 12)), Day(), Hour(), Minute(), Second(), NanoSecond(), time.UTC)
}
|
go
|
func Date() time.Time {
return time.Date(Year(), time.Month(Number(0, 12)), Day(), Hour(), Minute(), Second(), NanoSecond(), time.UTC)
}
|
[
"func",
"Date",
"(",
")",
"time",
".",
"Time",
"{",
"return",
"time",
".",
"Date",
"(",
"Year",
"(",
")",
",",
"time",
".",
"Month",
"(",
"Number",
"(",
"0",
",",
"12",
")",
")",
",",
"Day",
"(",
")",
",",
"Hour",
"(",
")",
",",
"Minute",
"(",
")",
",",
"Second",
"(",
")",
",",
"NanoSecond",
"(",
")",
",",
"time",
".",
"UTC",
")",
"\n",
"}"
] |
// Date will generate a random time.Time struct
|
[
"Date",
"will",
"generate",
"a",
"random",
"time",
".",
"Time",
"struct"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/datetime.go#L9-L11
|
148,972 |
brianvoe/gofakeit
|
datetime.go
|
DateRange
|
func DateRange(start, end time.Time) time.Time {
return time.Unix(0, int64(Number(int(start.UnixNano()), int(end.UnixNano())))).UTC()
}
|
go
|
func DateRange(start, end time.Time) time.Time {
return time.Unix(0, int64(Number(int(start.UnixNano()), int(end.UnixNano())))).UTC()
}
|
[
"func",
"DateRange",
"(",
"start",
",",
"end",
"time",
".",
"Time",
")",
"time",
".",
"Time",
"{",
"return",
"time",
".",
"Unix",
"(",
"0",
",",
"int64",
"(",
"Number",
"(",
"int",
"(",
"start",
".",
"UnixNano",
"(",
")",
")",
",",
"int",
"(",
"end",
".",
"UnixNano",
"(",
")",
")",
")",
")",
")",
".",
"UTC",
"(",
")",
"\n",
"}"
] |
// DateRange will generate a random time.Time struct between a start and end date
|
[
"DateRange",
"will",
"generate",
"a",
"random",
"time",
".",
"Time",
"struct",
"between",
"a",
"start",
"and",
"end",
"date"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/datetime.go#L14-L16
|
148,973 |
brianvoe/gofakeit
|
datetime.go
|
TimeZoneOffset
|
func TimeZoneOffset() float32 {
value, _ := strconv.ParseFloat(getRandValue([]string{"timezone", "offset"}), 32)
return float32(value)
}
|
go
|
func TimeZoneOffset() float32 {
value, _ := strconv.ParseFloat(getRandValue([]string{"timezone", "offset"}), 32)
return float32(value)
}
|
[
"func",
"TimeZoneOffset",
"(",
")",
"float32",
"{",
"value",
",",
"_",
":=",
"strconv",
".",
"ParseFloat",
"(",
"getRandValue",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
",",
"32",
")",
"\n",
"return",
"float32",
"(",
"value",
")",
"\n",
"}"
] |
// TimeZoneOffset will select a random timezone offset
|
[
"TimeZoneOffset",
"will",
"select",
"a",
"random",
"timezone",
"offset"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/datetime.go#L74-L77
|
148,974 |
brianvoe/gofakeit
|
internet.go
|
URL
|
func URL() string {
url := "http" + RandString([]string{"s", ""}) + "://www."
url += DomainName()
// Slugs
num := Number(1, 4)
slug := make([]string, num)
for i := 0; i < num; i++ {
slug[i] = BS()
}
url += "/" + strings.ToLower(strings.Join(slug, "/"))
return url
}
|
go
|
func URL() string {
url := "http" + RandString([]string{"s", ""}) + "://www."
url += DomainName()
// Slugs
num := Number(1, 4)
slug := make([]string, num)
for i := 0; i < num; i++ {
slug[i] = BS()
}
url += "/" + strings.ToLower(strings.Join(slug, "/"))
return url
}
|
[
"func",
"URL",
"(",
")",
"string",
"{",
"url",
":=",
"\"",
"\"",
"+",
"RandString",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"+",
"\"",
"\"",
"\n",
"url",
"+=",
"DomainName",
"(",
")",
"\n\n",
"// Slugs",
"num",
":=",
"Number",
"(",
"1",
",",
"4",
")",
"\n",
"slug",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"num",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"num",
";",
"i",
"++",
"{",
"slug",
"[",
"i",
"]",
"=",
"BS",
"(",
")",
"\n",
"}",
"\n",
"url",
"+=",
"\"",
"\"",
"+",
"strings",
".",
"ToLower",
"(",
"strings",
".",
"Join",
"(",
"slug",
",",
"\"",
"\"",
")",
")",
"\n\n",
"return",
"url",
"\n",
"}"
] |
// URL will generate a random url string
|
[
"URL",
"will",
"generate",
"a",
"random",
"url",
"string"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/internet.go#L20-L33
|
148,975 |
brianvoe/gofakeit
|
internet.go
|
IPv4Address
|
func IPv4Address() string {
num := func() int { return 2 + rand.Intn(254) }
return fmt.Sprintf("%d.%d.%d.%d", num(), num(), num(), num())
}
|
go
|
func IPv4Address() string {
num := func() int { return 2 + rand.Intn(254) }
return fmt.Sprintf("%d.%d.%d.%d", num(), num(), num(), num())
}
|
[
"func",
"IPv4Address",
"(",
")",
"string",
"{",
"num",
":=",
"func",
"(",
")",
"int",
"{",
"return",
"2",
"+",
"rand",
".",
"Intn",
"(",
"254",
")",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"num",
"(",
")",
",",
"num",
"(",
")",
",",
"num",
"(",
")",
",",
"num",
"(",
")",
")",
"\n",
"}"
] |
// IPv4Address will generate a random version 4 ip address
|
[
"IPv4Address",
"will",
"generate",
"a",
"random",
"version",
"4",
"ip",
"address"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/internet.go#L41-L44
|
148,976 |
brianvoe/gofakeit
|
internet.go
|
IPv6Address
|
func IPv6Address() string {
num := 65536
return fmt.Sprintf("2001:cafe:%x:%x:%x:%x:%x:%x", rand.Intn(num), rand.Intn(num), rand.Intn(num), rand.Intn(num), rand.Intn(num), rand.Intn(num))
}
|
go
|
func IPv6Address() string {
num := 65536
return fmt.Sprintf("2001:cafe:%x:%x:%x:%x:%x:%x", rand.Intn(num), rand.Intn(num), rand.Intn(num), rand.Intn(num), rand.Intn(num), rand.Intn(num))
}
|
[
"func",
"IPv6Address",
"(",
")",
"string",
"{",
"num",
":=",
"65536",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"rand",
".",
"Intn",
"(",
"num",
")",
",",
"rand",
".",
"Intn",
"(",
"num",
")",
",",
"rand",
".",
"Intn",
"(",
"num",
")",
",",
"rand",
".",
"Intn",
"(",
"num",
")",
",",
"rand",
".",
"Intn",
"(",
"num",
")",
",",
"rand",
".",
"Intn",
"(",
"num",
")",
")",
"\n",
"}"
] |
// IPv6Address will generate a random version 6 ip address
|
[
"IPv6Address",
"will",
"generate",
"a",
"random",
"version",
"6",
"ip",
"address"
] |
a5ac7cef41d64b726c51e8826e02dad0c34f55b4
|
https://github.com/brianvoe/gofakeit/blob/a5ac7cef41d64b726c51e8826e02dad0c34f55b4/internet.go#L47-L50
|
148,977 |
gorilla/handlers
|
cors.go
|
AllowedMethods
|
func AllowedMethods(methods []string) CORSOption {
return func(ch *cors) error {
ch.allowedMethods = []string{}
for _, v := range methods {
normalizedMethod := strings.ToUpper(strings.TrimSpace(v))
if normalizedMethod == "" {
continue
}
if !ch.isMatch(normalizedMethod, ch.allowedMethods) {
ch.allowedMethods = append(ch.allowedMethods, normalizedMethod)
}
}
return nil
}
}
|
go
|
func AllowedMethods(methods []string) CORSOption {
return func(ch *cors) error {
ch.allowedMethods = []string{}
for _, v := range methods {
normalizedMethod := strings.ToUpper(strings.TrimSpace(v))
if normalizedMethod == "" {
continue
}
if !ch.isMatch(normalizedMethod, ch.allowedMethods) {
ch.allowedMethods = append(ch.allowedMethods, normalizedMethod)
}
}
return nil
}
}
|
[
"func",
"AllowedMethods",
"(",
"methods",
"[",
"]",
"string",
")",
"CORSOption",
"{",
"return",
"func",
"(",
"ch",
"*",
"cors",
")",
"error",
"{",
"ch",
".",
"allowedMethods",
"=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"methods",
"{",
"normalizedMethod",
":=",
"strings",
".",
"ToUpper",
"(",
"strings",
".",
"TrimSpace",
"(",
"v",
")",
")",
"\n",
"if",
"normalizedMethod",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"!",
"ch",
".",
"isMatch",
"(",
"normalizedMethod",
",",
"ch",
".",
"allowedMethods",
")",
"{",
"ch",
".",
"allowedMethods",
"=",
"append",
"(",
"ch",
".",
"allowedMethods",
",",
"normalizedMethod",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// AllowedMethods can be used to explicitly allow methods in the
// Access-Control-Allow-Methods header.
// This is a replacement operation so you must also
// pass GET, HEAD, and POST if you wish to support those methods.
|
[
"AllowedMethods",
"can",
"be",
"used",
"to",
"explicitly",
"allow",
"methods",
"in",
"the",
"Access",
"-",
"Control",
"-",
"Allow",
"-",
"Methods",
"header",
".",
"This",
"is",
"a",
"replacement",
"operation",
"so",
"you",
"must",
"also",
"pass",
"GET",
"HEAD",
"and",
"POST",
"if",
"you",
"wish",
"to",
"support",
"those",
"methods",
"."
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/cors.go#L214-L230
|
148,978 |
gorilla/handlers
|
cors.go
|
AllowedOriginValidator
|
func AllowedOriginValidator(fn OriginValidator) CORSOption {
return func(ch *cors) error {
ch.allowedOriginValidator = fn
return nil
}
}
|
go
|
func AllowedOriginValidator(fn OriginValidator) CORSOption {
return func(ch *cors) error {
ch.allowedOriginValidator = fn
return nil
}
}
|
[
"func",
"AllowedOriginValidator",
"(",
"fn",
"OriginValidator",
")",
"CORSOption",
"{",
"return",
"func",
"(",
"ch",
"*",
"cors",
")",
"error",
"{",
"ch",
".",
"allowedOriginValidator",
"=",
"fn",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// AllowedOriginValidator sets a function for evaluating allowed origins in CORS requests, represented by the
// 'Allow-Access-Control-Origin' HTTP header.
|
[
"AllowedOriginValidator",
"sets",
"a",
"function",
"for",
"evaluating",
"allowed",
"origins",
"in",
"CORS",
"requests",
"represented",
"by",
"the",
"Allow",
"-",
"Access",
"-",
"Control",
"-",
"Origin",
"HTTP",
"header",
"."
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/cors.go#L251-L256
|
148,979 |
gorilla/handlers
|
cors.go
|
ExposedHeaders
|
func ExposedHeaders(headers []string) CORSOption {
return func(ch *cors) error {
ch.exposedHeaders = []string{}
for _, v := range headers {
normalizedHeader := http.CanonicalHeaderKey(strings.TrimSpace(v))
if normalizedHeader == "" {
continue
}
if !ch.isMatch(normalizedHeader, ch.exposedHeaders) {
ch.exposedHeaders = append(ch.exposedHeaders, normalizedHeader)
}
}
return nil
}
}
|
go
|
func ExposedHeaders(headers []string) CORSOption {
return func(ch *cors) error {
ch.exposedHeaders = []string{}
for _, v := range headers {
normalizedHeader := http.CanonicalHeaderKey(strings.TrimSpace(v))
if normalizedHeader == "" {
continue
}
if !ch.isMatch(normalizedHeader, ch.exposedHeaders) {
ch.exposedHeaders = append(ch.exposedHeaders, normalizedHeader)
}
}
return nil
}
}
|
[
"func",
"ExposedHeaders",
"(",
"headers",
"[",
"]",
"string",
")",
"CORSOption",
"{",
"return",
"func",
"(",
"ch",
"*",
"cors",
")",
"error",
"{",
"ch",
".",
"exposedHeaders",
"=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"headers",
"{",
"normalizedHeader",
":=",
"http",
".",
"CanonicalHeaderKey",
"(",
"strings",
".",
"TrimSpace",
"(",
"v",
")",
")",
"\n",
"if",
"normalizedHeader",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"!",
"ch",
".",
"isMatch",
"(",
"normalizedHeader",
",",
"ch",
".",
"exposedHeaders",
")",
"{",
"ch",
".",
"exposedHeaders",
"=",
"append",
"(",
"ch",
".",
"exposedHeaders",
",",
"normalizedHeader",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// ExposedHeaders can be used to specify headers that are available
// and will not be stripped out by the user-agent.
|
[
"ExposedHeaders",
"can",
"be",
"used",
"to",
"specify",
"headers",
"that",
"are",
"available",
"and",
"will",
"not",
"be",
"stripped",
"out",
"by",
"the",
"user",
"-",
"agent",
"."
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/cors.go#L273-L289
|
148,980 |
gorilla/handlers
|
logging.go
|
buildCommonLogLine
|
func buildCommonLogLine(req *http.Request, url url.URL, ts time.Time, status int, size int) []byte {
username := "-"
if url.User != nil {
if name := url.User.Username(); name != "" {
username = name
}
}
host, _, err := net.SplitHostPort(req.RemoteAddr)
if err != nil {
host = req.RemoteAddr
}
uri := req.RequestURI
// Requests using the CONNECT method over HTTP/2.0 must use
// the authority field (aka r.Host) to identify the target.
// Refer: https://httpwg.github.io/specs/rfc7540.html#CONNECT
if req.ProtoMajor == 2 && req.Method == "CONNECT" {
uri = req.Host
}
if uri == "" {
uri = url.RequestURI()
}
buf := make([]byte, 0, 3*(len(host)+len(username)+len(req.Method)+len(uri)+len(req.Proto)+50)/2)
buf = append(buf, host...)
buf = append(buf, " - "...)
buf = append(buf, username...)
buf = append(buf, " ["...)
buf = append(buf, ts.Format("02/Jan/2006:15:04:05 -0700")...)
buf = append(buf, `] "`...)
buf = append(buf, req.Method...)
buf = append(buf, " "...)
buf = appendQuoted(buf, uri)
buf = append(buf, " "...)
buf = append(buf, req.Proto...)
buf = append(buf, `" `...)
buf = append(buf, strconv.Itoa(status)...)
buf = append(buf, " "...)
buf = append(buf, strconv.Itoa(size)...)
return buf
}
|
go
|
func buildCommonLogLine(req *http.Request, url url.URL, ts time.Time, status int, size int) []byte {
username := "-"
if url.User != nil {
if name := url.User.Username(); name != "" {
username = name
}
}
host, _, err := net.SplitHostPort(req.RemoteAddr)
if err != nil {
host = req.RemoteAddr
}
uri := req.RequestURI
// Requests using the CONNECT method over HTTP/2.0 must use
// the authority field (aka r.Host) to identify the target.
// Refer: https://httpwg.github.io/specs/rfc7540.html#CONNECT
if req.ProtoMajor == 2 && req.Method == "CONNECT" {
uri = req.Host
}
if uri == "" {
uri = url.RequestURI()
}
buf := make([]byte, 0, 3*(len(host)+len(username)+len(req.Method)+len(uri)+len(req.Proto)+50)/2)
buf = append(buf, host...)
buf = append(buf, " - "...)
buf = append(buf, username...)
buf = append(buf, " ["...)
buf = append(buf, ts.Format("02/Jan/2006:15:04:05 -0700")...)
buf = append(buf, `] "`...)
buf = append(buf, req.Method...)
buf = append(buf, " "...)
buf = appendQuoted(buf, uri)
buf = append(buf, " "...)
buf = append(buf, req.Proto...)
buf = append(buf, `" `...)
buf = append(buf, strconv.Itoa(status)...)
buf = append(buf, " "...)
buf = append(buf, strconv.Itoa(size)...)
return buf
}
|
[
"func",
"buildCommonLogLine",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"url",
"url",
".",
"URL",
",",
"ts",
"time",
".",
"Time",
",",
"status",
"int",
",",
"size",
"int",
")",
"[",
"]",
"byte",
"{",
"username",
":=",
"\"",
"\"",
"\n",
"if",
"url",
".",
"User",
"!=",
"nil",
"{",
"if",
"name",
":=",
"url",
".",
"User",
".",
"Username",
"(",
")",
";",
"name",
"!=",
"\"",
"\"",
"{",
"username",
"=",
"name",
"\n",
"}",
"\n",
"}",
"\n\n",
"host",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"req",
".",
"RemoteAddr",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"host",
"=",
"req",
".",
"RemoteAddr",
"\n",
"}",
"\n\n",
"uri",
":=",
"req",
".",
"RequestURI",
"\n\n",
"// Requests using the CONNECT method over HTTP/2.0 must use",
"// the authority field (aka r.Host) to identify the target.",
"// Refer: https://httpwg.github.io/specs/rfc7540.html#CONNECT",
"if",
"req",
".",
"ProtoMajor",
"==",
"2",
"&&",
"req",
".",
"Method",
"==",
"\"",
"\"",
"{",
"uri",
"=",
"req",
".",
"Host",
"\n",
"}",
"\n",
"if",
"uri",
"==",
"\"",
"\"",
"{",
"uri",
"=",
"url",
".",
"RequestURI",
"(",
")",
"\n",
"}",
"\n\n",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"3",
"*",
"(",
"len",
"(",
"host",
")",
"+",
"len",
"(",
"username",
")",
"+",
"len",
"(",
"req",
".",
"Method",
")",
"+",
"len",
"(",
"uri",
")",
"+",
"len",
"(",
"req",
".",
"Proto",
")",
"+",
"50",
")",
"/",
"2",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"host",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"\"",
"\"",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"username",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"\"",
"\"",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"ts",
".",
"Format",
"(",
"\"",
"\"",
")",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"`] \"`",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"req",
".",
"Method",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"\"",
"\"",
"...",
")",
"\n",
"buf",
"=",
"appendQuoted",
"(",
"buf",
",",
"uri",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"\"",
"\"",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"req",
".",
"Proto",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"`\" `",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"strconv",
".",
"Itoa",
"(",
"status",
")",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"\"",
"\"",
"...",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"strconv",
".",
"Itoa",
"(",
"size",
")",
"...",
")",
"\n",
"return",
"buf",
"\n",
"}"
] |
// buildCommonLogLine builds a log entry for req in Apache Common Log Format.
// ts is the timestamp with which the entry should be logged.
// status and size are used to provide the response HTTP status and size.
|
[
"buildCommonLogLine",
"builds",
"a",
"log",
"entry",
"for",
"req",
"in",
"Apache",
"Common",
"Log",
"Format",
".",
"ts",
"is",
"the",
"timestamp",
"with",
"which",
"the",
"entry",
"should",
"be",
"logged",
".",
"status",
"and",
"size",
"are",
"used",
"to",
"provide",
"the",
"response",
"HTTP",
"status",
"and",
"size",
"."
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/logging.go#L151-L194
|
148,981 |
gorilla/handlers
|
logging.go
|
writeLog
|
func writeLog(writer io.Writer, params LogFormatterParams) {
buf := buildCommonLogLine(params.Request, params.URL, params.TimeStamp, params.StatusCode, params.Size)
buf = append(buf, '\n')
writer.Write(buf)
}
|
go
|
func writeLog(writer io.Writer, params LogFormatterParams) {
buf := buildCommonLogLine(params.Request, params.URL, params.TimeStamp, params.StatusCode, params.Size)
buf = append(buf, '\n')
writer.Write(buf)
}
|
[
"func",
"writeLog",
"(",
"writer",
"io",
".",
"Writer",
",",
"params",
"LogFormatterParams",
")",
"{",
"buf",
":=",
"buildCommonLogLine",
"(",
"params",
".",
"Request",
",",
"params",
".",
"URL",
",",
"params",
".",
"TimeStamp",
",",
"params",
".",
"StatusCode",
",",
"params",
".",
"Size",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"'\\n'",
")",
"\n",
"writer",
".",
"Write",
"(",
"buf",
")",
"\n",
"}"
] |
// writeLog writes a log entry for req to w in Apache Common Log Format.
// ts is the timestamp with which the entry should be logged.
// status and size are used to provide the response HTTP status and size.
|
[
"writeLog",
"writes",
"a",
"log",
"entry",
"for",
"req",
"to",
"w",
"in",
"Apache",
"Common",
"Log",
"Format",
".",
"ts",
"is",
"the",
"timestamp",
"with",
"which",
"the",
"entry",
"should",
"be",
"logged",
".",
"status",
"and",
"size",
"are",
"used",
"to",
"provide",
"the",
"response",
"HTTP",
"status",
"and",
"size",
"."
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/logging.go#L199-L203
|
148,982 |
gorilla/handlers
|
logging.go
|
writeCombinedLog
|
func writeCombinedLog(writer io.Writer, params LogFormatterParams) {
buf := buildCommonLogLine(params.Request, params.URL, params.TimeStamp, params.StatusCode, params.Size)
buf = append(buf, ` "`...)
buf = appendQuoted(buf, params.Request.Referer())
buf = append(buf, `" "`...)
buf = appendQuoted(buf, params.Request.UserAgent())
buf = append(buf, '"', '\n')
writer.Write(buf)
}
|
go
|
func writeCombinedLog(writer io.Writer, params LogFormatterParams) {
buf := buildCommonLogLine(params.Request, params.URL, params.TimeStamp, params.StatusCode, params.Size)
buf = append(buf, ` "`...)
buf = appendQuoted(buf, params.Request.Referer())
buf = append(buf, `" "`...)
buf = appendQuoted(buf, params.Request.UserAgent())
buf = append(buf, '"', '\n')
writer.Write(buf)
}
|
[
"func",
"writeCombinedLog",
"(",
"writer",
"io",
".",
"Writer",
",",
"params",
"LogFormatterParams",
")",
"{",
"buf",
":=",
"buildCommonLogLine",
"(",
"params",
".",
"Request",
",",
"params",
".",
"URL",
",",
"params",
".",
"TimeStamp",
",",
"params",
".",
"StatusCode",
",",
"params",
".",
"Size",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"` \"`",
"...",
")",
"\n",
"buf",
"=",
"appendQuoted",
"(",
"buf",
",",
"params",
".",
"Request",
".",
"Referer",
"(",
")",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"`\" \"`",
"...",
")",
"\n",
"buf",
"=",
"appendQuoted",
"(",
"buf",
",",
"params",
".",
"Request",
".",
"UserAgent",
"(",
")",
")",
"\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"'\"'",
",",
"'\\n'",
")",
"\n",
"writer",
".",
"Write",
"(",
"buf",
")",
"\n",
"}"
] |
// writeCombinedLog writes a log entry for req to w in Apache Combined Log Format.
// ts is the timestamp with which the entry should be logged.
// status and size are used to provide the response HTTP status and size.
|
[
"writeCombinedLog",
"writes",
"a",
"log",
"entry",
"for",
"req",
"to",
"w",
"in",
"Apache",
"Combined",
"Log",
"Format",
".",
"ts",
"is",
"the",
"timestamp",
"with",
"which",
"the",
"entry",
"should",
"be",
"logged",
".",
"status",
"and",
"size",
"are",
"used",
"to",
"provide",
"the",
"response",
"HTTP",
"status",
"and",
"size",
"."
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/logging.go#L208-L216
|
148,983 |
gorilla/handlers
|
logging.go
|
CustomLoggingHandler
|
func CustomLoggingHandler(out io.Writer, h http.Handler, f LogFormatter) http.Handler {
return loggingHandler{out, h, f}
}
|
go
|
func CustomLoggingHandler(out io.Writer, h http.Handler, f LogFormatter) http.Handler {
return loggingHandler{out, h, f}
}
|
[
"func",
"CustomLoggingHandler",
"(",
"out",
"io",
".",
"Writer",
",",
"h",
"http",
".",
"Handler",
",",
"f",
"LogFormatter",
")",
"http",
".",
"Handler",
"{",
"return",
"loggingHandler",
"{",
"out",
",",
"h",
",",
"f",
"}",
"\n",
"}"
] |
// CustomLoggingHandler provides a way to supply a custom log formatter
// while taking advantage of the mechanisms in this package
|
[
"CustomLoggingHandler",
"provides",
"a",
"way",
"to",
"supply",
"a",
"custom",
"log",
"formatter",
"while",
"taking",
"advantage",
"of",
"the",
"mechanisms",
"in",
"this",
"package"
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/logging.go#L250-L252
|
148,984 |
gorilla/handlers
|
handlers.go
|
isContentType
|
func isContentType(h http.Header, contentType string) bool {
ct := h.Get("Content-Type")
if i := strings.IndexRune(ct, ';'); i != -1 {
ct = ct[0:i]
}
return ct == contentType
}
|
go
|
func isContentType(h http.Header, contentType string) bool {
ct := h.Get("Content-Type")
if i := strings.IndexRune(ct, ';'); i != -1 {
ct = ct[0:i]
}
return ct == contentType
}
|
[
"func",
"isContentType",
"(",
"h",
"http",
".",
"Header",
",",
"contentType",
"string",
")",
"bool",
"{",
"ct",
":=",
"h",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"i",
":=",
"strings",
".",
"IndexRune",
"(",
"ct",
",",
"';'",
")",
";",
"i",
"!=",
"-",
"1",
"{",
"ct",
"=",
"ct",
"[",
"0",
":",
"i",
"]",
"\n",
"}",
"\n",
"return",
"ct",
"==",
"contentType",
"\n",
"}"
] |
// isContentType validates the Content-Type header matches the supplied
// contentType. That is, its type and subtype match.
|
[
"isContentType",
"validates",
"the",
"Content",
"-",
"Type",
"header",
"matches",
"the",
"supplied",
"contentType",
".",
"That",
"is",
"its",
"type",
"and",
"subtype",
"match",
"."
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/handlers.go#L112-L118
|
148,985 |
gorilla/handlers
|
handlers.go
|
ContentTypeHandler
|
func ContentTypeHandler(h http.Handler, contentTypes ...string) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !(r.Method == "PUT" || r.Method == "POST" || r.Method == "PATCH") {
h.ServeHTTP(w, r)
return
}
for _, ct := range contentTypes {
if isContentType(r.Header, ct) {
h.ServeHTTP(w, r)
return
}
}
http.Error(w, fmt.Sprintf("Unsupported content type %q; expected one of %q", r.Header.Get("Content-Type"), contentTypes), http.StatusUnsupportedMediaType)
})
}
|
go
|
func ContentTypeHandler(h http.Handler, contentTypes ...string) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !(r.Method == "PUT" || r.Method == "POST" || r.Method == "PATCH") {
h.ServeHTTP(w, r)
return
}
for _, ct := range contentTypes {
if isContentType(r.Header, ct) {
h.ServeHTTP(w, r)
return
}
}
http.Error(w, fmt.Sprintf("Unsupported content type %q; expected one of %q", r.Header.Get("Content-Type"), contentTypes), http.StatusUnsupportedMediaType)
})
}
|
[
"func",
"ContentTypeHandler",
"(",
"h",
"http",
".",
"Handler",
",",
"contentTypes",
"...",
"string",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"!",
"(",
"r",
".",
"Method",
"==",
"\"",
"\"",
"||",
"r",
".",
"Method",
"==",
"\"",
"\"",
"||",
"r",
".",
"Method",
"==",
"\"",
"\"",
")",
"{",
"h",
".",
"ServeHTTP",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ct",
":=",
"range",
"contentTypes",
"{",
"if",
"isContentType",
"(",
"r",
".",
"Header",
",",
"ct",
")",
"{",
"h",
".",
"ServeHTTP",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"http",
".",
"Error",
"(",
"w",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"r",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
",",
"contentTypes",
")",
",",
"http",
".",
"StatusUnsupportedMediaType",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// ContentTypeHandler wraps and returns a http.Handler, validating the request
// content type is compatible with the contentTypes list. It writes a HTTP 415
// error if that fails.
//
// Only PUT, POST, and PATCH requests are considered.
|
[
"ContentTypeHandler",
"wraps",
"and",
"returns",
"a",
"http",
".",
"Handler",
"validating",
"the",
"request",
"content",
"type",
"is",
"compatible",
"with",
"the",
"contentTypes",
"list",
".",
"It",
"writes",
"a",
"HTTP",
"415",
"error",
"if",
"that",
"fails",
".",
"Only",
"PUT",
"POST",
"and",
"PATCH",
"requests",
"are",
"considered",
"."
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/handlers.go#L125-L140
|
148,986 |
gorilla/handlers
|
recovery.go
|
RecoveryLogger
|
func RecoveryLogger(logger RecoveryHandlerLogger) RecoveryOption {
return func(h http.Handler) {
r := h.(*recoveryHandler)
r.logger = logger
}
}
|
go
|
func RecoveryLogger(logger RecoveryHandlerLogger) RecoveryOption {
return func(h http.Handler) {
r := h.(*recoveryHandler)
r.logger = logger
}
}
|
[
"func",
"RecoveryLogger",
"(",
"logger",
"RecoveryHandlerLogger",
")",
"RecoveryOption",
"{",
"return",
"func",
"(",
"h",
"http",
".",
"Handler",
")",
"{",
"r",
":=",
"h",
".",
"(",
"*",
"recoveryHandler",
")",
"\n",
"r",
".",
"logger",
"=",
"logger",
"\n",
"}",
"\n",
"}"
] |
// RecoveryLogger is a functional option to override
// the default logger
|
[
"RecoveryLogger",
"is",
"a",
"functional",
"option",
"to",
"override",
"the",
"default",
"logger"
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/recovery.go#L54-L59
|
148,987 |
gorilla/handlers
|
recovery.go
|
PrintRecoveryStack
|
func PrintRecoveryStack(print bool) RecoveryOption {
return func(h http.Handler) {
r := h.(*recoveryHandler)
r.printStack = print
}
}
|
go
|
func PrintRecoveryStack(print bool) RecoveryOption {
return func(h http.Handler) {
r := h.(*recoveryHandler)
r.printStack = print
}
}
|
[
"func",
"PrintRecoveryStack",
"(",
"print",
"bool",
")",
"RecoveryOption",
"{",
"return",
"func",
"(",
"h",
"http",
".",
"Handler",
")",
"{",
"r",
":=",
"h",
".",
"(",
"*",
"recoveryHandler",
")",
"\n",
"r",
".",
"printStack",
"=",
"print",
"\n",
"}",
"\n",
"}"
] |
// PrintRecoveryStack is a functional option to enable
// or disable printing stack traces on panic.
|
[
"PrintRecoveryStack",
"is",
"a",
"functional",
"option",
"to",
"enable",
"or",
"disable",
"printing",
"stack",
"traces",
"on",
"panic",
"."
] |
ac6d24f88de4584385a0cb3a88f953d08a2f7a05
|
https://github.com/gorilla/handlers/blob/ac6d24f88de4584385a0cb3a88f953d08a2f7a05/recovery.go#L63-L68
|
148,988 |
colinmarc/hdfs
|
internal/rpc/block_writer.go
|
SetDeadline
|
func (bw *BlockWriter) SetDeadline(t time.Time) error {
bw.deadline = t
if bw.conn != nil {
return bw.conn.SetDeadline(t)
}
// Return the error at connection time.
return nil
}
|
go
|
func (bw *BlockWriter) SetDeadline(t time.Time) error {
bw.deadline = t
if bw.conn != nil {
return bw.conn.SetDeadline(t)
}
// Return the error at connection time.
return nil
}
|
[
"func",
"(",
"bw",
"*",
"BlockWriter",
")",
"SetDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"bw",
".",
"deadline",
"=",
"t",
"\n",
"if",
"bw",
".",
"conn",
"!=",
"nil",
"{",
"return",
"bw",
".",
"conn",
".",
"SetDeadline",
"(",
"t",
")",
"\n",
"}",
"\n\n",
"// Return the error at connection time.",
"return",
"nil",
"\n",
"}"
] |
// SetDeadline sets the deadline for future Write, Flush, and Close calls. A
// zero value for t means those calls will not time out.
|
[
"SetDeadline",
"sets",
"the",
"deadline",
"for",
"future",
"Write",
"Flush",
"and",
"Close",
"calls",
".",
"A",
"zero",
"value",
"for",
"t",
"means",
"those",
"calls",
"will",
"not",
"time",
"out",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/block_writer.go#L49-L57
|
148,989 |
colinmarc/hdfs
|
internal/rpc/block_writer.go
|
Flush
|
func (bw *BlockWriter) Flush() error {
if bw.stream != nil {
return bw.stream.flush(true)
}
return nil
}
|
go
|
func (bw *BlockWriter) Flush() error {
if bw.stream != nil {
return bw.stream.flush(true)
}
return nil
}
|
[
"func",
"(",
"bw",
"*",
"BlockWriter",
")",
"Flush",
"(",
")",
"error",
"{",
"if",
"bw",
".",
"stream",
"!=",
"nil",
"{",
"return",
"bw",
".",
"stream",
".",
"flush",
"(",
"true",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Flush flushes any unwritten packets out to the datanode.
|
[
"Flush",
"flushes",
"any",
"unwritten",
"packets",
"out",
"to",
"the",
"datanode",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/block_writer.go#L94-L100
|
148,990 |
colinmarc/hdfs
|
internal/rpc/block_writer.go
|
Close
|
func (bw *BlockWriter) Close() error {
bw.closed = true
if bw.conn != nil {
defer bw.conn.Close()
}
if bw.stream != nil {
// TODO: handle failures, set up recovery pipeline
err := bw.stream.finish()
if err != nil {
return err
}
}
return nil
}
|
go
|
func (bw *BlockWriter) Close() error {
bw.closed = true
if bw.conn != nil {
defer bw.conn.Close()
}
if bw.stream != nil {
// TODO: handle failures, set up recovery pipeline
err := bw.stream.finish()
if err != nil {
return err
}
}
return nil
}
|
[
"func",
"(",
"bw",
"*",
"BlockWriter",
")",
"Close",
"(",
")",
"error",
"{",
"bw",
".",
"closed",
"=",
"true",
"\n",
"if",
"bw",
".",
"conn",
"!=",
"nil",
"{",
"defer",
"bw",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"bw",
".",
"stream",
"!=",
"nil",
"{",
"// TODO: handle failures, set up recovery pipeline",
"err",
":=",
"bw",
".",
"stream",
".",
"finish",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Close implements io.Closer. It flushes any unwritten packets out to the
// datanode, and sends a final packet indicating the end of the block. The
// block must still be finalized with the namenode.
|
[
"Close",
"implements",
"io",
".",
"Closer",
".",
"It",
"flushes",
"any",
"unwritten",
"packets",
"out",
"to",
"the",
"datanode",
"and",
"sends",
"a",
"final",
"packet",
"indicating",
"the",
"end",
"of",
"the",
"block",
".",
"The",
"block",
"must",
"still",
"be",
"finalized",
"with",
"the",
"namenode",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/block_writer.go#L105-L120
|
148,991 |
colinmarc/hdfs
|
internal/rpc/namenode.go
|
NewNamenodeConnection
|
func NewNamenodeConnection(options NamenodeConnectionOptions) (*NamenodeConnection, error) {
// Build the list of hosts to be used for failover.
hostList := make([]*namenodeHost, len(options.Addresses))
for i, addr := range options.Addresses {
hostList[i] = &namenodeHost{address: addr}
}
var user, realm string
user = options.User
if user == "" {
if options.KerberosClient != nil {
creds := options.KerberosClient.Credentials
user = creds.Username
realm = creds.Realm
} else {
return nil, errors.New("user not specified")
}
}
// The ClientID is reused here both in the RPC headers (which requires a
// "globally unique" ID) and as the "client name" in various requests.
clientId := newClientID()
c := &NamenodeConnection{
ClientID: clientId,
ClientName: "go-hdfs-" + string(clientId),
User: user,
kerberosClient: options.KerberosClient,
kerberosServicePrincipleName: options.KerberosServicePrincipleName,
kerberosRealm: realm,
dialFunc: options.DialFunc,
hostList: hostList,
}
err := c.resolveConnection()
if err != nil {
return nil, err
}
return c, nil
}
|
go
|
func NewNamenodeConnection(options NamenodeConnectionOptions) (*NamenodeConnection, error) {
// Build the list of hosts to be used for failover.
hostList := make([]*namenodeHost, len(options.Addresses))
for i, addr := range options.Addresses {
hostList[i] = &namenodeHost{address: addr}
}
var user, realm string
user = options.User
if user == "" {
if options.KerberosClient != nil {
creds := options.KerberosClient.Credentials
user = creds.Username
realm = creds.Realm
} else {
return nil, errors.New("user not specified")
}
}
// The ClientID is reused here both in the RPC headers (which requires a
// "globally unique" ID) and as the "client name" in various requests.
clientId := newClientID()
c := &NamenodeConnection{
ClientID: clientId,
ClientName: "go-hdfs-" + string(clientId),
User: user,
kerberosClient: options.KerberosClient,
kerberosServicePrincipleName: options.KerberosServicePrincipleName,
kerberosRealm: realm,
dialFunc: options.DialFunc,
hostList: hostList,
}
err := c.resolveConnection()
if err != nil {
return nil, err
}
return c, nil
}
|
[
"func",
"NewNamenodeConnection",
"(",
"options",
"NamenodeConnectionOptions",
")",
"(",
"*",
"NamenodeConnection",
",",
"error",
")",
"{",
"// Build the list of hosts to be used for failover.",
"hostList",
":=",
"make",
"(",
"[",
"]",
"*",
"namenodeHost",
",",
"len",
"(",
"options",
".",
"Addresses",
")",
")",
"\n",
"for",
"i",
",",
"addr",
":=",
"range",
"options",
".",
"Addresses",
"{",
"hostList",
"[",
"i",
"]",
"=",
"&",
"namenodeHost",
"{",
"address",
":",
"addr",
"}",
"\n",
"}",
"\n\n",
"var",
"user",
",",
"realm",
"string",
"\n",
"user",
"=",
"options",
".",
"User",
"\n",
"if",
"user",
"==",
"\"",
"\"",
"{",
"if",
"options",
".",
"KerberosClient",
"!=",
"nil",
"{",
"creds",
":=",
"options",
".",
"KerberosClient",
".",
"Credentials",
"\n",
"user",
"=",
"creds",
".",
"Username",
"\n",
"realm",
"=",
"creds",
".",
"Realm",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// The ClientID is reused here both in the RPC headers (which requires a",
"// \"globally unique\" ID) and as the \"client name\" in various requests.",
"clientId",
":=",
"newClientID",
"(",
")",
"\n",
"c",
":=",
"&",
"NamenodeConnection",
"{",
"ClientID",
":",
"clientId",
",",
"ClientName",
":",
"\"",
"\"",
"+",
"string",
"(",
"clientId",
")",
",",
"User",
":",
"user",
",",
"kerberosClient",
":",
"options",
".",
"KerberosClient",
",",
"kerberosServicePrincipleName",
":",
"options",
".",
"KerberosServicePrincipleName",
",",
"kerberosRealm",
":",
"realm",
",",
"dialFunc",
":",
"options",
".",
"DialFunc",
",",
"hostList",
":",
"hostList",
",",
"}",
"\n\n",
"err",
":=",
"c",
".",
"resolveConnection",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] |
// NewNamenodeConnectionWithOptions creates a new connection to a namenode with
// the given options and performs an initial handshake.
|
[
"NewNamenodeConnectionWithOptions",
"creates",
"a",
"new",
"connection",
"to",
"a",
"namenode",
"with",
"the",
"given",
"options",
"and",
"performs",
"an",
"initial",
"handshake",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/namenode.go#L82-L123
|
148,992 |
colinmarc/hdfs
|
internal/rpc/namenode.go
|
Execute
|
func (c *NamenodeConnection) Execute(method string, req proto.Message, resp proto.Message) error {
c.reqLock.Lock()
defer c.reqLock.Unlock()
c.currentRequestID++
for {
err := c.resolveConnection()
if err != nil {
return err
}
err = c.writeRequest(method, req)
if err != nil {
c.markFailure(err)
continue
}
err = c.readResponse(method, resp)
if err != nil {
// Only retry on a standby exception.
if nerr, ok := err.(*NamenodeError); ok && nerr.exception == standbyExceptionClass {
c.markFailure(err)
continue
}
return err
}
break
}
return nil
}
|
go
|
func (c *NamenodeConnection) Execute(method string, req proto.Message, resp proto.Message) error {
c.reqLock.Lock()
defer c.reqLock.Unlock()
c.currentRequestID++
for {
err := c.resolveConnection()
if err != nil {
return err
}
err = c.writeRequest(method, req)
if err != nil {
c.markFailure(err)
continue
}
err = c.readResponse(method, resp)
if err != nil {
// Only retry on a standby exception.
if nerr, ok := err.(*NamenodeError); ok && nerr.exception == standbyExceptionClass {
c.markFailure(err)
continue
}
return err
}
break
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"NamenodeConnection",
")",
"Execute",
"(",
"method",
"string",
",",
"req",
"proto",
".",
"Message",
",",
"resp",
"proto",
".",
"Message",
")",
"error",
"{",
"c",
".",
"reqLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"reqLock",
".",
"Unlock",
"(",
")",
"\n\n",
"c",
".",
"currentRequestID",
"++",
"\n\n",
"for",
"{",
"err",
":=",
"c",
".",
"resolveConnection",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"c",
".",
"writeRequest",
"(",
"method",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"markFailure",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"err",
"=",
"c",
".",
"readResponse",
"(",
"method",
",",
"resp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Only retry on a standby exception.",
"if",
"nerr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"NamenodeError",
")",
";",
"ok",
"&&",
"nerr",
".",
"exception",
"==",
"standbyExceptionClass",
"{",
"c",
".",
"markFailure",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}",
"\n\n",
"break",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Execute performs an rpc call. It does this by sending req over the wire and
// unmarshaling the result into resp.
|
[
"Execute",
"performs",
"an",
"rpc",
"call",
".",
"It",
"does",
"this",
"by",
"sending",
"req",
"over",
"the",
"wire",
"and",
"unmarshaling",
"the",
"result",
"into",
"resp",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/namenode.go#L178-L211
|
148,993 |
colinmarc/hdfs
|
internal/rpc/namenode.go
|
Close
|
func (c *NamenodeConnection) Close() error {
if c.conn != nil {
return c.conn.Close()
}
return nil
}
|
go
|
func (c *NamenodeConnection) Close() error {
if c.conn != nil {
return c.conn.Close()
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"NamenodeConnection",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"c",
".",
"conn",
"!=",
"nil",
"{",
"return",
"c",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close terminates all underlying socket connections to remote server.
|
[
"Close",
"terminates",
"all",
"underlying",
"socket",
"connections",
"to",
"remote",
"server",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/namenode.go#L326-L331
|
148,994 |
colinmarc/hdfs
|
file_reader.go
|
Open
|
func (c *Client) Open(name string) (*FileReader, error) {
info, err := c.getFileInfo(name)
if err != nil {
return nil, &os.PathError{"open", name, interpretException(err)}
}
return &FileReader{
client: c,
name: name,
info: info,
closed: false,
}, nil
}
|
go
|
func (c *Client) Open(name string) (*FileReader, error) {
info, err := c.getFileInfo(name)
if err != nil {
return nil, &os.PathError{"open", name, interpretException(err)}
}
return &FileReader{
client: c,
name: name,
info: info,
closed: false,
}, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"Open",
"(",
"name",
"string",
")",
"(",
"*",
"FileReader",
",",
"error",
")",
"{",
"info",
",",
"err",
":=",
"c",
".",
"getFileInfo",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"name",
",",
"interpretException",
"(",
"err",
")",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"FileReader",
"{",
"client",
":",
"c",
",",
"name",
":",
"name",
",",
"info",
":",
"info",
",",
"closed",
":",
"false",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Open returns an FileReader which can be used for reading.
|
[
"Open",
"returns",
"an",
"FileReader",
"which",
"can",
"be",
"used",
"for",
"reading",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/file_reader.go#L35-L47
|
148,995 |
colinmarc/hdfs
|
file_reader.go
|
SetDeadline
|
func (f *FileReader) SetDeadline(t time.Time) error {
f.deadline = t
if f.blockReader != nil {
return f.blockReader.SetDeadline(t)
}
// Return the error at connection time.
return nil
}
|
go
|
func (f *FileReader) SetDeadline(t time.Time) error {
f.deadline = t
if f.blockReader != nil {
return f.blockReader.SetDeadline(t)
}
// Return the error at connection time.
return nil
}
|
[
"func",
"(",
"f",
"*",
"FileReader",
")",
"SetDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"f",
".",
"deadline",
"=",
"t",
"\n",
"if",
"f",
".",
"blockReader",
"!=",
"nil",
"{",
"return",
"f",
".",
"blockReader",
".",
"SetDeadline",
"(",
"t",
")",
"\n",
"}",
"\n\n",
"// Return the error at connection time.",
"return",
"nil",
"\n",
"}"
] |
// SetDeadline sets the deadline for future Read, ReadAt, and Checksum calls. A
// zero value for t means those calls will not time out.
|
[
"SetDeadline",
"sets",
"the",
"deadline",
"for",
"future",
"Read",
"ReadAt",
"and",
"Checksum",
"calls",
".",
"A",
"zero",
"value",
"for",
"t",
"means",
"those",
"calls",
"will",
"not",
"time",
"out",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/file_reader.go#L61-L69
|
148,996 |
colinmarc/hdfs
|
file_reader.go
|
Seek
|
func (f *FileReader) Seek(offset int64, whence int) (int64, error) {
if f.closed {
return 0, io.ErrClosedPipe
}
var off int64
if whence == 0 {
off = offset
} else if whence == 1 {
off = f.offset + offset
} else if whence == 2 {
off = f.info.Size() + offset
} else {
return f.offset, fmt.Errorf("invalid whence: %d", whence)
}
if off < 0 || off > f.info.Size() {
return f.offset, fmt.Errorf("invalid resulting offset: %d", off)
}
if f.offset != off {
f.offset = off
if f.blockReader != nil {
f.blockReader.Close()
f.blockReader = nil
}
}
return f.offset, nil
}
|
go
|
func (f *FileReader) Seek(offset int64, whence int) (int64, error) {
if f.closed {
return 0, io.ErrClosedPipe
}
var off int64
if whence == 0 {
off = offset
} else if whence == 1 {
off = f.offset + offset
} else if whence == 2 {
off = f.info.Size() + offset
} else {
return f.offset, fmt.Errorf("invalid whence: %d", whence)
}
if off < 0 || off > f.info.Size() {
return f.offset, fmt.Errorf("invalid resulting offset: %d", off)
}
if f.offset != off {
f.offset = off
if f.blockReader != nil {
f.blockReader.Close()
f.blockReader = nil
}
}
return f.offset, nil
}
|
[
"func",
"(",
"f",
"*",
"FileReader",
")",
"Seek",
"(",
"offset",
"int64",
",",
"whence",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"f",
".",
"closed",
"{",
"return",
"0",
",",
"io",
".",
"ErrClosedPipe",
"\n",
"}",
"\n\n",
"var",
"off",
"int64",
"\n",
"if",
"whence",
"==",
"0",
"{",
"off",
"=",
"offset",
"\n",
"}",
"else",
"if",
"whence",
"==",
"1",
"{",
"off",
"=",
"f",
".",
"offset",
"+",
"offset",
"\n",
"}",
"else",
"if",
"whence",
"==",
"2",
"{",
"off",
"=",
"f",
".",
"info",
".",
"Size",
"(",
")",
"+",
"offset",
"\n",
"}",
"else",
"{",
"return",
"f",
".",
"offset",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"whence",
")",
"\n",
"}",
"\n\n",
"if",
"off",
"<",
"0",
"||",
"off",
">",
"f",
".",
"info",
".",
"Size",
"(",
")",
"{",
"return",
"f",
".",
"offset",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"off",
")",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"offset",
"!=",
"off",
"{",
"f",
".",
"offset",
"=",
"off",
"\n",
"if",
"f",
".",
"blockReader",
"!=",
"nil",
"{",
"f",
".",
"blockReader",
".",
"Close",
"(",
")",
"\n",
"f",
".",
"blockReader",
"=",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"f",
".",
"offset",
",",
"nil",
"\n",
"}"
] |
// Seek implements io.Seeker.
//
// The seek is virtual - it starts a new block read at the new position.
|
[
"Seek",
"implements",
"io",
".",
"Seeker",
".",
"The",
"seek",
"is",
"virtual",
"-",
"it",
"starts",
"a",
"new",
"block",
"read",
"at",
"the",
"new",
"position",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/file_reader.go#L131-L159
|
148,997 |
colinmarc/hdfs
|
file_writer.go
|
CreateFile
|
func (c *Client) CreateFile(name string, replication int, blockSize int64, perm os.FileMode) (*FileWriter, error) {
createReq := &hdfs.CreateRequestProto{
Src: proto.String(name),
Masked: &hdfs.FsPermissionProto{Perm: proto.Uint32(uint32(perm))},
ClientName: proto.String(c.namenode.ClientName),
CreateFlag: proto.Uint32(1),
CreateParent: proto.Bool(false),
Replication: proto.Uint32(uint32(replication)),
BlockSize: proto.Uint64(uint64(blockSize)),
}
createResp := &hdfs.CreateResponseProto{}
err := c.namenode.Execute("create", createReq, createResp)
if err != nil {
return nil, &os.PathError{"create", name, interpretException(err)}
}
return &FileWriter{
client: c,
name: name,
replication: replication,
blockSize: blockSize,
}, nil
}
|
go
|
func (c *Client) CreateFile(name string, replication int, blockSize int64, perm os.FileMode) (*FileWriter, error) {
createReq := &hdfs.CreateRequestProto{
Src: proto.String(name),
Masked: &hdfs.FsPermissionProto{Perm: proto.Uint32(uint32(perm))},
ClientName: proto.String(c.namenode.ClientName),
CreateFlag: proto.Uint32(1),
CreateParent: proto.Bool(false),
Replication: proto.Uint32(uint32(replication)),
BlockSize: proto.Uint64(uint64(blockSize)),
}
createResp := &hdfs.CreateResponseProto{}
err := c.namenode.Execute("create", createReq, createResp)
if err != nil {
return nil, &os.PathError{"create", name, interpretException(err)}
}
return &FileWriter{
client: c,
name: name,
replication: replication,
blockSize: blockSize,
}, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"CreateFile",
"(",
"name",
"string",
",",
"replication",
"int",
",",
"blockSize",
"int64",
",",
"perm",
"os",
".",
"FileMode",
")",
"(",
"*",
"FileWriter",
",",
"error",
")",
"{",
"createReq",
":=",
"&",
"hdfs",
".",
"CreateRequestProto",
"{",
"Src",
":",
"proto",
".",
"String",
"(",
"name",
")",
",",
"Masked",
":",
"&",
"hdfs",
".",
"FsPermissionProto",
"{",
"Perm",
":",
"proto",
".",
"Uint32",
"(",
"uint32",
"(",
"perm",
")",
")",
"}",
",",
"ClientName",
":",
"proto",
".",
"String",
"(",
"c",
".",
"namenode",
".",
"ClientName",
")",
",",
"CreateFlag",
":",
"proto",
".",
"Uint32",
"(",
"1",
")",
",",
"CreateParent",
":",
"proto",
".",
"Bool",
"(",
"false",
")",
",",
"Replication",
":",
"proto",
".",
"Uint32",
"(",
"uint32",
"(",
"replication",
")",
")",
",",
"BlockSize",
":",
"proto",
".",
"Uint64",
"(",
"uint64",
"(",
"blockSize",
")",
")",
",",
"}",
"\n",
"createResp",
":=",
"&",
"hdfs",
".",
"CreateResponseProto",
"{",
"}",
"\n\n",
"err",
":=",
"c",
".",
"namenode",
".",
"Execute",
"(",
"\"",
"\"",
",",
"createReq",
",",
"createResp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"name",
",",
"interpretException",
"(",
"err",
")",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"FileWriter",
"{",
"client",
":",
"c",
",",
"name",
":",
"name",
",",
"replication",
":",
"replication",
",",
"blockSize",
":",
"blockSize",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// CreateFile opens a new file in HDFS with the given replication, block size,
// and permissions, and returns an io.WriteCloser for writing to it. Because of
// the way that HDFS writes are buffered and acknowledged asynchronously, it is
// very important that Close is called after all data has been written.
|
[
"CreateFile",
"opens",
"a",
"new",
"file",
"in",
"HDFS",
"with",
"the",
"given",
"replication",
"block",
"size",
"and",
"permissions",
"and",
"returns",
"an",
"io",
".",
"WriteCloser",
"for",
"writing",
"to",
"it",
".",
"Because",
"of",
"the",
"way",
"that",
"HDFS",
"writes",
"are",
"buffered",
"and",
"acknowledged",
"asynchronously",
"it",
"is",
"very",
"important",
"that",
"Close",
"is",
"called",
"after",
"all",
"data",
"has",
"been",
"written",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/file_writer.go#L55-L78
|
148,998 |
colinmarc/hdfs
|
file_writer.go
|
Append
|
func (c *Client) Append(name string) (*FileWriter, error) {
_, err := c.getFileInfo(name)
if err != nil {
return nil, &os.PathError{"append", name, interpretException(err)}
}
appendReq := &hdfs.AppendRequestProto{
Src: proto.String(name),
ClientName: proto.String(c.namenode.ClientName),
}
appendResp := &hdfs.AppendResponseProto{}
err = c.namenode.Execute("append", appendReq, appendResp)
if err != nil {
return nil, &os.PathError{"append", name, interpretException(err)}
}
f := &FileWriter{
client: c,
name: name,
replication: int(appendResp.Stat.GetBlockReplication()),
blockSize: int64(appendResp.Stat.GetBlocksize()),
}
// This returns nil if there are no blocks (it's an empty file) or if the
// last block is full (so we have to start a fresh block).
block := appendResp.GetBlock()
if block == nil {
return f, nil
}
f.blockWriter = &rpc.BlockWriter{
ClientName: f.client.namenode.ClientName,
Block: block,
BlockSize: f.blockSize,
Offset: int64(block.B.GetNumBytes()),
Append: true,
UseDatanodeHostname: f.client.options.UseDatanodeHostname,
DialFunc: f.client.options.DatanodeDialFunc,
}
err = f.blockWriter.SetDeadline(f.deadline)
if err != nil {
return nil, err
}
return f, nil
}
|
go
|
func (c *Client) Append(name string) (*FileWriter, error) {
_, err := c.getFileInfo(name)
if err != nil {
return nil, &os.PathError{"append", name, interpretException(err)}
}
appendReq := &hdfs.AppendRequestProto{
Src: proto.String(name),
ClientName: proto.String(c.namenode.ClientName),
}
appendResp := &hdfs.AppendResponseProto{}
err = c.namenode.Execute("append", appendReq, appendResp)
if err != nil {
return nil, &os.PathError{"append", name, interpretException(err)}
}
f := &FileWriter{
client: c,
name: name,
replication: int(appendResp.Stat.GetBlockReplication()),
blockSize: int64(appendResp.Stat.GetBlocksize()),
}
// This returns nil if there are no blocks (it's an empty file) or if the
// last block is full (so we have to start a fresh block).
block := appendResp.GetBlock()
if block == nil {
return f, nil
}
f.blockWriter = &rpc.BlockWriter{
ClientName: f.client.namenode.ClientName,
Block: block,
BlockSize: f.blockSize,
Offset: int64(block.B.GetNumBytes()),
Append: true,
UseDatanodeHostname: f.client.options.UseDatanodeHostname,
DialFunc: f.client.options.DatanodeDialFunc,
}
err = f.blockWriter.SetDeadline(f.deadline)
if err != nil {
return nil, err
}
return f, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"Append",
"(",
"name",
"string",
")",
"(",
"*",
"FileWriter",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"c",
".",
"getFileInfo",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"name",
",",
"interpretException",
"(",
"err",
")",
"}",
"\n",
"}",
"\n\n",
"appendReq",
":=",
"&",
"hdfs",
".",
"AppendRequestProto",
"{",
"Src",
":",
"proto",
".",
"String",
"(",
"name",
")",
",",
"ClientName",
":",
"proto",
".",
"String",
"(",
"c",
".",
"namenode",
".",
"ClientName",
")",
",",
"}",
"\n",
"appendResp",
":=",
"&",
"hdfs",
".",
"AppendResponseProto",
"{",
"}",
"\n\n",
"err",
"=",
"c",
".",
"namenode",
".",
"Execute",
"(",
"\"",
"\"",
",",
"appendReq",
",",
"appendResp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"name",
",",
"interpretException",
"(",
"err",
")",
"}",
"\n",
"}",
"\n\n",
"f",
":=",
"&",
"FileWriter",
"{",
"client",
":",
"c",
",",
"name",
":",
"name",
",",
"replication",
":",
"int",
"(",
"appendResp",
".",
"Stat",
".",
"GetBlockReplication",
"(",
")",
")",
",",
"blockSize",
":",
"int64",
"(",
"appendResp",
".",
"Stat",
".",
"GetBlocksize",
"(",
")",
")",
",",
"}",
"\n\n",
"// This returns nil if there are no blocks (it's an empty file) or if the",
"// last block is full (so we have to start a fresh block).",
"block",
":=",
"appendResp",
".",
"GetBlock",
"(",
")",
"\n",
"if",
"block",
"==",
"nil",
"{",
"return",
"f",
",",
"nil",
"\n",
"}",
"\n\n",
"f",
".",
"blockWriter",
"=",
"&",
"rpc",
".",
"BlockWriter",
"{",
"ClientName",
":",
"f",
".",
"client",
".",
"namenode",
".",
"ClientName",
",",
"Block",
":",
"block",
",",
"BlockSize",
":",
"f",
".",
"blockSize",
",",
"Offset",
":",
"int64",
"(",
"block",
".",
"B",
".",
"GetNumBytes",
"(",
")",
")",
",",
"Append",
":",
"true",
",",
"UseDatanodeHostname",
":",
"f",
".",
"client",
".",
"options",
".",
"UseDatanodeHostname",
",",
"DialFunc",
":",
"f",
".",
"client",
".",
"options",
".",
"DatanodeDialFunc",
",",
"}",
"\n\n",
"err",
"=",
"f",
".",
"blockWriter",
".",
"SetDeadline",
"(",
"f",
".",
"deadline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"f",
",",
"nil",
"\n",
"}"
] |
// Append opens an existing file in HDFS and returns an io.WriteCloser for
// writing to it. Because of the way that HDFS writes are buffered and
// acknowledged asynchronously, it is very important that Close is called after
// all data has been written.
|
[
"Append",
"opens",
"an",
"existing",
"file",
"in",
"HDFS",
"and",
"returns",
"an",
"io",
".",
"WriteCloser",
"for",
"writing",
"to",
"it",
".",
"Because",
"of",
"the",
"way",
"that",
"HDFS",
"writes",
"are",
"buffered",
"and",
"acknowledged",
"asynchronously",
"it",
"is",
"very",
"important",
"that",
"Close",
"is",
"called",
"after",
"all",
"data",
"has",
"been",
"written",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/file_writer.go#L84-L131
|
148,999 |
colinmarc/hdfs
|
file_writer.go
|
CreateEmptyFile
|
func (c *Client) CreateEmptyFile(name string) error {
f, err := c.Create(name)
if err != nil {
return err
}
return f.Close()
}
|
go
|
func (c *Client) CreateEmptyFile(name string) error {
f, err := c.Create(name)
if err != nil {
return err
}
return f.Close()
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"CreateEmptyFile",
"(",
"name",
"string",
")",
"error",
"{",
"f",
",",
"err",
":=",
"c",
".",
"Create",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"f",
".",
"Close",
"(",
")",
"\n",
"}"
] |
// CreateEmptyFile creates a empty file at the given name, with the
// permissions 0644.
|
[
"CreateEmptyFile",
"creates",
"a",
"empty",
"file",
"at",
"the",
"given",
"name",
"with",
"the",
"permissions",
"0644",
"."
] |
6f7e441ec688730014b4ca08657db358d7a45b87
|
https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/file_writer.go#L135-L142
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.