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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
asaskevich/govalidator | validator.go | IsDataURI | func IsDataURI(str string) bool {
dataURI := strings.Split(str, ",")
if !rxDataURI.MatchString(dataURI[0]) {
return false
}
return IsBase64(dataURI[1])
} | go | func IsDataURI(str string) bool {
dataURI := strings.Split(str, ",")
if !rxDataURI.MatchString(dataURI[0]) {
return false
}
return IsBase64(dataURI[1])
} | [
"func",
"IsDataURI",
"(",
"str",
"string",
")",
"bool",
"{",
"dataURI",
":=",
"strings",
".",
"Split",
"(",
"str",
",",
"\"",
"\"",
")",
"\n",
"if",
"!",
"rxDataURI",
".",
"MatchString",
"(",
"dataURI",
"[",
"0",
"]",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"IsBase64",
"(",
"dataURI",
"[",
"1",
"]",
")",
"\n",
"}"
] | // IsDataURI checks if a string is base64 encoded data URI such as an image | [
"IsDataURI",
"checks",
"if",
"a",
"string",
"is",
"base64",
"encoded",
"data",
"URI",
"such",
"as",
"an",
"image"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L508-L514 | train |
asaskevich/govalidator | validator.go | IsISO3166Alpha2 | func IsISO3166Alpha2(str string) bool {
for _, entry := range ISO3166List {
if str == entry.Alpha2Code {
return true
}
}
return false
} | go | func IsISO3166Alpha2(str string) bool {
for _, entry := range ISO3166List {
if str == entry.Alpha2Code {
return true
}
}
return false
} | [
"func",
"IsISO3166Alpha2",
"(",
"str",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"entry",
":=",
"range",
"ISO3166List",
"{",
"if",
"str",
"==",
"entry",
".",
"Alpha2Code",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsISO3166Alpha2 checks if a string is valid two-letter country code | [
"IsISO3166Alpha2",
"checks",
"if",
"a",
"string",
"is",
"valid",
"two",
"-",
"letter",
"country",
"code"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L517-L524 | train |
asaskevich/govalidator | validator.go | IsISO3166Alpha3 | func IsISO3166Alpha3(str string) bool {
for _, entry := range ISO3166List {
if str == entry.Alpha3Code {
return true
}
}
return false
} | go | func IsISO3166Alpha3(str string) bool {
for _, entry := range ISO3166List {
if str == entry.Alpha3Code {
return true
}
}
return false
} | [
"func",
"IsISO3166Alpha3",
"(",
"str",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"entry",
":=",
"range",
"ISO3166List",
"{",
"if",
"str",
"==",
"entry",
".",
"Alpha3Code",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsISO3166Alpha3 checks if a string is valid three-letter country code | [
"IsISO3166Alpha3",
"checks",
"if",
"a",
"string",
"is",
"valid",
"three",
"-",
"letter",
"country",
"code"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L527-L534 | train |
asaskevich/govalidator | validator.go | IsISO693Alpha2 | func IsISO693Alpha2(str string) bool {
for _, entry := range ISO693List {
if str == entry.Alpha2Code {
return true
}
}
return false
} | go | func IsISO693Alpha2(str string) bool {
for _, entry := range ISO693List {
if str == entry.Alpha2Code {
return true
}
}
return false
} | [
"func",
"IsISO693Alpha2",
"(",
"str",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"entry",
":=",
"range",
"ISO693List",
"{",
"if",
"str",
"==",
"entry",
".",
"Alpha2Code",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsISO693Alpha2 checks if a string is valid two-letter language code | [
"IsISO693Alpha2",
"checks",
"if",
"a",
"string",
"is",
"valid",
"two",
"-",
"letter",
"language",
"code"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L537-L544 | train |
asaskevich/govalidator | validator.go | IsISO693Alpha3b | func IsISO693Alpha3b(str string) bool {
for _, entry := range ISO693List {
if str == entry.Alpha3bCode {
return true
}
}
return false
} | go | func IsISO693Alpha3b(str string) bool {
for _, entry := range ISO693List {
if str == entry.Alpha3bCode {
return true
}
}
return false
} | [
"func",
"IsISO693Alpha3b",
"(",
"str",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"entry",
":=",
"range",
"ISO693List",
"{",
"if",
"str",
"==",
"entry",
".",
"Alpha3bCode",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsISO693Alpha3b checks if a string is valid three-letter language code | [
"IsISO693Alpha3b",
"checks",
"if",
"a",
"string",
"is",
"valid",
"three",
"-",
"letter",
"language",
"code"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L547-L554 | train |
asaskevich/govalidator | validator.go | IsPort | func IsPort(str string) bool {
if i, err := strconv.Atoi(str); err == nil && i > 0 && i < 65536 {
return true
}
return false
} | go | func IsPort(str string) bool {
if i, err := strconv.Atoi(str); err == nil && i > 0 && i < 65536 {
return true
}
return false
} | [
"func",
"IsPort",
"(",
"str",
"string",
")",
"bool",
"{",
"if",
"i",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"str",
")",
";",
"err",
"==",
"nil",
"&&",
"i",
">",
"0",
"&&",
"i",
"<",
"65536",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsPort checks if a string represents a valid port | [
"IsPort",
"checks",
"if",
"a",
"string",
"represents",
"a",
"valid",
"port"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L608-L613 | train |
asaskevich/govalidator | validator.go | IsIPv4 | func IsIPv4(str string) bool {
ip := net.ParseIP(str)
return ip != nil && strings.Contains(str, ".")
} | go | func IsIPv4(str string) bool {
ip := net.ParseIP(str)
return ip != nil && strings.Contains(str, ".")
} | [
"func",
"IsIPv4",
"(",
"str",
"string",
")",
"bool",
"{",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"str",
")",
"\n",
"return",
"ip",
"!=",
"nil",
"&&",
"strings",
".",
"Contains",
"(",
"str",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // IsIPv4 check if the string is an IP version 4. | [
"IsIPv4",
"check",
"if",
"the",
"string",
"is",
"an",
"IP",
"version",
"4",
"."
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L616-L619 | train |
asaskevich/govalidator | validator.go | IsRsaPublicKey | func IsRsaPublicKey(str string, keylen int) bool {
bb := bytes.NewBufferString(str)
pemBytes, err := ioutil.ReadAll(bb)
if err != nil {
return false
}
block, _ := pem.Decode(pemBytes)
if block != nil && block.Type != "PUBLIC KEY" {
return false
}
var der []byte
if block != nil {
der = block.Bytes
} else {
der, err = base64.StdEncoding.DecodeString(str)
if err != nil {
return false
}
}
key, err := x509.ParsePKIXPublicKey(der)
if err != nil {
return false
}
pubkey, ok := key.(*rsa.PublicKey)
if !ok {
return false
}
bitlen := len(pubkey.N.Bytes()) * 8
return bitlen == int(keylen)
} | go | func IsRsaPublicKey(str string, keylen int) bool {
bb := bytes.NewBufferString(str)
pemBytes, err := ioutil.ReadAll(bb)
if err != nil {
return false
}
block, _ := pem.Decode(pemBytes)
if block != nil && block.Type != "PUBLIC KEY" {
return false
}
var der []byte
if block != nil {
der = block.Bytes
} else {
der, err = base64.StdEncoding.DecodeString(str)
if err != nil {
return false
}
}
key, err := x509.ParsePKIXPublicKey(der)
if err != nil {
return false
}
pubkey, ok := key.(*rsa.PublicKey)
if !ok {
return false
}
bitlen := len(pubkey.N.Bytes()) * 8
return bitlen == int(keylen)
} | [
"func",
"IsRsaPublicKey",
"(",
"str",
"string",
",",
"keylen",
"int",
")",
"bool",
"{",
"bb",
":=",
"bytes",
".",
"NewBufferString",
"(",
"str",
")",
"\n",
"pemBytes",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"bb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"block",
",",
"_",
":=",
"pem",
".",
"Decode",
"(",
"pemBytes",
")",
"\n",
"if",
"block",
"!=",
"nil",
"&&",
"block",
".",
"Type",
"!=",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"var",
"der",
"[",
"]",
"byte",
"\n\n",
"if",
"block",
"!=",
"nil",
"{",
"der",
"=",
"block",
".",
"Bytes",
"\n",
"}",
"else",
"{",
"der",
",",
"err",
"=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"str",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"key",
",",
"err",
":=",
"x509",
".",
"ParsePKIXPublicKey",
"(",
"der",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"pubkey",
",",
"ok",
":=",
"key",
".",
"(",
"*",
"rsa",
".",
"PublicKey",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"bitlen",
":=",
"len",
"(",
"pubkey",
".",
"N",
".",
"Bytes",
"(",
")",
")",
"*",
"8",
"\n",
"return",
"bitlen",
"==",
"int",
"(",
"keylen",
")",
"\n",
"}"
] | // IsRsaPublicKey check if a string is valid public key with provided length | [
"IsRsaPublicKey",
"check",
"if",
"a",
"string",
"is",
"valid",
"public",
"key",
"with",
"provided",
"length"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L667-L698 | train |
asaskevich/govalidator | validator.go | ValidateStruct | func ValidateStruct(s interface{}) (bool, error) {
if s == nil {
return true, nil
}
result := true
var err error
val := reflect.ValueOf(s)
if val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
val = val.Elem()
}
// we only accept structs
if val.Kind() != reflect.Struct {
return false, fmt.Errorf("function only accepts structs; got %s", val.Kind())
}
var errs Errors
for i := 0; i < val.NumField(); i++ {
valueField := val.Field(i)
typeField := val.Type().Field(i)
if typeField.PkgPath != "" {
continue // Private field
}
structResult := true
if valueField.Kind() == reflect.Interface {
valueField = valueField.Elem()
}
if (valueField.Kind() == reflect.Struct ||
(valueField.Kind() == reflect.Ptr && valueField.Elem().Kind() == reflect.Struct)) &&
typeField.Tag.Get(tagName) != "-" {
var err error
structResult, err = ValidateStruct(valueField.Interface())
if err != nil {
err = PrependPathToErrors(err, typeField.Name)
errs = append(errs, err)
}
}
resultField, err2 := typeCheck(valueField, typeField, val, nil)
if err2 != nil {
// Replace structure name with JSON name if there is a tag on the variable
jsonTag := toJSONName(typeField.Tag.Get("json"))
if jsonTag != "" {
switch jsonError := err2.(type) {
case Error:
jsonError.Name = jsonTag
err2 = jsonError
case Errors:
for i2, err3 := range jsonError {
switch customErr := err3.(type) {
case Error:
customErr.Name = jsonTag
jsonError[i2] = customErr
}
}
err2 = jsonError
}
}
errs = append(errs, err2)
}
result = result && resultField && structResult
}
if len(errs) > 0 {
err = errs
}
return result, err
} | go | func ValidateStruct(s interface{}) (bool, error) {
if s == nil {
return true, nil
}
result := true
var err error
val := reflect.ValueOf(s)
if val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
val = val.Elem()
}
// we only accept structs
if val.Kind() != reflect.Struct {
return false, fmt.Errorf("function only accepts structs; got %s", val.Kind())
}
var errs Errors
for i := 0; i < val.NumField(); i++ {
valueField := val.Field(i)
typeField := val.Type().Field(i)
if typeField.PkgPath != "" {
continue // Private field
}
structResult := true
if valueField.Kind() == reflect.Interface {
valueField = valueField.Elem()
}
if (valueField.Kind() == reflect.Struct ||
(valueField.Kind() == reflect.Ptr && valueField.Elem().Kind() == reflect.Struct)) &&
typeField.Tag.Get(tagName) != "-" {
var err error
structResult, err = ValidateStruct(valueField.Interface())
if err != nil {
err = PrependPathToErrors(err, typeField.Name)
errs = append(errs, err)
}
}
resultField, err2 := typeCheck(valueField, typeField, val, nil)
if err2 != nil {
// Replace structure name with JSON name if there is a tag on the variable
jsonTag := toJSONName(typeField.Tag.Get("json"))
if jsonTag != "" {
switch jsonError := err2.(type) {
case Error:
jsonError.Name = jsonTag
err2 = jsonError
case Errors:
for i2, err3 := range jsonError {
switch customErr := err3.(type) {
case Error:
customErr.Name = jsonTag
jsonError[i2] = customErr
}
}
err2 = jsonError
}
}
errs = append(errs, err2)
}
result = result && resultField && structResult
}
if len(errs) > 0 {
err = errs
}
return result, err
} | [
"func",
"ValidateStruct",
"(",
"s",
"interface",
"{",
"}",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"s",
"==",
"nil",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"result",
":=",
"true",
"\n",
"var",
"err",
"error",
"\n",
"val",
":=",
"reflect",
".",
"ValueOf",
"(",
"s",
")",
"\n",
"if",
"val",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Interface",
"||",
"val",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"val",
"=",
"val",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n",
"// we only accept structs",
"if",
"val",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Struct",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"val",
".",
"Kind",
"(",
")",
")",
"\n",
"}",
"\n",
"var",
"errs",
"Errors",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"val",
".",
"NumField",
"(",
")",
";",
"i",
"++",
"{",
"valueField",
":=",
"val",
".",
"Field",
"(",
"i",
")",
"\n",
"typeField",
":=",
"val",
".",
"Type",
"(",
")",
".",
"Field",
"(",
"i",
")",
"\n",
"if",
"typeField",
".",
"PkgPath",
"!=",
"\"",
"\"",
"{",
"continue",
"// Private field",
"\n",
"}",
"\n",
"structResult",
":=",
"true",
"\n",
"if",
"valueField",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Interface",
"{",
"valueField",
"=",
"valueField",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n",
"if",
"(",
"valueField",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Struct",
"||",
"(",
"valueField",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"&&",
"valueField",
".",
"Elem",
"(",
")",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Struct",
")",
")",
"&&",
"typeField",
".",
"Tag",
".",
"Get",
"(",
"tagName",
")",
"!=",
"\"",
"\"",
"{",
"var",
"err",
"error",
"\n",
"structResult",
",",
"err",
"=",
"ValidateStruct",
"(",
"valueField",
".",
"Interface",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"PrependPathToErrors",
"(",
"err",
",",
"typeField",
".",
"Name",
")",
"\n",
"errs",
"=",
"append",
"(",
"errs",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"resultField",
",",
"err2",
":=",
"typeCheck",
"(",
"valueField",
",",
"typeField",
",",
"val",
",",
"nil",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"{",
"// Replace structure name with JSON name if there is a tag on the variable",
"jsonTag",
":=",
"toJSONName",
"(",
"typeField",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"jsonTag",
"!=",
"\"",
"\"",
"{",
"switch",
"jsonError",
":=",
"err2",
".",
"(",
"type",
")",
"{",
"case",
"Error",
":",
"jsonError",
".",
"Name",
"=",
"jsonTag",
"\n",
"err2",
"=",
"jsonError",
"\n",
"case",
"Errors",
":",
"for",
"i2",
",",
"err3",
":=",
"range",
"jsonError",
"{",
"switch",
"customErr",
":=",
"err3",
".",
"(",
"type",
")",
"{",
"case",
"Error",
":",
"customErr",
".",
"Name",
"=",
"jsonTag",
"\n",
"jsonError",
"[",
"i2",
"]",
"=",
"customErr",
"\n",
"}",
"\n",
"}",
"\n\n",
"err2",
"=",
"jsonError",
"\n",
"}",
"\n",
"}",
"\n\n",
"errs",
"=",
"append",
"(",
"errs",
",",
"err2",
")",
"\n",
"}",
"\n",
"result",
"=",
"result",
"&&",
"resultField",
"&&",
"structResult",
"\n",
"}",
"\n",
"if",
"len",
"(",
"errs",
")",
">",
"0",
"{",
"err",
"=",
"errs",
"\n",
"}",
"\n",
"return",
"result",
",",
"err",
"\n",
"}"
] | // ValidateStruct use tags for fields.
// result will be equal to `false` if there are any errors. | [
"ValidateStruct",
"use",
"tags",
"for",
"fields",
".",
"result",
"will",
"be",
"equal",
"to",
"false",
"if",
"there",
"are",
"any",
"errors",
"."
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L738-L804 | train |
asaskevich/govalidator | validator.go | IsSSN | func IsSSN(str string) bool {
if str == "" || len(str) != 11 {
return false
}
return rxSSN.MatchString(str)
} | go | func IsSSN(str string) bool {
if str == "" || len(str) != 11 {
return false
}
return rxSSN.MatchString(str)
} | [
"func",
"IsSSN",
"(",
"str",
"string",
")",
"bool",
"{",
"if",
"str",
"==",
"\"",
"\"",
"||",
"len",
"(",
"str",
")",
"!=",
"11",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"rxSSN",
".",
"MatchString",
"(",
"str",
")",
"\n",
"}"
] | // IsSSN will validate the given string as a U.S. Social Security Number | [
"IsSSN",
"will",
"validate",
"the",
"given",
"string",
"as",
"a",
"U",
".",
"S",
".",
"Social",
"Security",
"Number"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L847-L852 | train |
asaskevich/govalidator | validator.go | IsTime | func IsTime(str string, format string) bool {
_, err := time.Parse(format, str)
return err == nil
} | go | func IsTime(str string, format string) bool {
_, err := time.Parse(format, str)
return err == nil
} | [
"func",
"IsTime",
"(",
"str",
"string",
",",
"format",
"string",
")",
"bool",
"{",
"_",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"format",
",",
"str",
")",
"\n",
"return",
"err",
"==",
"nil",
"\n",
"}"
] | // IsTime check if string is valid according to given format | [
"IsTime",
"check",
"if",
"string",
"is",
"valid",
"according",
"to",
"given",
"format"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L860-L863 | train |
asaskevich/govalidator | validator.go | IsISO4217 | func IsISO4217(str string) bool {
for _, currency := range ISO4217List {
if str == currency {
return true
}
}
return false
} | go | func IsISO4217(str string) bool {
for _, currency := range ISO4217List {
if str == currency {
return true
}
}
return false
} | [
"func",
"IsISO4217",
"(",
"str",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"currency",
":=",
"range",
"ISO4217List",
"{",
"if",
"str",
"==",
"currency",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // IsISO4217 check if string is valid ISO currency code | [
"IsISO4217",
"check",
"if",
"string",
"is",
"valid",
"ISO",
"currency",
"code"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L876-L884 | train |
asaskevich/govalidator | validator.go | ByteLength | func ByteLength(str string, params ...string) bool {
if len(params) == 2 {
min, _ := ToInt(params[0])
max, _ := ToInt(params[1])
return len(str) >= int(min) && len(str) <= int(max)
}
return false
} | go | func ByteLength(str string, params ...string) bool {
if len(params) == 2 {
min, _ := ToInt(params[0])
max, _ := ToInt(params[1])
return len(str) >= int(min) && len(str) <= int(max)
}
return false
} | [
"func",
"ByteLength",
"(",
"str",
"string",
",",
"params",
"...",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"params",
")",
"==",
"2",
"{",
"min",
",",
"_",
":=",
"ToInt",
"(",
"params",
"[",
"0",
"]",
")",
"\n",
"max",
",",
"_",
":=",
"ToInt",
"(",
"params",
"[",
"1",
"]",
")",
"\n",
"return",
"len",
"(",
"str",
")",
">=",
"int",
"(",
"min",
")",
"&&",
"len",
"(",
"str",
")",
"<=",
"int",
"(",
"max",
")",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // ByteLength check string's length | [
"ByteLength",
"check",
"string",
"s",
"length"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L887-L895 | train |
asaskevich/govalidator | validator.go | IsRsaPub | func IsRsaPub(str string, params ...string) bool {
if len(params) == 1 {
len, _ := ToInt(params[0])
return IsRsaPublicKey(str, int(len))
}
return false
} | go | func IsRsaPub(str string, params ...string) bool {
if len(params) == 1 {
len, _ := ToInt(params[0])
return IsRsaPublicKey(str, int(len))
}
return false
} | [
"func",
"IsRsaPub",
"(",
"str",
"string",
",",
"params",
"...",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"params",
")",
"==",
"1",
"{",
"len",
",",
"_",
":=",
"ToInt",
"(",
"params",
"[",
"0",
"]",
")",
"\n",
"return",
"IsRsaPublicKey",
"(",
"str",
",",
"int",
"(",
"len",
")",
")",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // IsRsaPub check whether string is valid RSA key
// Alias for IsRsaPublicKey | [
"IsRsaPub",
"check",
"whether",
"string",
"is",
"valid",
"RSA",
"key",
"Alias",
"for",
"IsRsaPublicKey"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L905-L912 | train |
asaskevich/govalidator | validator.go | StringMatches | func StringMatches(s string, params ...string) bool {
if len(params) == 1 {
pattern := params[0]
return Matches(s, pattern)
}
return false
} | go | func StringMatches(s string, params ...string) bool {
if len(params) == 1 {
pattern := params[0]
return Matches(s, pattern)
}
return false
} | [
"func",
"StringMatches",
"(",
"s",
"string",
",",
"params",
"...",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"params",
")",
"==",
"1",
"{",
"pattern",
":=",
"params",
"[",
"0",
"]",
"\n",
"return",
"Matches",
"(",
"s",
",",
"pattern",
")",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // StringMatches checks if a string matches a given pattern. | [
"StringMatches",
"checks",
"if",
"a",
"string",
"matches",
"a",
"given",
"pattern",
"."
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L915-L921 | train |
asaskevich/govalidator | validator.go | Range | func Range(str string, params ...string) bool {
if len(params) == 2 {
value, _ := ToFloat(str)
min, _ := ToFloat(params[0])
max, _ := ToFloat(params[1])
return InRange(value, min, max)
}
return false
} | go | func Range(str string, params ...string) bool {
if len(params) == 2 {
value, _ := ToFloat(str)
min, _ := ToFloat(params[0])
max, _ := ToFloat(params[1])
return InRange(value, min, max)
}
return false
} | [
"func",
"Range",
"(",
"str",
"string",
",",
"params",
"...",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"params",
")",
"==",
"2",
"{",
"value",
",",
"_",
":=",
"ToFloat",
"(",
"str",
")",
"\n",
"min",
",",
"_",
":=",
"ToFloat",
"(",
"params",
"[",
"0",
"]",
")",
"\n",
"max",
",",
"_",
":=",
"ToFloat",
"(",
"params",
"[",
"1",
"]",
")",
"\n",
"return",
"InRange",
"(",
"value",
",",
"min",
",",
"max",
")",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // Range check string's length | [
"Range",
"check",
"string",
"s",
"length"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L937-L946 | train |
asaskevich/govalidator | validator.go | IsIn | func IsIn(str string, params ...string) bool {
for _, param := range params {
if str == param {
return true
}
}
return false
} | go | func IsIn(str string, params ...string) bool {
for _, param := range params {
if str == param {
return true
}
}
return false
} | [
"func",
"IsIn",
"(",
"str",
"string",
",",
"params",
"...",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"param",
":=",
"range",
"params",
"{",
"if",
"str",
"==",
"param",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // IsIn check if string str is a member of the set of strings params | [
"IsIn",
"check",
"if",
"string",
"str",
"is",
"a",
"member",
"of",
"the",
"set",
"of",
"strings",
"params"
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L961-L969 | train |
asaskevich/govalidator | validator.go | ErrorByField | func ErrorByField(e error, field string) string {
if e == nil {
return ""
}
return ErrorsByField(e)[field]
} | go | func ErrorByField(e error, field string) string {
if e == nil {
return ""
}
return ErrorsByField(e)[field]
} | [
"func",
"ErrorByField",
"(",
"e",
"error",
",",
"field",
"string",
")",
"string",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"ErrorsByField",
"(",
"e",
")",
"[",
"field",
"]",
"\n",
"}"
] | // ErrorByField returns error for specified field of the struct
// validated by ValidateStruct or empty string if there are no errors
// or this field doesn't exists or doesn't have any errors. | [
"ErrorByField",
"returns",
"error",
"for",
"specified",
"field",
"of",
"the",
"struct",
"validated",
"by",
"ValidateStruct",
"or",
"empty",
"string",
"if",
"there",
"are",
"no",
"errors",
"or",
"this",
"field",
"doesn",
"t",
"exists",
"or",
"doesn",
"t",
"have",
"any",
"errors",
"."
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L1239-L1244 | train |
asaskevich/govalidator | validator.go | ErrorsByField | func ErrorsByField(e error) map[string]string {
m := make(map[string]string)
if e == nil {
return m
}
// prototype for ValidateStruct
switch e.(type) {
case Error:
m[e.(Error).Name] = e.(Error).Err.Error()
case Errors:
for _, item := range e.(Errors).Errors() {
n := ErrorsByField(item)
for k, v := range n {
m[k] = v
}
}
}
return m
} | go | func ErrorsByField(e error) map[string]string {
m := make(map[string]string)
if e == nil {
return m
}
// prototype for ValidateStruct
switch e.(type) {
case Error:
m[e.(Error).Name] = e.(Error).Err.Error()
case Errors:
for _, item := range e.(Errors).Errors() {
n := ErrorsByField(item)
for k, v := range n {
m[k] = v
}
}
}
return m
} | [
"func",
"ErrorsByField",
"(",
"e",
"error",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"if",
"e",
"==",
"nil",
"{",
"return",
"m",
"\n",
"}",
"\n",
"// prototype for ValidateStruct",
"switch",
"e",
".",
"(",
"type",
")",
"{",
"case",
"Error",
":",
"m",
"[",
"e",
".",
"(",
"Error",
")",
".",
"Name",
"]",
"=",
"e",
".",
"(",
"Error",
")",
".",
"Err",
".",
"Error",
"(",
")",
"\n",
"case",
"Errors",
":",
"for",
"_",
",",
"item",
":=",
"range",
"e",
".",
"(",
"Errors",
")",
".",
"Errors",
"(",
")",
"{",
"n",
":=",
"ErrorsByField",
"(",
"item",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"n",
"{",
"m",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] | // ErrorsByField returns map of errors of the struct validated
// by ValidateStruct or empty map if there are no errors. | [
"ErrorsByField",
"returns",
"map",
"of",
"errors",
"of",
"the",
"struct",
"validated",
"by",
"ValidateStruct",
"or",
"empty",
"map",
"if",
"there",
"are",
"no",
"errors",
"."
] | f61b66f89f4a311bef65f13e575bcf1a2ffadda6 | https://github.com/asaskevich/govalidator/blob/f61b66f89f4a311bef65f13e575bcf1a2ffadda6/validator.go#L1248-L1268 | train |
beego/bee | cmd/commands/dlv/dlv_amd64.go | buildDebug | func buildDebug() (string, error) {
args := []string{"-gcflags", "-N -l", "-o", "debug"}
args = append(args, utils.SplitQuotedFields("-ldflags='-linkmode internal'")...)
args = append(args, packageName)
if err := utils.GoCommand("build", args...); err != nil {
return "", err
}
fp, err := filepath.Abs("./debug")
if err != nil {
return "", err
}
return fp, nil
} | go | func buildDebug() (string, error) {
args := []string{"-gcflags", "-N -l", "-o", "debug"}
args = append(args, utils.SplitQuotedFields("-ldflags='-linkmode internal'")...)
args = append(args, packageName)
if err := utils.GoCommand("build", args...); err != nil {
return "", err
}
fp, err := filepath.Abs("./debug")
if err != nil {
return "", err
}
return fp, nil
} | [
"func",
"buildDebug",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"args",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"utils",
".",
"SplitQuotedFields",
"(",
"\"",
"\"",
")",
"...",
")",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"packageName",
")",
"\n",
"if",
"err",
":=",
"utils",
".",
"GoCommand",
"(",
"\"",
"\"",
",",
"args",
"...",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"fp",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"fp",
",",
"nil",
"\n",
"}"
] | // buildDebug builds a debug binary in the current working directory | [
"buildDebug",
"builds",
"a",
"debug",
"binary",
"in",
"the",
"current",
"working",
"directory"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/dlv/dlv_amd64.go#L86-L99 | train |
beego/bee | cmd/commands/dlv/dlv_amd64.go | loadPathsToWatch | func loadPathsToWatch(paths *[]string) error {
directory, err := os.Getwd()
if err != nil {
return err
}
filepath.Walk(directory, func(path string, info os.FileInfo, _ error) error {
if strings.HasSuffix(info.Name(), "docs") {
return filepath.SkipDir
}
if strings.HasSuffix(info.Name(), "swagger") {
return filepath.SkipDir
}
if strings.HasSuffix(info.Name(), "vendor") {
return filepath.SkipDir
}
if filepath.Ext(info.Name()) == ".go" {
*paths = append(*paths, path)
}
return nil
})
return nil
} | go | func loadPathsToWatch(paths *[]string) error {
directory, err := os.Getwd()
if err != nil {
return err
}
filepath.Walk(directory, func(path string, info os.FileInfo, _ error) error {
if strings.HasSuffix(info.Name(), "docs") {
return filepath.SkipDir
}
if strings.HasSuffix(info.Name(), "swagger") {
return filepath.SkipDir
}
if strings.HasSuffix(info.Name(), "vendor") {
return filepath.SkipDir
}
if filepath.Ext(info.Name()) == ".go" {
*paths = append(*paths, path)
}
return nil
})
return nil
} | [
"func",
"loadPathsToWatch",
"(",
"paths",
"*",
"[",
"]",
"string",
")",
"error",
"{",
"directory",
",",
"err",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"filepath",
".",
"Walk",
"(",
"directory",
",",
"func",
"(",
"path",
"string",
",",
"info",
"os",
".",
"FileInfo",
",",
"_",
"error",
")",
"error",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"info",
".",
"Name",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"return",
"filepath",
".",
"SkipDir",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"info",
".",
"Name",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"return",
"filepath",
".",
"SkipDir",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"info",
".",
"Name",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"return",
"filepath",
".",
"SkipDir",
"\n",
"}",
"\n\n",
"if",
"filepath",
".",
"Ext",
"(",
"info",
".",
"Name",
"(",
")",
")",
"==",
"\"",
"\"",
"{",
"*",
"paths",
"=",
"append",
"(",
"*",
"paths",
",",
"path",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // loadPathsToWatch loads the paths that needs to be watched for changes | [
"loadPathsToWatch",
"loads",
"the",
"paths",
"that",
"needs",
"to",
"be",
"watched",
"for",
"changes"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/dlv/dlv_amd64.go#L102-L124 | train |
beego/bee | cmd/commands/dlv/dlv_amd64.go | startDelveDebugger | func startDelveDebugger(addr string, ch chan int) int {
beeLogger.Log.Info("Starting Delve Debugger...")
fp, err := buildDebug()
if err != nil {
beeLogger.Log.Fatalf("Error while building debug binary: %v", err)
}
defer os.Remove(fp)
abs, err := filepath.Abs("./debug")
if err != nil {
beeLogger.Log.Fatalf("%v", err)
}
// Create and start the debugger server
listener, err := net.Listen("tcp", addr)
if err != nil {
beeLogger.Log.Fatalf("Could not start listener: %s", err)
}
defer listener.Close()
server := rpccommon.NewServer(&service.Config{
Listener: listener,
AcceptMulti: true,
AttachPid: 0,
APIVersion: 2,
WorkingDir: ".",
ProcessArgs: []string{abs},
}, false)
if err := server.Run(); err != nil {
beeLogger.Log.Fatalf("Could not start debugger server: %v", err)
}
// Start the Delve client REPL
client := rpc2.NewClient(addr)
// Make sure the client is restarted when new changes are introduced
go func() {
for {
if val := <-ch; val == 0 {
if _, err := client.Restart(); err != nil {
utils.Notify("Error while restarting the client: "+err.Error(), "bee")
} else {
if verbose {
utils.Notify("Delve Debugger Restarted", "bee")
}
}
}
}
}()
// Create the terminal and connect it to the client debugger
term := terminal.New(client, nil)
status, err := term.Run()
if err != nil {
beeLogger.Log.Fatalf("Could not start Delve REPL: %v", err)
}
// Stop and kill the debugger server once user quits the REPL
if err := server.Stop(true); err != nil {
beeLogger.Log.Fatalf("Could not stop Delve server: %v", err)
}
return status
} | go | func startDelveDebugger(addr string, ch chan int) int {
beeLogger.Log.Info("Starting Delve Debugger...")
fp, err := buildDebug()
if err != nil {
beeLogger.Log.Fatalf("Error while building debug binary: %v", err)
}
defer os.Remove(fp)
abs, err := filepath.Abs("./debug")
if err != nil {
beeLogger.Log.Fatalf("%v", err)
}
// Create and start the debugger server
listener, err := net.Listen("tcp", addr)
if err != nil {
beeLogger.Log.Fatalf("Could not start listener: %s", err)
}
defer listener.Close()
server := rpccommon.NewServer(&service.Config{
Listener: listener,
AcceptMulti: true,
AttachPid: 0,
APIVersion: 2,
WorkingDir: ".",
ProcessArgs: []string{abs},
}, false)
if err := server.Run(); err != nil {
beeLogger.Log.Fatalf("Could not start debugger server: %v", err)
}
// Start the Delve client REPL
client := rpc2.NewClient(addr)
// Make sure the client is restarted when new changes are introduced
go func() {
for {
if val := <-ch; val == 0 {
if _, err := client.Restart(); err != nil {
utils.Notify("Error while restarting the client: "+err.Error(), "bee")
} else {
if verbose {
utils.Notify("Delve Debugger Restarted", "bee")
}
}
}
}
}()
// Create the terminal and connect it to the client debugger
term := terminal.New(client, nil)
status, err := term.Run()
if err != nil {
beeLogger.Log.Fatalf("Could not start Delve REPL: %v", err)
}
// Stop and kill the debugger server once user quits the REPL
if err := server.Stop(true); err != nil {
beeLogger.Log.Fatalf("Could not stop Delve server: %v", err)
}
return status
} | [
"func",
"startDelveDebugger",
"(",
"addr",
"string",
",",
"ch",
"chan",
"int",
")",
"int",
"{",
"beeLogger",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"fp",
",",
"err",
":=",
"buildDebug",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"os",
".",
"Remove",
"(",
"fp",
")",
"\n\n",
"abs",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Create and start the debugger server",
"listener",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"listener",
".",
"Close",
"(",
")",
"\n\n",
"server",
":=",
"rpccommon",
".",
"NewServer",
"(",
"&",
"service",
".",
"Config",
"{",
"Listener",
":",
"listener",
",",
"AcceptMulti",
":",
"true",
",",
"AttachPid",
":",
"0",
",",
"APIVersion",
":",
"2",
",",
"WorkingDir",
":",
"\"",
"\"",
",",
"ProcessArgs",
":",
"[",
"]",
"string",
"{",
"abs",
"}",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
":=",
"server",
".",
"Run",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Start the Delve client REPL",
"client",
":=",
"rpc2",
".",
"NewClient",
"(",
"addr",
")",
"\n",
"// Make sure the client is restarted when new changes are introduced",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"if",
"val",
":=",
"<-",
"ch",
";",
"val",
"==",
"0",
"{",
"if",
"_",
",",
"err",
":=",
"client",
".",
"Restart",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"utils",
".",
"Notify",
"(",
"\"",
"\"",
"+",
"err",
".",
"Error",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"if",
"verbose",
"{",
"utils",
".",
"Notify",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"// Create the terminal and connect it to the client debugger",
"term",
":=",
"terminal",
".",
"New",
"(",
"client",
",",
"nil",
")",
"\n",
"status",
",",
"err",
":=",
"term",
".",
"Run",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Stop and kill the debugger server once user quits the REPL",
"if",
"err",
":=",
"server",
".",
"Stop",
"(",
"true",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"status",
"\n",
"}"
] | // startDelveDebugger starts the Delve debugger server | [
"startDelveDebugger",
"starts",
"the",
"Delve",
"debugger",
"server"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/dlv/dlv_amd64.go#L127-L189 | train |
beego/bee | cmd/commands/dlv/dlv_amd64.go | startWatcher | func startWatcher(paths []string, ch chan int) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
beeLogger.Log.Fatalf("Could not start the watcher: %v", err)
}
defer watcher.Close()
// Feed the paths to the watcher
for _, path := range paths {
if err := watcher.Add(path); err != nil {
beeLogger.Log.Fatalf("Could not set a watch on path: %v", err)
}
}
for {
select {
case evt := <-watcher.Events:
build := true
if filepath.Ext(evt.Name) != ".go" {
continue
}
mt := utils.GetFileModTime(evt.Name)
if t := eventsModTime[evt.Name]; mt == t {
build = false
}
eventsModTime[evt.Name] = mt
if build {
go func() {
if verbose {
utils.Notify("Rebuilding application with the new changes", "bee")
}
// Wait 1s before re-build until there is no file change
scheduleTime := time.Now().Add(1 * time.Second)
time.Sleep(time.Until(scheduleTime))
_, err := buildDebug()
if err != nil {
utils.Notify("Build Failed: "+err.Error(), "bee")
} else {
ch <- 0 // Notify listeners
}
}()
}
case err := <-watcher.Errors:
if err != nil {
ch <- -1
}
}
}
} | go | func startWatcher(paths []string, ch chan int) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
beeLogger.Log.Fatalf("Could not start the watcher: %v", err)
}
defer watcher.Close()
// Feed the paths to the watcher
for _, path := range paths {
if err := watcher.Add(path); err != nil {
beeLogger.Log.Fatalf("Could not set a watch on path: %v", err)
}
}
for {
select {
case evt := <-watcher.Events:
build := true
if filepath.Ext(evt.Name) != ".go" {
continue
}
mt := utils.GetFileModTime(evt.Name)
if t := eventsModTime[evt.Name]; mt == t {
build = false
}
eventsModTime[evt.Name] = mt
if build {
go func() {
if verbose {
utils.Notify("Rebuilding application with the new changes", "bee")
}
// Wait 1s before re-build until there is no file change
scheduleTime := time.Now().Add(1 * time.Second)
time.Sleep(time.Until(scheduleTime))
_, err := buildDebug()
if err != nil {
utils.Notify("Build Failed: "+err.Error(), "bee")
} else {
ch <- 0 // Notify listeners
}
}()
}
case err := <-watcher.Errors:
if err != nil {
ch <- -1
}
}
}
} | [
"func",
"startWatcher",
"(",
"paths",
"[",
"]",
"string",
",",
"ch",
"chan",
"int",
")",
"{",
"watcher",
",",
"err",
":=",
"fsnotify",
".",
"NewWatcher",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"watcher",
".",
"Close",
"(",
")",
"\n\n",
"// Feed the paths to the watcher",
"for",
"_",
",",
"path",
":=",
"range",
"paths",
"{",
"if",
"err",
":=",
"watcher",
".",
"Add",
"(",
"path",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"evt",
":=",
"<-",
"watcher",
".",
"Events",
":",
"build",
":=",
"true",
"\n",
"if",
"filepath",
".",
"Ext",
"(",
"evt",
".",
"Name",
")",
"!=",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n\n",
"mt",
":=",
"utils",
".",
"GetFileModTime",
"(",
"evt",
".",
"Name",
")",
"\n",
"if",
"t",
":=",
"eventsModTime",
"[",
"evt",
".",
"Name",
"]",
";",
"mt",
"==",
"t",
"{",
"build",
"=",
"false",
"\n",
"}",
"\n",
"eventsModTime",
"[",
"evt",
".",
"Name",
"]",
"=",
"mt",
"\n\n",
"if",
"build",
"{",
"go",
"func",
"(",
")",
"{",
"if",
"verbose",
"{",
"utils",
".",
"Notify",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Wait 1s before re-build until there is no file change",
"scheduleTime",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"1",
"*",
"time",
".",
"Second",
")",
"\n",
"time",
".",
"Sleep",
"(",
"time",
".",
"Until",
"(",
"scheduleTime",
")",
")",
"\n",
"_",
",",
"err",
":=",
"buildDebug",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"Notify",
"(",
"\"",
"\"",
"+",
"err",
".",
"Error",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"ch",
"<-",
"0",
"// Notify listeners",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"case",
"err",
":=",
"<-",
"watcher",
".",
"Errors",
":",
"if",
"err",
"!=",
"nil",
"{",
"ch",
"<-",
"-",
"1",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // startWatcher starts the fsnotify watcher on the passed paths | [
"startWatcher",
"starts",
"the",
"fsnotify",
"watcher",
"on",
"the",
"passed",
"paths"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/dlv/dlv_amd64.go#L194-L245 | train |
beego/bee | generate/swaggergen/g_docs.go | ParsePackagesFromDir | func ParsePackagesFromDir(dirpath string) {
c := make(chan error)
go func() {
filepath.Walk(dirpath, func(fpath string, fileInfo os.FileInfo, err error) error {
if err != nil {
return nil
}
if !fileInfo.IsDir() {
return nil
}
// skip folder if it's a 'vendor' folder within dirpath or its child,
// all 'tests' folders and dot folders wihin dirpath
d, _ := filepath.Rel(dirpath, fpath)
if !(d == "vendor" || strings.HasPrefix(d, "vendor"+string(os.PathSeparator))) &&
!strings.Contains(d, "tests") &&
!(d[0] == '.') {
err = parsePackageFromDir(fpath)
if err != nil {
// Send the error to through the channel and continue walking
c <- fmt.Errorf("error while parsing directory: %s", err.Error())
return nil
}
}
return nil
})
close(c)
}()
for err := range c {
beeLogger.Log.Warnf("%s", err)
}
} | go | func ParsePackagesFromDir(dirpath string) {
c := make(chan error)
go func() {
filepath.Walk(dirpath, func(fpath string, fileInfo os.FileInfo, err error) error {
if err != nil {
return nil
}
if !fileInfo.IsDir() {
return nil
}
// skip folder if it's a 'vendor' folder within dirpath or its child,
// all 'tests' folders and dot folders wihin dirpath
d, _ := filepath.Rel(dirpath, fpath)
if !(d == "vendor" || strings.HasPrefix(d, "vendor"+string(os.PathSeparator))) &&
!strings.Contains(d, "tests") &&
!(d[0] == '.') {
err = parsePackageFromDir(fpath)
if err != nil {
// Send the error to through the channel and continue walking
c <- fmt.Errorf("error while parsing directory: %s", err.Error())
return nil
}
}
return nil
})
close(c)
}()
for err := range c {
beeLogger.Log.Warnf("%s", err)
}
} | [
"func",
"ParsePackagesFromDir",
"(",
"dirpath",
"string",
")",
"{",
"c",
":=",
"make",
"(",
"chan",
"error",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"filepath",
".",
"Walk",
"(",
"dirpath",
",",
"func",
"(",
"fpath",
"string",
",",
"fileInfo",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"error",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"!",
"fileInfo",
".",
"IsDir",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// skip folder if it's a 'vendor' folder within dirpath or its child,",
"// all 'tests' folders and dot folders wihin dirpath",
"d",
",",
"_",
":=",
"filepath",
".",
"Rel",
"(",
"dirpath",
",",
"fpath",
")",
"\n",
"if",
"!",
"(",
"d",
"==",
"\"",
"\"",
"||",
"strings",
".",
"HasPrefix",
"(",
"d",
",",
"\"",
"\"",
"+",
"string",
"(",
"os",
".",
"PathSeparator",
")",
")",
")",
"&&",
"!",
"strings",
".",
"Contains",
"(",
"d",
",",
"\"",
"\"",
")",
"&&",
"!",
"(",
"d",
"[",
"0",
"]",
"==",
"'.'",
")",
"{",
"err",
"=",
"parsePackageFromDir",
"(",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Send the error to through the channel and continue walking",
"c",
"<-",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"close",
"(",
"c",
")",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"err",
":=",
"range",
"c",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // ParsePackagesFromDir parses packages from a given directory | [
"ParsePackagesFromDir",
"parses",
"packages",
"from",
"a",
"given",
"directory"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/swaggergen/g_docs.go#L106-L139 | train |
beego/bee | generate/swaggergen/g_docs.go | analyseNewNamespace | func analyseNewNamespace(ce *ast.CallExpr) (first string, others []ast.Expr) {
for i, p := range ce.Args {
if i == 0 {
switch pp := p.(type) {
case *ast.BasicLit:
first = strings.Trim(pp.Value, `"`)
}
continue
}
others = append(others, p)
}
return
} | go | func analyseNewNamespace(ce *ast.CallExpr) (first string, others []ast.Expr) {
for i, p := range ce.Args {
if i == 0 {
switch pp := p.(type) {
case *ast.BasicLit:
first = strings.Trim(pp.Value, `"`)
}
continue
}
others = append(others, p)
}
return
} | [
"func",
"analyseNewNamespace",
"(",
"ce",
"*",
"ast",
".",
"CallExpr",
")",
"(",
"first",
"string",
",",
"others",
"[",
"]",
"ast",
".",
"Expr",
")",
"{",
"for",
"i",
",",
"p",
":=",
"range",
"ce",
".",
"Args",
"{",
"if",
"i",
"==",
"0",
"{",
"switch",
"pp",
":=",
"p",
".",
"(",
"type",
")",
"{",
"case",
"*",
"ast",
".",
"BasicLit",
":",
"first",
"=",
"strings",
".",
"Trim",
"(",
"pp",
".",
"Value",
",",
"`\"`",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"others",
"=",
"append",
"(",
"others",
",",
"p",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // analyseNewNamespace returns version and the others params | [
"analyseNewNamespace",
"returns",
"version",
"and",
"the",
"others",
"params"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/swaggergen/g_docs.go#L347-L359 | train |
beego/bee | generate/g_appcode.go | String | func (tb *Table) String() string {
rv := fmt.Sprintf("type %s struct {\n", utils.CamelCase(tb.Name))
for _, v := range tb.Columns {
rv += v.String() + "\n"
}
rv += "}\n"
return rv
} | go | func (tb *Table) String() string {
rv := fmt.Sprintf("type %s struct {\n", utils.CamelCase(tb.Name))
for _, v := range tb.Columns {
rv += v.String() + "\n"
}
rv += "}\n"
return rv
} | [
"func",
"(",
"tb",
"*",
"Table",
")",
"String",
"(",
")",
"string",
"{",
"rv",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"utils",
".",
"CamelCase",
"(",
"tb",
".",
"Name",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"tb",
".",
"Columns",
"{",
"rv",
"+=",
"v",
".",
"String",
"(",
")",
"+",
"\"",
"\\n",
"\"",
"\n",
"}",
"\n",
"rv",
"+=",
"\"",
"\\n",
"\"",
"\n",
"return",
"rv",
"\n",
"}"
] | // String returns the source code string for the Table struct | [
"String",
"returns",
"the",
"source",
"code",
"string",
"for",
"the",
"Table",
"struct"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L190-L197 | train |
beego/bee | generate/g_appcode.go | String | func (tag *OrmTag) String() string {
var ormOptions []string
if tag.Column != "" {
ormOptions = append(ormOptions, fmt.Sprintf("column(%s)", tag.Column))
}
if tag.Auto {
ormOptions = append(ormOptions, "auto")
}
if tag.Size != "" {
ormOptions = append(ormOptions, fmt.Sprintf("size(%s)", tag.Size))
}
if tag.Type != "" {
ormOptions = append(ormOptions, fmt.Sprintf("type(%s)", tag.Type))
}
if tag.Null {
ormOptions = append(ormOptions, "null")
}
if tag.AutoNow {
ormOptions = append(ormOptions, "auto_now")
}
if tag.AutoNowAdd {
ormOptions = append(ormOptions, "auto_now_add")
}
if tag.Decimals != "" {
ormOptions = append(ormOptions, fmt.Sprintf("digits(%s);decimals(%s)", tag.Digits, tag.Decimals))
}
if tag.RelFk {
ormOptions = append(ormOptions, "rel(fk)")
}
if tag.RelOne {
ormOptions = append(ormOptions, "rel(one)")
}
if tag.ReverseOne {
ormOptions = append(ormOptions, "reverse(one)")
}
if tag.ReverseMany {
ormOptions = append(ormOptions, "reverse(many)")
}
if tag.RelM2M {
ormOptions = append(ormOptions, "rel(m2m)")
}
if tag.Pk {
ormOptions = append(ormOptions, "pk")
}
if tag.Unique {
ormOptions = append(ormOptions, "unique")
}
if tag.Default != "" {
ormOptions = append(ormOptions, fmt.Sprintf("default(%s)", tag.Default))
}
if len(ormOptions) == 0 {
return ""
}
if tag.Comment != "" {
return fmt.Sprintf("`orm:\"%s\" description:\"%s\"`", strings.Join(ormOptions, ";"), tag.Comment)
}
return fmt.Sprintf("`orm:\"%s\"`", strings.Join(ormOptions, ";"))
} | go | func (tag *OrmTag) String() string {
var ormOptions []string
if tag.Column != "" {
ormOptions = append(ormOptions, fmt.Sprintf("column(%s)", tag.Column))
}
if tag.Auto {
ormOptions = append(ormOptions, "auto")
}
if tag.Size != "" {
ormOptions = append(ormOptions, fmt.Sprintf("size(%s)", tag.Size))
}
if tag.Type != "" {
ormOptions = append(ormOptions, fmt.Sprintf("type(%s)", tag.Type))
}
if tag.Null {
ormOptions = append(ormOptions, "null")
}
if tag.AutoNow {
ormOptions = append(ormOptions, "auto_now")
}
if tag.AutoNowAdd {
ormOptions = append(ormOptions, "auto_now_add")
}
if tag.Decimals != "" {
ormOptions = append(ormOptions, fmt.Sprintf("digits(%s);decimals(%s)", tag.Digits, tag.Decimals))
}
if tag.RelFk {
ormOptions = append(ormOptions, "rel(fk)")
}
if tag.RelOne {
ormOptions = append(ormOptions, "rel(one)")
}
if tag.ReverseOne {
ormOptions = append(ormOptions, "reverse(one)")
}
if tag.ReverseMany {
ormOptions = append(ormOptions, "reverse(many)")
}
if tag.RelM2M {
ormOptions = append(ormOptions, "rel(m2m)")
}
if tag.Pk {
ormOptions = append(ormOptions, "pk")
}
if tag.Unique {
ormOptions = append(ormOptions, "unique")
}
if tag.Default != "" {
ormOptions = append(ormOptions, fmt.Sprintf("default(%s)", tag.Default))
}
if len(ormOptions) == 0 {
return ""
}
if tag.Comment != "" {
return fmt.Sprintf("`orm:\"%s\" description:\"%s\"`", strings.Join(ormOptions, ";"), tag.Comment)
}
return fmt.Sprintf("`orm:\"%s\"`", strings.Join(ormOptions, ";"))
} | [
"func",
"(",
"tag",
"*",
"OrmTag",
")",
"String",
"(",
")",
"string",
"{",
"var",
"ormOptions",
"[",
"]",
"string",
"\n",
"if",
"tag",
".",
"Column",
"!=",
"\"",
"\"",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Column",
")",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Auto",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Size",
"!=",
"\"",
"\"",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Size",
")",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Type",
"!=",
"\"",
"\"",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Type",
")",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Null",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"AutoNow",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"AutoNowAdd",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Decimals",
"!=",
"\"",
"\"",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Digits",
",",
"tag",
".",
"Decimals",
")",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"RelFk",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"RelOne",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"ReverseOne",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"ReverseMany",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"RelM2M",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Pk",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Unique",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Default",
"!=",
"\"",
"\"",
"{",
"ormOptions",
"=",
"append",
"(",
"ormOptions",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"tag",
".",
"Default",
")",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"ormOptions",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"tag",
".",
"Comment",
"!=",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\\\"",
"\\\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
",",
"tag",
".",
"Comment",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"ormOptions",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] | // String returns the ORM tag string for a column | [
"String",
"returns",
"the",
"ORM",
"tag",
"string",
"for",
"a",
"column"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L206-L264 | train |
beego/bee | generate/g_appcode.go | getTableObjects | func getTableObjects(tableNames []string, db *sql.DB, dbTransformer DbTransformer) (tables []*Table) {
// if a table has a composite pk or doesn't have pk, we can't use it yet
// these tables will be put into blacklist so that other struct will not
// reference it.
blackList := make(map[string]bool)
// process constraints information for each table, also gather blacklisted table names
for _, tableName := range tableNames {
// create a table struct
tb := new(Table)
tb.Name = tableName
tb.Fk = make(map[string]*ForeignKey)
dbTransformer.GetConstraints(db, tb, blackList)
tables = append(tables, tb)
}
// process columns, ignoring blacklisted tables
for _, tb := range tables {
dbTransformer.GetColumns(db, tb, blackList)
}
return
} | go | func getTableObjects(tableNames []string, db *sql.DB, dbTransformer DbTransformer) (tables []*Table) {
// if a table has a composite pk or doesn't have pk, we can't use it yet
// these tables will be put into blacklist so that other struct will not
// reference it.
blackList := make(map[string]bool)
// process constraints information for each table, also gather blacklisted table names
for _, tableName := range tableNames {
// create a table struct
tb := new(Table)
tb.Name = tableName
tb.Fk = make(map[string]*ForeignKey)
dbTransformer.GetConstraints(db, tb, blackList)
tables = append(tables, tb)
}
// process columns, ignoring blacklisted tables
for _, tb := range tables {
dbTransformer.GetColumns(db, tb, blackList)
}
return
} | [
"func",
"getTableObjects",
"(",
"tableNames",
"[",
"]",
"string",
",",
"db",
"*",
"sql",
".",
"DB",
",",
"dbTransformer",
"DbTransformer",
")",
"(",
"tables",
"[",
"]",
"*",
"Table",
")",
"{",
"// if a table has a composite pk or doesn't have pk, we can't use it yet",
"// these tables will be put into blacklist so that other struct will not",
"// reference it.",
"blackList",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"// process constraints information for each table, also gather blacklisted table names",
"for",
"_",
",",
"tableName",
":=",
"range",
"tableNames",
"{",
"// create a table struct",
"tb",
":=",
"new",
"(",
"Table",
")",
"\n",
"tb",
".",
"Name",
"=",
"tableName",
"\n",
"tb",
".",
"Fk",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
")",
"\n",
"dbTransformer",
".",
"GetConstraints",
"(",
"db",
",",
"tb",
",",
"blackList",
")",
"\n",
"tables",
"=",
"append",
"(",
"tables",
",",
"tb",
")",
"\n",
"}",
"\n",
"// process columns, ignoring blacklisted tables",
"for",
"_",
",",
"tb",
":=",
"range",
"tables",
"{",
"dbTransformer",
".",
"GetColumns",
"(",
"db",
",",
"tb",
",",
"blackList",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // getTableObjects process each table name | [
"getTableObjects",
"process",
"each",
"table",
"name"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L345-L364 | train |
beego/bee | generate/g_appcode.go | GetGoDataType | func (*MysqlDB) GetGoDataType(sqlType string) (string, error) {
if v, ok := typeMappingMysql[sqlType]; ok {
return v, nil
}
return "", fmt.Errorf("data type '%s' not found", sqlType)
} | go | func (*MysqlDB) GetGoDataType(sqlType string) (string, error) {
if v, ok := typeMappingMysql[sqlType]; ok {
return v, nil
}
return "", fmt.Errorf("data type '%s' not found", sqlType)
} | [
"func",
"(",
"*",
"MysqlDB",
")",
"GetGoDataType",
"(",
"sqlType",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"v",
",",
"ok",
":=",
"typeMappingMysql",
"[",
"sqlType",
"]",
";",
"ok",
"{",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sqlType",
")",
"\n",
"}"
] | // GetGoDataType maps an SQL data type to Golang data type | [
"GetGoDataType",
"maps",
"an",
"SQL",
"data",
"type",
"to",
"Golang",
"data",
"type"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L518-L523 | train |
beego/bee | generate/g_appcode.go | GetTableNames | func (*PostgresDB) GetTableNames(db *sql.DB) (tables []string) {
rows, err := db.Query(`
SELECT table_name FROM information_schema.tables
WHERE table_catalog = current_database() AND
table_type = 'BASE TABLE' AND
table_schema NOT IN ('pg_catalog', 'information_schema')`)
if err != nil {
beeLogger.Log.Fatalf("Could not show tables: %s", err)
}
defer rows.Close()
for rows.Next() {
var name string
if err := rows.Scan(&name); err != nil {
beeLogger.Log.Fatalf("Could not show tables: %s", err)
}
tables = append(tables, name)
}
return
} | go | func (*PostgresDB) GetTableNames(db *sql.DB) (tables []string) {
rows, err := db.Query(`
SELECT table_name FROM information_schema.tables
WHERE table_catalog = current_database() AND
table_type = 'BASE TABLE' AND
table_schema NOT IN ('pg_catalog', 'information_schema')`)
if err != nil {
beeLogger.Log.Fatalf("Could not show tables: %s", err)
}
defer rows.Close()
for rows.Next() {
var name string
if err := rows.Scan(&name); err != nil {
beeLogger.Log.Fatalf("Could not show tables: %s", err)
}
tables = append(tables, name)
}
return
} | [
"func",
"(",
"*",
"PostgresDB",
")",
"GetTableNames",
"(",
"db",
"*",
"sql",
".",
"DB",
")",
"(",
"tables",
"[",
"]",
"string",
")",
"{",
"rows",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"`\n\t\tSELECT table_name FROM information_schema.tables\n\t\tWHERE table_catalog = current_database() AND\n\t\ttable_type = 'BASE TABLE' AND\n\t\ttable_schema NOT IN ('pg_catalog', 'information_schema')`",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"rows",
".",
"Close",
"(",
")",
"\n\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"var",
"name",
"string",
"\n",
"if",
"err",
":=",
"rows",
".",
"Scan",
"(",
"&",
"name",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"tables",
"=",
"append",
"(",
"tables",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // GetTableNames for PostgreSQL | [
"GetTableNames",
"for",
"PostgreSQL"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L526-L545 | train |
beego/bee | generate/g_appcode.go | GetConstraints | func (*PostgresDB) GetConstraints(db *sql.DB, table *Table, blackList map[string]bool) {
rows, err := db.Query(
`SELECT
c.constraint_type,
u.column_name,
cu.table_catalog AS referenced_table_catalog,
cu.table_name AS referenced_table_name,
cu.column_name AS referenced_column_name,
u.ordinal_position
FROM
information_schema.table_constraints c
INNER JOIN
information_schema.key_column_usage u ON c.constraint_name = u.constraint_name
INNER JOIN
information_schema.constraint_column_usage cu ON cu.constraint_name = c.constraint_name
WHERE
c.table_catalog = current_database() AND c.table_schema NOT IN ('pg_catalog', 'information_schema')
AND c.table_name = $1
AND u.table_catalog = current_database() AND u.table_schema NOT IN ('pg_catalog', 'information_schema')
AND u.table_name = $2`,
table.Name, table.Name) // u.position_in_unique_constraint,
if err != nil {
beeLogger.Log.Fatalf("Could not query INFORMATION_SCHEMA for PK/UK/FK information: %s", err)
}
for rows.Next() {
var constraintTypeBytes, columnNameBytes, refTableSchemaBytes, refTableNameBytes, refColumnNameBytes, refOrdinalPosBytes []byte
if err := rows.Scan(&constraintTypeBytes, &columnNameBytes, &refTableSchemaBytes, &refTableNameBytes, &refColumnNameBytes, &refOrdinalPosBytes); err != nil {
beeLogger.Log.Fatalf("Could not read INFORMATION_SCHEMA for PK/UK/FK information: %s", err)
}
constraintType, columnName, refTableSchema, refTableName, refColumnName, refOrdinalPos :=
string(constraintTypeBytes), string(columnNameBytes), string(refTableSchemaBytes),
string(refTableNameBytes), string(refColumnNameBytes), string(refOrdinalPosBytes)
if constraintType == "PRIMARY KEY" {
if refOrdinalPos == "1" {
table.Pk = columnName
} else {
table.Pk = ""
// add table to blacklist so that other struct will not reference it, because we are not
// registering blacklisted tables
blackList[table.Name] = true
}
} else if constraintType == "UNIQUE" {
table.Uk = append(table.Uk, columnName)
} else if constraintType == "FOREIGN KEY" {
fk := new(ForeignKey)
fk.Name = columnName
fk.RefSchema = refTableSchema
fk.RefTable = refTableName
fk.RefColumn = refColumnName
table.Fk[columnName] = fk
}
}
} | go | func (*PostgresDB) GetConstraints(db *sql.DB, table *Table, blackList map[string]bool) {
rows, err := db.Query(
`SELECT
c.constraint_type,
u.column_name,
cu.table_catalog AS referenced_table_catalog,
cu.table_name AS referenced_table_name,
cu.column_name AS referenced_column_name,
u.ordinal_position
FROM
information_schema.table_constraints c
INNER JOIN
information_schema.key_column_usage u ON c.constraint_name = u.constraint_name
INNER JOIN
information_schema.constraint_column_usage cu ON cu.constraint_name = c.constraint_name
WHERE
c.table_catalog = current_database() AND c.table_schema NOT IN ('pg_catalog', 'information_schema')
AND c.table_name = $1
AND u.table_catalog = current_database() AND u.table_schema NOT IN ('pg_catalog', 'information_schema')
AND u.table_name = $2`,
table.Name, table.Name) // u.position_in_unique_constraint,
if err != nil {
beeLogger.Log.Fatalf("Could not query INFORMATION_SCHEMA for PK/UK/FK information: %s", err)
}
for rows.Next() {
var constraintTypeBytes, columnNameBytes, refTableSchemaBytes, refTableNameBytes, refColumnNameBytes, refOrdinalPosBytes []byte
if err := rows.Scan(&constraintTypeBytes, &columnNameBytes, &refTableSchemaBytes, &refTableNameBytes, &refColumnNameBytes, &refOrdinalPosBytes); err != nil {
beeLogger.Log.Fatalf("Could not read INFORMATION_SCHEMA for PK/UK/FK information: %s", err)
}
constraintType, columnName, refTableSchema, refTableName, refColumnName, refOrdinalPos :=
string(constraintTypeBytes), string(columnNameBytes), string(refTableSchemaBytes),
string(refTableNameBytes), string(refColumnNameBytes), string(refOrdinalPosBytes)
if constraintType == "PRIMARY KEY" {
if refOrdinalPos == "1" {
table.Pk = columnName
} else {
table.Pk = ""
// add table to blacklist so that other struct will not reference it, because we are not
// registering blacklisted tables
blackList[table.Name] = true
}
} else if constraintType == "UNIQUE" {
table.Uk = append(table.Uk, columnName)
} else if constraintType == "FOREIGN KEY" {
fk := new(ForeignKey)
fk.Name = columnName
fk.RefSchema = refTableSchema
fk.RefTable = refTableName
fk.RefColumn = refColumnName
table.Fk[columnName] = fk
}
}
} | [
"func",
"(",
"*",
"PostgresDB",
")",
"GetConstraints",
"(",
"db",
"*",
"sql",
".",
"DB",
",",
"table",
"*",
"Table",
",",
"blackList",
"map",
"[",
"string",
"]",
"bool",
")",
"{",
"rows",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"`SELECT\n\t\t\tc.constraint_type,\n\t\t\tu.column_name,\n\t\t\tcu.table_catalog AS referenced_table_catalog,\n\t\t\tcu.table_name AS referenced_table_name,\n\t\t\tcu.column_name AS referenced_column_name,\n\t\t\tu.ordinal_position\n\t\tFROM\n\t\t\tinformation_schema.table_constraints c\n\t\tINNER JOIN\n\t\t\tinformation_schema.key_column_usage u ON c.constraint_name = u.constraint_name\n\t\tINNER JOIN\n\t\t\tinformation_schema.constraint_column_usage cu ON cu.constraint_name = c.constraint_name\n\t\tWHERE\n\t\t\tc.table_catalog = current_database() AND c.table_schema NOT IN ('pg_catalog', 'information_schema')\n\t\t\t AND c.table_name = $1\n\t\t\tAND u.table_catalog = current_database() AND u.table_schema NOT IN ('pg_catalog', 'information_schema')\n\t\t\t AND u.table_name = $2`",
",",
"table",
".",
"Name",
",",
"table",
".",
"Name",
")",
"// u.position_in_unique_constraint,",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"var",
"constraintTypeBytes",
",",
"columnNameBytes",
",",
"refTableSchemaBytes",
",",
"refTableNameBytes",
",",
"refColumnNameBytes",
",",
"refOrdinalPosBytes",
"[",
"]",
"byte",
"\n",
"if",
"err",
":=",
"rows",
".",
"Scan",
"(",
"&",
"constraintTypeBytes",
",",
"&",
"columnNameBytes",
",",
"&",
"refTableSchemaBytes",
",",
"&",
"refTableNameBytes",
",",
"&",
"refColumnNameBytes",
",",
"&",
"refOrdinalPosBytes",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"constraintType",
",",
"columnName",
",",
"refTableSchema",
",",
"refTableName",
",",
"refColumnName",
",",
"refOrdinalPos",
":=",
"string",
"(",
"constraintTypeBytes",
")",
",",
"string",
"(",
"columnNameBytes",
")",
",",
"string",
"(",
"refTableSchemaBytes",
")",
",",
"string",
"(",
"refTableNameBytes",
")",
",",
"string",
"(",
"refColumnNameBytes",
")",
",",
"string",
"(",
"refOrdinalPosBytes",
")",
"\n",
"if",
"constraintType",
"==",
"\"",
"\"",
"{",
"if",
"refOrdinalPos",
"==",
"\"",
"\"",
"{",
"table",
".",
"Pk",
"=",
"columnName",
"\n",
"}",
"else",
"{",
"table",
".",
"Pk",
"=",
"\"",
"\"",
"\n",
"// add table to blacklist so that other struct will not reference it, because we are not",
"// registering blacklisted tables",
"blackList",
"[",
"table",
".",
"Name",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"else",
"if",
"constraintType",
"==",
"\"",
"\"",
"{",
"table",
".",
"Uk",
"=",
"append",
"(",
"table",
".",
"Uk",
",",
"columnName",
")",
"\n",
"}",
"else",
"if",
"constraintType",
"==",
"\"",
"\"",
"{",
"fk",
":=",
"new",
"(",
"ForeignKey",
")",
"\n",
"fk",
".",
"Name",
"=",
"columnName",
"\n",
"fk",
".",
"RefSchema",
"=",
"refTableSchema",
"\n",
"fk",
".",
"RefTable",
"=",
"refTableName",
"\n",
"fk",
".",
"RefColumn",
"=",
"refColumnName",
"\n",
"table",
".",
"Fk",
"[",
"columnName",
"]",
"=",
"fk",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // GetConstraints for PostgreSQL | [
"GetConstraints",
"for",
"PostgreSQL"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L548-L601 | train |
beego/bee | generate/g_appcode.go | GetGoDataType | func (*PostgresDB) GetGoDataType(sqlType string) (string, error) {
if v, ok := typeMappingPostgres[sqlType]; ok {
return v, nil
}
return "", fmt.Errorf("data type '%s' not found", sqlType)
} | go | func (*PostgresDB) GetGoDataType(sqlType string) (string, error) {
if v, ok := typeMappingPostgres[sqlType]; ok {
return v, nil
}
return "", fmt.Errorf("data type '%s' not found", sqlType)
} | [
"func",
"(",
"*",
"PostgresDB",
")",
"GetGoDataType",
"(",
"sqlType",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"v",
",",
"ok",
":=",
"typeMappingPostgres",
"[",
"sqlType",
"]",
";",
"ok",
"{",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sqlType",
")",
"\n",
"}"
] | // GetGoDataType returns the Go type from the mapped Postgres type | [
"GetGoDataType",
"returns",
"the",
"Go",
"type",
"from",
"the",
"mapped",
"Postgres",
"type"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L708-L713 | train |
beego/bee | generate/g_appcode.go | createPaths | func createPaths(mode byte, paths *MvcPath) {
if (mode & OModel) == OModel {
os.Mkdir(paths.ModelPath, 0777)
}
if (mode & OController) == OController {
os.Mkdir(paths.ControllerPath, 0777)
}
if (mode & ORouter) == ORouter {
os.Mkdir(paths.RouterPath, 0777)
}
} | go | func createPaths(mode byte, paths *MvcPath) {
if (mode & OModel) == OModel {
os.Mkdir(paths.ModelPath, 0777)
}
if (mode & OController) == OController {
os.Mkdir(paths.ControllerPath, 0777)
}
if (mode & ORouter) == ORouter {
os.Mkdir(paths.RouterPath, 0777)
}
} | [
"func",
"createPaths",
"(",
"mode",
"byte",
",",
"paths",
"*",
"MvcPath",
")",
"{",
"if",
"(",
"mode",
"&",
"OModel",
")",
"==",
"OModel",
"{",
"os",
".",
"Mkdir",
"(",
"paths",
".",
"ModelPath",
",",
"0777",
")",
"\n",
"}",
"\n",
"if",
"(",
"mode",
"&",
"OController",
")",
"==",
"OController",
"{",
"os",
".",
"Mkdir",
"(",
"paths",
".",
"ControllerPath",
",",
"0777",
")",
"\n",
"}",
"\n",
"if",
"(",
"mode",
"&",
"ORouter",
")",
"==",
"ORouter",
"{",
"os",
".",
"Mkdir",
"(",
"paths",
".",
"RouterPath",
",",
"0777",
")",
"\n",
"}",
"\n",
"}"
] | // deleteAndRecreatePaths removes several directories completely | [
"deleteAndRecreatePaths",
"removes",
"several",
"directories",
"completely"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L716-L726 | train |
beego/bee | generate/g_appcode.go | writeModelFiles | func writeModelFiles(tables []*Table, mPath string) {
w := colors.NewColorWriter(os.Stdout)
for _, tb := range tables {
filename := getFileName(tb.Name)
fpath := path.Join(mPath, filename+".go")
var f *os.File
var err error
if utils.IsExist(fpath) {
beeLogger.Log.Warnf("'%s' already exists. Do you want to overwrite it? [Yes|No] ", fpath)
if utils.AskForConfirmation() {
f, err = os.OpenFile(fpath, os.O_RDWR|os.O_TRUNC, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
continue
}
} else {
beeLogger.Log.Warnf("Skipped create file '%s'", fpath)
continue
}
} else {
f, err = os.OpenFile(fpath, os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
continue
}
}
var template string
if tb.Pk == "" {
template = StructModelTPL
} else {
template = ModelTPL
}
fileStr := strings.Replace(template, "{{modelStruct}}", tb.String(), 1)
fileStr = strings.Replace(fileStr, "{{modelName}}", utils.CamelCase(tb.Name), -1)
fileStr = strings.Replace(fileStr, "{{tableName}}", tb.Name, -1)
// If table contains time field, import time.Time package
timePkg := ""
importTimePkg := ""
if tb.ImportTimePkg {
timePkg = "\"time\"\n"
importTimePkg = "import \"time\"\n"
}
fileStr = strings.Replace(fileStr, "{{timePkg}}", timePkg, -1)
fileStr = strings.Replace(fileStr, "{{importTimePkg}}", importTimePkg, -1)
if _, err := f.WriteString(fileStr); err != nil {
beeLogger.Log.Fatalf("Could not write model file to '%s': %s", fpath, err)
}
utils.CloseFile(f)
fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", fpath, "\x1b[0m")
utils.FormatSourceCode(fpath)
}
} | go | func writeModelFiles(tables []*Table, mPath string) {
w := colors.NewColorWriter(os.Stdout)
for _, tb := range tables {
filename := getFileName(tb.Name)
fpath := path.Join(mPath, filename+".go")
var f *os.File
var err error
if utils.IsExist(fpath) {
beeLogger.Log.Warnf("'%s' already exists. Do you want to overwrite it? [Yes|No] ", fpath)
if utils.AskForConfirmation() {
f, err = os.OpenFile(fpath, os.O_RDWR|os.O_TRUNC, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
continue
}
} else {
beeLogger.Log.Warnf("Skipped create file '%s'", fpath)
continue
}
} else {
f, err = os.OpenFile(fpath, os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
continue
}
}
var template string
if tb.Pk == "" {
template = StructModelTPL
} else {
template = ModelTPL
}
fileStr := strings.Replace(template, "{{modelStruct}}", tb.String(), 1)
fileStr = strings.Replace(fileStr, "{{modelName}}", utils.CamelCase(tb.Name), -1)
fileStr = strings.Replace(fileStr, "{{tableName}}", tb.Name, -1)
// If table contains time field, import time.Time package
timePkg := ""
importTimePkg := ""
if tb.ImportTimePkg {
timePkg = "\"time\"\n"
importTimePkg = "import \"time\"\n"
}
fileStr = strings.Replace(fileStr, "{{timePkg}}", timePkg, -1)
fileStr = strings.Replace(fileStr, "{{importTimePkg}}", importTimePkg, -1)
if _, err := f.WriteString(fileStr); err != nil {
beeLogger.Log.Fatalf("Could not write model file to '%s': %s", fpath, err)
}
utils.CloseFile(f)
fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", fpath, "\x1b[0m")
utils.FormatSourceCode(fpath)
}
} | [
"func",
"writeModelFiles",
"(",
"tables",
"[",
"]",
"*",
"Table",
",",
"mPath",
"string",
")",
"{",
"w",
":=",
"colors",
".",
"NewColorWriter",
"(",
"os",
".",
"Stdout",
")",
"\n\n",
"for",
"_",
",",
"tb",
":=",
"range",
"tables",
"{",
"filename",
":=",
"getFileName",
"(",
"tb",
".",
"Name",
")",
"\n",
"fpath",
":=",
"path",
".",
"Join",
"(",
"mPath",
",",
"filename",
"+",
"\"",
"\"",
")",
"\n",
"var",
"f",
"*",
"os",
".",
"File",
"\n",
"var",
"err",
"error",
"\n",
"if",
"utils",
".",
"IsExist",
"(",
"fpath",
")",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"fpath",
")",
"\n",
"if",
"utils",
".",
"AskForConfirmation",
"(",
")",
"{",
"f",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"fpath",
",",
"os",
".",
"O_RDWR",
"|",
"os",
".",
"O_TRUNC",
",",
"0666",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"else",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"fpath",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"else",
"{",
"f",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"fpath",
",",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_RDWR",
",",
"0666",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"template",
"string",
"\n",
"if",
"tb",
".",
"Pk",
"==",
"\"",
"\"",
"{",
"template",
"=",
"StructModelTPL",
"\n",
"}",
"else",
"{",
"template",
"=",
"ModelTPL",
"\n",
"}",
"\n",
"fileStr",
":=",
"strings",
".",
"Replace",
"(",
"template",
",",
"\"",
"\"",
",",
"tb",
".",
"String",
"(",
")",
",",
"1",
")",
"\n",
"fileStr",
"=",
"strings",
".",
"Replace",
"(",
"fileStr",
",",
"\"",
"\"",
",",
"utils",
".",
"CamelCase",
"(",
"tb",
".",
"Name",
")",
",",
"-",
"1",
")",
"\n",
"fileStr",
"=",
"strings",
".",
"Replace",
"(",
"fileStr",
",",
"\"",
"\"",
",",
"tb",
".",
"Name",
",",
"-",
"1",
")",
"\n\n",
"// If table contains time field, import time.Time package",
"timePkg",
":=",
"\"",
"\"",
"\n",
"importTimePkg",
":=",
"\"",
"\"",
"\n",
"if",
"tb",
".",
"ImportTimePkg",
"{",
"timePkg",
"=",
"\"",
"\\\"",
"\\\"",
"\\n",
"\"",
"\n",
"importTimePkg",
"=",
"\"",
"\\\"",
"\\\"",
"\\n",
"\"",
"\n",
"}",
"\n",
"fileStr",
"=",
"strings",
".",
"Replace",
"(",
"fileStr",
",",
"\"",
"\"",
",",
"timePkg",
",",
"-",
"1",
")",
"\n",
"fileStr",
"=",
"strings",
".",
"Replace",
"(",
"fileStr",
",",
"\"",
"\"",
",",
"importTimePkg",
",",
"-",
"1",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"f",
".",
"WriteString",
"(",
"fileStr",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"fpath",
",",
"err",
")",
"\n",
"}",
"\n",
"utils",
".",
"CloseFile",
"(",
"f",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\\t",
"\\t",
"\\n",
"\"",
",",
"\"",
"\\x1b",
"\"",
",",
"\"",
"\\x1b",
"\"",
",",
"\"",
"\\x1b",
"\"",
",",
"fpath",
",",
"\"",
"\\x1b",
"\"",
")",
"\n",
"utils",
".",
"FormatSourceCode",
"(",
"fpath",
")",
"\n",
"}",
"\n",
"}"
] | // writeModelFiles generates model files | [
"writeModelFiles",
"generates",
"model",
"files"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L747-L800 | train |
beego/bee | generate/g_appcode.go | writeControllerFiles | func writeControllerFiles(tables []*Table, cPath string, pkgPath string) {
w := colors.NewColorWriter(os.Stdout)
for _, tb := range tables {
if tb.Pk == "" {
continue
}
filename := getFileName(tb.Name)
fpath := path.Join(cPath, filename+".go")
var f *os.File
var err error
if utils.IsExist(fpath) {
beeLogger.Log.Warnf("'%s' already exists. Do you want to overwrite it? [Yes|No] ", fpath)
if utils.AskForConfirmation() {
f, err = os.OpenFile(fpath, os.O_RDWR|os.O_TRUNC, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
continue
}
} else {
beeLogger.Log.Warnf("Skipped create file '%s'", fpath)
continue
}
} else {
f, err = os.OpenFile(fpath, os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
continue
}
}
fileStr := strings.Replace(CtrlTPL, "{{ctrlName}}", utils.CamelCase(tb.Name), -1)
fileStr = strings.Replace(fileStr, "{{pkgPath}}", pkgPath, -1)
if _, err := f.WriteString(fileStr); err != nil {
beeLogger.Log.Fatalf("Could not write controller file to '%s': %s", fpath, err)
}
utils.CloseFile(f)
fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", fpath, "\x1b[0m")
utils.FormatSourceCode(fpath)
}
} | go | func writeControllerFiles(tables []*Table, cPath string, pkgPath string) {
w := colors.NewColorWriter(os.Stdout)
for _, tb := range tables {
if tb.Pk == "" {
continue
}
filename := getFileName(tb.Name)
fpath := path.Join(cPath, filename+".go")
var f *os.File
var err error
if utils.IsExist(fpath) {
beeLogger.Log.Warnf("'%s' already exists. Do you want to overwrite it? [Yes|No] ", fpath)
if utils.AskForConfirmation() {
f, err = os.OpenFile(fpath, os.O_RDWR|os.O_TRUNC, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
continue
}
} else {
beeLogger.Log.Warnf("Skipped create file '%s'", fpath)
continue
}
} else {
f, err = os.OpenFile(fpath, os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
continue
}
}
fileStr := strings.Replace(CtrlTPL, "{{ctrlName}}", utils.CamelCase(tb.Name), -1)
fileStr = strings.Replace(fileStr, "{{pkgPath}}", pkgPath, -1)
if _, err := f.WriteString(fileStr); err != nil {
beeLogger.Log.Fatalf("Could not write controller file to '%s': %s", fpath, err)
}
utils.CloseFile(f)
fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", fpath, "\x1b[0m")
utils.FormatSourceCode(fpath)
}
} | [
"func",
"writeControllerFiles",
"(",
"tables",
"[",
"]",
"*",
"Table",
",",
"cPath",
"string",
",",
"pkgPath",
"string",
")",
"{",
"w",
":=",
"colors",
".",
"NewColorWriter",
"(",
"os",
".",
"Stdout",
")",
"\n\n",
"for",
"_",
",",
"tb",
":=",
"range",
"tables",
"{",
"if",
"tb",
".",
"Pk",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"filename",
":=",
"getFileName",
"(",
"tb",
".",
"Name",
")",
"\n",
"fpath",
":=",
"path",
".",
"Join",
"(",
"cPath",
",",
"filename",
"+",
"\"",
"\"",
")",
"\n",
"var",
"f",
"*",
"os",
".",
"File",
"\n",
"var",
"err",
"error",
"\n",
"if",
"utils",
".",
"IsExist",
"(",
"fpath",
")",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"fpath",
")",
"\n",
"if",
"utils",
".",
"AskForConfirmation",
"(",
")",
"{",
"f",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"fpath",
",",
"os",
".",
"O_RDWR",
"|",
"os",
".",
"O_TRUNC",
",",
"0666",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"else",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"fpath",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"else",
"{",
"f",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"fpath",
",",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_RDWR",
",",
"0666",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"fileStr",
":=",
"strings",
".",
"Replace",
"(",
"CtrlTPL",
",",
"\"",
"\"",
",",
"utils",
".",
"CamelCase",
"(",
"tb",
".",
"Name",
")",
",",
"-",
"1",
")",
"\n",
"fileStr",
"=",
"strings",
".",
"Replace",
"(",
"fileStr",
",",
"\"",
"\"",
",",
"pkgPath",
",",
"-",
"1",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"f",
".",
"WriteString",
"(",
"fileStr",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"fpath",
",",
"err",
")",
"\n",
"}",
"\n",
"utils",
".",
"CloseFile",
"(",
"f",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\\t",
"\\t",
"\\n",
"\"",
",",
"\"",
"\\x1b",
"\"",
",",
"\"",
"\\x1b",
"\"",
",",
"\"",
"\\x1b",
"\"",
",",
"fpath",
",",
"\"",
"\\x1b",
"\"",
")",
"\n",
"utils",
".",
"FormatSourceCode",
"(",
"fpath",
")",
"\n",
"}",
"\n",
"}"
] | // writeControllerFiles generates controller files | [
"writeControllerFiles",
"generates",
"controller",
"files"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L803-L842 | train |
beego/bee | generate/g_appcode.go | writeRouterFile | func writeRouterFile(tables []*Table, rPath string, pkgPath string) {
w := colors.NewColorWriter(os.Stdout)
var nameSpaces []string
for _, tb := range tables {
if tb.Pk == "" {
continue
}
// Add namespaces
nameSpace := strings.Replace(NamespaceTPL, "{{nameSpace}}", tb.Name, -1)
nameSpace = strings.Replace(nameSpace, "{{ctrlName}}", utils.CamelCase(tb.Name), -1)
nameSpaces = append(nameSpaces, nameSpace)
}
// Add export controller
fpath := filepath.Join(rPath, "router.go")
routerStr := strings.Replace(RouterTPL, "{{nameSpaces}}", strings.Join(nameSpaces, ""), 1)
routerStr = strings.Replace(routerStr, "{{pkgPath}}", pkgPath, 1)
var f *os.File
var err error
if utils.IsExist(fpath) {
beeLogger.Log.Warnf("'%s' already exists. Do you want to overwrite it? [Yes|No] ", fpath)
if utils.AskForConfirmation() {
f, err = os.OpenFile(fpath, os.O_RDWR|os.O_TRUNC, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
return
}
} else {
beeLogger.Log.Warnf("Skipped create file '%s'", fpath)
return
}
} else {
f, err = os.OpenFile(fpath, os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
return
}
}
if _, err := f.WriteString(routerStr); err != nil {
beeLogger.Log.Fatalf("Could not write router file to '%s': %s", fpath, err)
}
utils.CloseFile(f)
fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", fpath, "\x1b[0m")
utils.FormatSourceCode(fpath)
} | go | func writeRouterFile(tables []*Table, rPath string, pkgPath string) {
w := colors.NewColorWriter(os.Stdout)
var nameSpaces []string
for _, tb := range tables {
if tb.Pk == "" {
continue
}
// Add namespaces
nameSpace := strings.Replace(NamespaceTPL, "{{nameSpace}}", tb.Name, -1)
nameSpace = strings.Replace(nameSpace, "{{ctrlName}}", utils.CamelCase(tb.Name), -1)
nameSpaces = append(nameSpaces, nameSpace)
}
// Add export controller
fpath := filepath.Join(rPath, "router.go")
routerStr := strings.Replace(RouterTPL, "{{nameSpaces}}", strings.Join(nameSpaces, ""), 1)
routerStr = strings.Replace(routerStr, "{{pkgPath}}", pkgPath, 1)
var f *os.File
var err error
if utils.IsExist(fpath) {
beeLogger.Log.Warnf("'%s' already exists. Do you want to overwrite it? [Yes|No] ", fpath)
if utils.AskForConfirmation() {
f, err = os.OpenFile(fpath, os.O_RDWR|os.O_TRUNC, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
return
}
} else {
beeLogger.Log.Warnf("Skipped create file '%s'", fpath)
return
}
} else {
f, err = os.OpenFile(fpath, os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
return
}
}
if _, err := f.WriteString(routerStr); err != nil {
beeLogger.Log.Fatalf("Could not write router file to '%s': %s", fpath, err)
}
utils.CloseFile(f)
fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", fpath, "\x1b[0m")
utils.FormatSourceCode(fpath)
} | [
"func",
"writeRouterFile",
"(",
"tables",
"[",
"]",
"*",
"Table",
",",
"rPath",
"string",
",",
"pkgPath",
"string",
")",
"{",
"w",
":=",
"colors",
".",
"NewColorWriter",
"(",
"os",
".",
"Stdout",
")",
"\n\n",
"var",
"nameSpaces",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"tb",
":=",
"range",
"tables",
"{",
"if",
"tb",
".",
"Pk",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"// Add namespaces",
"nameSpace",
":=",
"strings",
".",
"Replace",
"(",
"NamespaceTPL",
",",
"\"",
"\"",
",",
"tb",
".",
"Name",
",",
"-",
"1",
")",
"\n",
"nameSpace",
"=",
"strings",
".",
"Replace",
"(",
"nameSpace",
",",
"\"",
"\"",
",",
"utils",
".",
"CamelCase",
"(",
"tb",
".",
"Name",
")",
",",
"-",
"1",
")",
"\n",
"nameSpaces",
"=",
"append",
"(",
"nameSpaces",
",",
"nameSpace",
")",
"\n",
"}",
"\n",
"// Add export controller",
"fpath",
":=",
"filepath",
".",
"Join",
"(",
"rPath",
",",
"\"",
"\"",
")",
"\n",
"routerStr",
":=",
"strings",
".",
"Replace",
"(",
"RouterTPL",
",",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"nameSpaces",
",",
"\"",
"\"",
")",
",",
"1",
")",
"\n",
"routerStr",
"=",
"strings",
".",
"Replace",
"(",
"routerStr",
",",
"\"",
"\"",
",",
"pkgPath",
",",
"1",
")",
"\n",
"var",
"f",
"*",
"os",
".",
"File",
"\n",
"var",
"err",
"error",
"\n",
"if",
"utils",
".",
"IsExist",
"(",
"fpath",
")",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"fpath",
")",
"\n",
"if",
"utils",
".",
"AskForConfirmation",
"(",
")",
"{",
"f",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"fpath",
",",
"os",
".",
"O_RDWR",
"|",
"os",
".",
"O_TRUNC",
",",
"0666",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"else",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"fpath",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"else",
"{",
"f",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"fpath",
",",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_RDWR",
",",
"0666",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"f",
".",
"WriteString",
"(",
"routerStr",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"fpath",
",",
"err",
")",
"\n",
"}",
"\n",
"utils",
".",
"CloseFile",
"(",
"f",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\\t",
"\\t",
"\\n",
"\"",
",",
"\"",
"\\x1b",
"\"",
",",
"\"",
"\\x1b",
"\"",
",",
"\"",
"\\x1b",
"\"",
",",
"fpath",
",",
"\"",
"\\x1b",
"\"",
")",
"\n",
"utils",
".",
"FormatSourceCode",
"(",
"fpath",
")",
"\n",
"}"
] | // writeRouterFile generates router file | [
"writeRouterFile",
"generates",
"router",
"file"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/generate/g_appcode.go#L845-L889 | train |
beego/bee | cmd/commands/version/banner.go | InitBanner | func InitBanner(out io.Writer, in io.Reader) {
if in == nil {
beeLogger.Log.Fatal("The input is nil")
}
banner, err := ioutil.ReadAll(in)
if err != nil {
beeLogger.Log.Fatalf("Error while trying to read the banner: %s", err)
}
show(out, string(banner))
} | go | func InitBanner(out io.Writer, in io.Reader) {
if in == nil {
beeLogger.Log.Fatal("The input is nil")
}
banner, err := ioutil.ReadAll(in)
if err != nil {
beeLogger.Log.Fatalf("Error while trying to read the banner: %s", err)
}
show(out, string(banner))
} | [
"func",
"InitBanner",
"(",
"out",
"io",
".",
"Writer",
",",
"in",
"io",
".",
"Reader",
")",
"{",
"if",
"in",
"==",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"banner",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"show",
"(",
"out",
",",
"string",
"(",
"banner",
")",
")",
"\n",
"}"
] | // InitBanner loads the banner and prints it to output
// All errors are ignored, the application will not
// print the banner in case of error. | [
"InitBanner",
"loads",
"the",
"banner",
"and",
"prints",
"it",
"to",
"output",
"All",
"errors",
"are",
"ignored",
"the",
"application",
"will",
"not",
"print",
"the",
"banner",
"in",
"case",
"of",
"error",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/version/banner.go#L31-L42 | train |
beego/bee | cmd/commands/command.go | Out | func (c *Command) Out() io.Writer {
if c.output != nil {
return *c.output
}
return colors.NewColorWriter(os.Stderr)
} | go | func (c *Command) Out() io.Writer {
if c.output != nil {
return *c.output
}
return colors.NewColorWriter(os.Stderr)
} | [
"func",
"(",
"c",
"*",
"Command",
")",
"Out",
"(",
")",
"io",
".",
"Writer",
"{",
"if",
"c",
".",
"output",
"!=",
"nil",
"{",
"return",
"*",
"c",
".",
"output",
"\n",
"}",
"\n",
"return",
"colors",
".",
"NewColorWriter",
"(",
"os",
".",
"Stderr",
")",
"\n",
"}"
] | // Out returns the out writer of the current command.
// If cmd.output is nil, os.Stderr is used. | [
"Out",
"returns",
"the",
"out",
"writer",
"of",
"the",
"current",
"command",
".",
"If",
"cmd",
".",
"output",
"is",
"nil",
"os",
".",
"Stderr",
"is",
"used",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/command.go#L64-L69 | train |
beego/bee | cmd/commands/run/reload.go | readPump | func (c *wsClient) readPump() {
defer func() {
c.broker.unregister <- c
c.conn.Close()
}()
for {
_, _, err := c.conn.ReadMessage()
if err != nil {
if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) {
beeLogger.Log.Errorf("An error happened when reading from the Websocket client: %v", err)
}
break
}
}
} | go | func (c *wsClient) readPump() {
defer func() {
c.broker.unregister <- c
c.conn.Close()
}()
for {
_, _, err := c.conn.ReadMessage()
if err != nil {
if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) {
beeLogger.Log.Errorf("An error happened when reading from the Websocket client: %v", err)
}
break
}
}
} | [
"func",
"(",
"c",
"*",
"wsClient",
")",
"readPump",
"(",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"c",
".",
"broker",
".",
"unregister",
"<-",
"c",
"\n",
"c",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"{",
"_",
",",
"_",
",",
"err",
":=",
"c",
".",
"conn",
".",
"ReadMessage",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"websocket",
".",
"IsUnexpectedCloseError",
"(",
"err",
",",
"websocket",
".",
"CloseGoingAway",
")",
"{",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // readPump pumps messages from the websocket connection to the broker. | [
"readPump",
"pumps",
"messages",
"from",
"the",
"websocket",
"connection",
"to",
"the",
"broker",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/run/reload.go#L64-L79 | train |
beego/bee | cmd/commands/run/reload.go | handleWsRequest | func handleWsRequest(broker *wsBroker, w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
beeLogger.Log.Errorf("error while upgrading server connection: %v", err)
return
}
client := &wsClient{
broker: broker,
conn: conn,
send: make(chan []byte, 256),
}
client.broker.register <- client
go client.writePump()
client.readPump()
} | go | func handleWsRequest(broker *wsBroker, w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
beeLogger.Log.Errorf("error while upgrading server connection: %v", err)
return
}
client := &wsClient{
broker: broker,
conn: conn,
send: make(chan []byte, 256),
}
client.broker.register <- client
go client.writePump()
client.readPump()
} | [
"func",
"handleWsRequest",
"(",
"broker",
"*",
"wsBroker",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"conn",
",",
"err",
":=",
"upgrader",
".",
"Upgrade",
"(",
"w",
",",
"r",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"client",
":=",
"&",
"wsClient",
"{",
"broker",
":",
"broker",
",",
"conn",
":",
"conn",
",",
"send",
":",
"make",
"(",
"chan",
"[",
"]",
"byte",
",",
"256",
")",
",",
"}",
"\n",
"client",
".",
"broker",
".",
"register",
"<-",
"client",
"\n\n",
"go",
"client",
".",
"writePump",
"(",
")",
"\n",
"client",
".",
"readPump",
"(",
")",
"\n",
"}"
] | // handleWsRequest handles websocket requests from the peer. | [
"handleWsRequest",
"handles",
"websocket",
"requests",
"from",
"the",
"peer",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/run/reload.go#L176-L192 | train |
beego/bee | config/conf.go | LoadConfig | func LoadConfig() {
currentPath, err := os.Getwd()
if err != nil {
beeLogger.Log.Error(err.Error())
}
dir, err := os.Open(currentPath)
if err != nil {
beeLogger.Log.Error(err.Error())
}
defer dir.Close()
files, err := dir.Readdir(-1)
if err != nil {
beeLogger.Log.Error(err.Error())
}
for _, file := range files {
switch file.Name() {
case "bee.json":
{
err = parseJSON(filepath.Join(currentPath, file.Name()), &Conf)
if err != nil {
beeLogger.Log.Errorf("Failed to parse JSON file: %s", err)
}
break
}
case "Beefile":
{
err = parseYAML(filepath.Join(currentPath, file.Name()), &Conf)
if err != nil {
beeLogger.Log.Errorf("Failed to parse YAML file: %s", err)
}
break
}
}
}
// Check format version
if Conf.Version != confVer {
beeLogger.Log.Warn("Your configuration file is outdated. Please do consider updating it.")
beeLogger.Log.Hint("Check the latest version of bee's configuration file.")
}
// Set variables
if len(Conf.DirStruct.Controllers) == 0 {
Conf.DirStruct.Controllers = "controllers"
}
if len(Conf.DirStruct.Models) == 0 {
Conf.DirStruct.Models = "models"
}
} | go | func LoadConfig() {
currentPath, err := os.Getwd()
if err != nil {
beeLogger.Log.Error(err.Error())
}
dir, err := os.Open(currentPath)
if err != nil {
beeLogger.Log.Error(err.Error())
}
defer dir.Close()
files, err := dir.Readdir(-1)
if err != nil {
beeLogger.Log.Error(err.Error())
}
for _, file := range files {
switch file.Name() {
case "bee.json":
{
err = parseJSON(filepath.Join(currentPath, file.Name()), &Conf)
if err != nil {
beeLogger.Log.Errorf("Failed to parse JSON file: %s", err)
}
break
}
case "Beefile":
{
err = parseYAML(filepath.Join(currentPath, file.Name()), &Conf)
if err != nil {
beeLogger.Log.Errorf("Failed to parse YAML file: %s", err)
}
break
}
}
}
// Check format version
if Conf.Version != confVer {
beeLogger.Log.Warn("Your configuration file is outdated. Please do consider updating it.")
beeLogger.Log.Hint("Check the latest version of bee's configuration file.")
}
// Set variables
if len(Conf.DirStruct.Controllers) == 0 {
Conf.DirStruct.Controllers = "controllers"
}
if len(Conf.DirStruct.Models) == 0 {
Conf.DirStruct.Models = "models"
}
} | [
"func",
"LoadConfig",
"(",
")",
"{",
"currentPath",
",",
"err",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Error",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"dir",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"currentPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Error",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"defer",
"dir",
".",
"Close",
"(",
")",
"\n\n",
"files",
",",
"err",
":=",
"dir",
".",
"Readdir",
"(",
"-",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Error",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"file",
":=",
"range",
"files",
"{",
"switch",
"file",
".",
"Name",
"(",
")",
"{",
"case",
"\"",
"\"",
":",
"{",
"err",
"=",
"parseJSON",
"(",
"filepath",
".",
"Join",
"(",
"currentPath",
",",
"file",
".",
"Name",
"(",
")",
")",
",",
"&",
"Conf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"{",
"err",
"=",
"parseYAML",
"(",
"filepath",
".",
"Join",
"(",
"currentPath",
",",
"file",
".",
"Name",
"(",
")",
")",
",",
"&",
"Conf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Check format version",
"if",
"Conf",
".",
"Version",
"!=",
"confVer",
"{",
"beeLogger",
".",
"Log",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"beeLogger",
".",
"Log",
".",
"Hint",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Set variables",
"if",
"len",
"(",
"Conf",
".",
"DirStruct",
".",
"Controllers",
")",
"==",
"0",
"{",
"Conf",
".",
"DirStruct",
".",
"Controllers",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"Conf",
".",
"DirStruct",
".",
"Models",
")",
"==",
"0",
"{",
"Conf",
".",
"DirStruct",
".",
"Models",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"}"
] | // LoadConfig loads the bee tool configuration.
// It looks for Beefile or bee.json in the current path,
// and falls back to default configuration in case not found. | [
"LoadConfig",
"loads",
"the",
"bee",
"tool",
"configuration",
".",
"It",
"looks",
"for",
"Beefile",
"or",
"bee",
".",
"json",
"in",
"the",
"current",
"path",
"and",
"falls",
"back",
"to",
"default",
"configuration",
"in",
"case",
"not",
"found",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/config/conf.go#L86-L138 | train |
beego/bee | utils/utils.go | IsInGOPATH | func IsInGOPATH(thePath string) bool {
for _, gopath := range GetGOPATHs() {
if strings.Contains(thePath, filepath.Join(gopath, "src")) {
return true
}
}
return false
} | go | func IsInGOPATH(thePath string) bool {
for _, gopath := range GetGOPATHs() {
if strings.Contains(thePath, filepath.Join(gopath, "src")) {
return true
}
}
return false
} | [
"func",
"IsInGOPATH",
"(",
"thePath",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"gopath",
":=",
"range",
"GetGOPATHs",
"(",
")",
"{",
"if",
"strings",
".",
"Contains",
"(",
"thePath",
",",
"filepath",
".",
"Join",
"(",
"gopath",
",",
"\"",
"\"",
")",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsInGOPATH checks whether the path is inside of any GOPATH or not | [
"IsInGOPATH",
"checks",
"whether",
"the",
"path",
"is",
"inside",
"of",
"any",
"GOPATH",
"or",
"not"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/utils/utils.go#L62-L69 | train |
beego/bee | utils/utils.go | IsBeegoProject | func IsBeegoProject(thePath string) bool {
mainFiles := []string{}
hasBeegoRegex := regexp.MustCompile(`(?s)package main.*?import.*?\(.*?github.com/astaxie/beego".*?\).*func main()`)
c := make(chan error)
// Walk the application path tree to look for main files.
// Main files must satisfy the 'hasBeegoRegex' regular expression.
go func() {
filepath.Walk(thePath, func(fpath string, f os.FileInfo, err error) error {
if err != nil {
return nil
}
// Skip sub-directories
if !f.IsDir() {
var data []byte
data, err = ioutil.ReadFile(fpath)
if err != nil {
c <- err
return nil
}
if len(hasBeegoRegex.Find(data)) > 0 {
mainFiles = append(mainFiles, fpath)
}
}
return nil
})
close(c)
}()
if err := <-c; err != nil {
beeLogger.Log.Fatalf("Unable to walk '%s' tree: %s", thePath, err)
}
if len(mainFiles) > 0 {
return true
}
return false
} | go | func IsBeegoProject(thePath string) bool {
mainFiles := []string{}
hasBeegoRegex := regexp.MustCompile(`(?s)package main.*?import.*?\(.*?github.com/astaxie/beego".*?\).*func main()`)
c := make(chan error)
// Walk the application path tree to look for main files.
// Main files must satisfy the 'hasBeegoRegex' regular expression.
go func() {
filepath.Walk(thePath, func(fpath string, f os.FileInfo, err error) error {
if err != nil {
return nil
}
// Skip sub-directories
if !f.IsDir() {
var data []byte
data, err = ioutil.ReadFile(fpath)
if err != nil {
c <- err
return nil
}
if len(hasBeegoRegex.Find(data)) > 0 {
mainFiles = append(mainFiles, fpath)
}
}
return nil
})
close(c)
}()
if err := <-c; err != nil {
beeLogger.Log.Fatalf("Unable to walk '%s' tree: %s", thePath, err)
}
if len(mainFiles) > 0 {
return true
}
return false
} | [
"func",
"IsBeegoProject",
"(",
"thePath",
"string",
")",
"bool",
"{",
"mainFiles",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"hasBeegoRegex",
":=",
"regexp",
".",
"MustCompile",
"(",
"`(?s)package main.*?import.*?\\(.*?github.com/astaxie/beego\".*?\\).*func main()`",
")",
"\n",
"c",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"// Walk the application path tree to look for main files.",
"// Main files must satisfy the 'hasBeegoRegex' regular expression.",
"go",
"func",
"(",
")",
"{",
"filepath",
".",
"Walk",
"(",
"thePath",
",",
"func",
"(",
"fpath",
"string",
",",
"f",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"error",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"// Skip sub-directories",
"if",
"!",
"f",
".",
"IsDir",
"(",
")",
"{",
"var",
"data",
"[",
"]",
"byte",
"\n",
"data",
",",
"err",
"=",
"ioutil",
".",
"ReadFile",
"(",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
"<-",
"err",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"hasBeegoRegex",
".",
"Find",
"(",
"data",
")",
")",
">",
"0",
"{",
"mainFiles",
"=",
"append",
"(",
"mainFiles",
",",
"fpath",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"close",
"(",
"c",
")",
"\n",
"}",
"(",
")",
"\n\n",
"if",
"err",
":=",
"<-",
"c",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"thePath",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"mainFiles",
")",
">",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsBeegoProject checks whether the current path is a Beego application or not | [
"IsBeegoProject",
"checks",
"whether",
"the",
"current",
"path",
"is",
"a",
"Beego",
"application",
"or",
"not"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/utils/utils.go#L72-L109 | train |
beego/bee | utils/utils.go | SnakeString | func SnakeString(s string) string {
data := make([]byte, 0, len(s)*2)
j := false
num := len(s)
for i := 0; i < num; i++ {
d := s[i]
if i > 0 && d >= 'A' && d <= 'Z' && j {
data = append(data, '_')
}
if d != '_' {
j = true
}
data = append(data, d)
}
return strings.ToLower(string(data[:]))
} | go | func SnakeString(s string) string {
data := make([]byte, 0, len(s)*2)
j := false
num := len(s)
for i := 0; i < num; i++ {
d := s[i]
if i > 0 && d >= 'A' && d <= 'Z' && j {
data = append(data, '_')
}
if d != '_' {
j = true
}
data = append(data, d)
}
return strings.ToLower(string(data[:]))
} | [
"func",
"SnakeString",
"(",
"s",
"string",
")",
"string",
"{",
"data",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"len",
"(",
"s",
")",
"*",
"2",
")",
"\n",
"j",
":=",
"false",
"\n",
"num",
":=",
"len",
"(",
"s",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"num",
";",
"i",
"++",
"{",
"d",
":=",
"s",
"[",
"i",
"]",
"\n",
"if",
"i",
">",
"0",
"&&",
"d",
">=",
"'A'",
"&&",
"d",
"<=",
"'Z'",
"&&",
"j",
"{",
"data",
"=",
"append",
"(",
"data",
",",
"'_'",
")",
"\n",
"}",
"\n",
"if",
"d",
"!=",
"'_'",
"{",
"j",
"=",
"true",
"\n",
"}",
"\n",
"data",
"=",
"append",
"(",
"data",
",",
"d",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"ToLower",
"(",
"string",
"(",
"data",
"[",
":",
"]",
")",
")",
"\n",
"}"
] | // snake string, XxYy to xx_yy | [
"snake",
"string",
"XxYy",
"to",
"xx_yy"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/utils/utils.go#L170-L185 | train |
beego/bee | utils/utils.go | FormatSourceCode | func FormatSourceCode(filename string) {
cmd := exec.Command("gofmt", "-w", filename)
if err := cmd.Run(); err != nil {
beeLogger.Log.Warnf("Error while running gofmt: %s", err)
}
} | go | func FormatSourceCode(filename string) {
cmd := exec.Command("gofmt", "-w", filename)
if err := cmd.Run(); err != nil {
beeLogger.Log.Warnf("Error while running gofmt: %s", err)
}
} | [
"func",
"FormatSourceCode",
"(",
"filename",
"string",
")",
"{",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"filename",
")",
"\n",
"if",
"err",
":=",
"cmd",
".",
"Run",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // formatSourceCode formats source files | [
"formatSourceCode",
"formats",
"source",
"files"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/utils/utils.go#L222-L227 | train |
beego/bee | utils/utils.go | WriteToFile | func WriteToFile(filename, content string) {
f, err := os.Create(filename)
MustCheck(err)
defer CloseFile(f)
_, err = f.WriteString(content)
MustCheck(err)
} | go | func WriteToFile(filename, content string) {
f, err := os.Create(filename)
MustCheck(err)
defer CloseFile(f)
_, err = f.WriteString(content)
MustCheck(err)
} | [
"func",
"WriteToFile",
"(",
"filename",
",",
"content",
"string",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"filename",
")",
"\n",
"MustCheck",
"(",
"err",
")",
"\n",
"defer",
"CloseFile",
"(",
"f",
")",
"\n",
"_",
",",
"err",
"=",
"f",
".",
"WriteString",
"(",
"content",
")",
"\n",
"MustCheck",
"(",
"err",
")",
"\n",
"}"
] | // WriteToFile creates a file and writes content to it | [
"WriteToFile",
"creates",
"a",
"file",
"and",
"writes",
"content",
"to",
"it"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/utils/utils.go#L244-L250 | train |
beego/bee | utils/utils.go | BeeFuncMap | func BeeFuncMap() template.FuncMap {
return template.FuncMap{
"trim": strings.TrimSpace,
"bold": colors.Bold,
"headline": colors.MagentaBold,
"foldername": colors.RedBold,
"endline": EndLine,
"tmpltostr": TmplToString,
}
} | go | func BeeFuncMap() template.FuncMap {
return template.FuncMap{
"trim": strings.TrimSpace,
"bold": colors.Bold,
"headline": colors.MagentaBold,
"foldername": colors.RedBold,
"endline": EndLine,
"tmpltostr": TmplToString,
}
} | [
"func",
"BeeFuncMap",
"(",
")",
"template",
".",
"FuncMap",
"{",
"return",
"template",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"strings",
".",
"TrimSpace",
",",
"\"",
"\"",
":",
"colors",
".",
"Bold",
",",
"\"",
"\"",
":",
"colors",
".",
"MagentaBold",
",",
"\"",
"\"",
":",
"colors",
".",
"RedBold",
",",
"\"",
"\"",
":",
"EndLine",
",",
"\"",
"\"",
":",
"TmplToString",
",",
"}",
"\n",
"}"
] | // BeeFuncMap returns a FuncMap of functions used in different templates. | [
"BeeFuncMap",
"returns",
"a",
"FuncMap",
"of",
"functions",
"used",
"in",
"different",
"templates",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/utils/utils.go#L265-L274 | train |
beego/bee | utils/utils.go | TmplToString | func TmplToString(tmpl string, data interface{}) string {
t := template.New("tmpl").Funcs(BeeFuncMap())
template.Must(t.Parse(tmpl))
var doc bytes.Buffer
err := t.Execute(&doc, data)
MustCheck(err)
return doc.String()
} | go | func TmplToString(tmpl string, data interface{}) string {
t := template.New("tmpl").Funcs(BeeFuncMap())
template.Must(t.Parse(tmpl))
var doc bytes.Buffer
err := t.Execute(&doc, data)
MustCheck(err)
return doc.String()
} | [
"func",
"TmplToString",
"(",
"tmpl",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"string",
"{",
"t",
":=",
"template",
".",
"New",
"(",
"\"",
"\"",
")",
".",
"Funcs",
"(",
"BeeFuncMap",
"(",
")",
")",
"\n",
"template",
".",
"Must",
"(",
"t",
".",
"Parse",
"(",
"tmpl",
")",
")",
"\n\n",
"var",
"doc",
"bytes",
".",
"Buffer",
"\n",
"err",
":=",
"t",
".",
"Execute",
"(",
"&",
"doc",
",",
"data",
")",
"\n",
"MustCheck",
"(",
"err",
")",
"\n\n",
"return",
"doc",
".",
"String",
"(",
")",
"\n",
"}"
] | // TmplToString parses a text template and return the result as a string. | [
"TmplToString",
"parses",
"a",
"text",
"template",
"and",
"return",
"the",
"result",
"as",
"a",
"string",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/utils/utils.go#L277-L286 | train |
beego/bee | utils/utils.go | GetFileModTime | func GetFileModTime(path string) int64 {
path = strings.Replace(path, "\\", "/", -1)
f, err := os.Open(path)
if err != nil {
beeLogger.Log.Errorf("Failed to open file on '%s': %s", path, err)
return time.Now().Unix()
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
beeLogger.Log.Errorf("Failed to get file stats: %s", err)
return time.Now().Unix()
}
return fi.ModTime().Unix()
} | go | func GetFileModTime(path string) int64 {
path = strings.Replace(path, "\\", "/", -1)
f, err := os.Open(path)
if err != nil {
beeLogger.Log.Errorf("Failed to open file on '%s': %s", path, err)
return time.Now().Unix()
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
beeLogger.Log.Errorf("Failed to get file stats: %s", err)
return time.Now().Unix()
}
return fi.ModTime().Unix()
} | [
"func",
"GetFileModTime",
"(",
"path",
"string",
")",
"int64",
"{",
"path",
"=",
"strings",
".",
"Replace",
"(",
"path",
",",
"\"",
"\\\\",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
",",
"err",
")",
"\n",
"return",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"fi",
",",
"err",
":=",
"f",
".",
"Stat",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"fi",
".",
"ModTime",
"(",
")",
".",
"Unix",
"(",
")",
"\n",
"}"
] | // GetFileModTime returns unix timestamp of `os.File.ModTime` for the given path. | [
"GetFileModTime",
"returns",
"unix",
"timestamp",
"of",
"os",
".",
"File",
".",
"ModTime",
"for",
"the",
"given",
"path",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/utils/utils.go#L411-L427 | train |
beego/bee | cmd/commands/migrate/migrate.go | RunMigration | func RunMigration(cmd *commands.Command, args []string) int {
currpath, _ := os.Getwd()
gps := utils.GetGOPATHs()
if len(gps) == 0 {
beeLogger.Log.Fatal("GOPATH environment variable is not set or empty")
}
gopath := gps[0]
beeLogger.Log.Debugf("GOPATH: %s", utils.FILE(), utils.LINE(), gopath)
// Getting command line arguments
if len(args) != 0 {
cmd.Flag.Parse(args[1:])
}
if mDriver == "" {
mDriver = utils.DocValue(config.Conf.Database.Driver)
if mDriver == "" {
mDriver = "mysql"
}
}
if mConn == "" {
mConn = utils.DocValue(config.Conf.Database.Conn)
if mConn == "" {
mConn = "root:@tcp(127.0.0.1:3306)/test"
}
}
if mDir == "" {
mDir = utils.DocValue(config.Conf.Database.Dir)
if mDir == "" {
mDir = utils.DocValue(path.Join(currpath, "database", "migrations"))
}
}
beeLogger.Log.Infof("Using '%s' as 'driver'", mDriver)
//Log sensitive connection information only when DEBUG is set to true.
beeLogger.Log.Debugf("Conn: %s", utils.FILE(), utils.LINE(), mConn)
beeLogger.Log.Infof("Using '%s' as 'dir'", mDir)
driverStr, connStr, dirStr := string(mDriver), string(mConn), string(mDir)
dirRune := []rune(dirStr)
if dirRune[0] != '/' && dirRune[1] != ':' {
dirStr = path.Join(currpath, dirStr)
}
if len(args) == 0 {
// run all outstanding migrations
beeLogger.Log.Info("Running all outstanding migrations")
MigrateUpdate(currpath, driverStr, connStr, dirStr)
} else {
mcmd := args[0]
switch mcmd {
case "rollback":
beeLogger.Log.Info("Rolling back the last migration operation")
MigrateRollback(currpath, driverStr, connStr, dirStr)
case "reset":
beeLogger.Log.Info("Reseting all migrations")
MigrateReset(currpath, driverStr, connStr, dirStr)
case "refresh":
beeLogger.Log.Info("Refreshing all migrations")
MigrateRefresh(currpath, driverStr, connStr, dirStr)
default:
beeLogger.Log.Fatal("Command is missing")
}
}
beeLogger.Log.Success("Migration successful!")
return 0
} | go | func RunMigration(cmd *commands.Command, args []string) int {
currpath, _ := os.Getwd()
gps := utils.GetGOPATHs()
if len(gps) == 0 {
beeLogger.Log.Fatal("GOPATH environment variable is not set or empty")
}
gopath := gps[0]
beeLogger.Log.Debugf("GOPATH: %s", utils.FILE(), utils.LINE(), gopath)
// Getting command line arguments
if len(args) != 0 {
cmd.Flag.Parse(args[1:])
}
if mDriver == "" {
mDriver = utils.DocValue(config.Conf.Database.Driver)
if mDriver == "" {
mDriver = "mysql"
}
}
if mConn == "" {
mConn = utils.DocValue(config.Conf.Database.Conn)
if mConn == "" {
mConn = "root:@tcp(127.0.0.1:3306)/test"
}
}
if mDir == "" {
mDir = utils.DocValue(config.Conf.Database.Dir)
if mDir == "" {
mDir = utils.DocValue(path.Join(currpath, "database", "migrations"))
}
}
beeLogger.Log.Infof("Using '%s' as 'driver'", mDriver)
//Log sensitive connection information only when DEBUG is set to true.
beeLogger.Log.Debugf("Conn: %s", utils.FILE(), utils.LINE(), mConn)
beeLogger.Log.Infof("Using '%s' as 'dir'", mDir)
driverStr, connStr, dirStr := string(mDriver), string(mConn), string(mDir)
dirRune := []rune(dirStr)
if dirRune[0] != '/' && dirRune[1] != ':' {
dirStr = path.Join(currpath, dirStr)
}
if len(args) == 0 {
// run all outstanding migrations
beeLogger.Log.Info("Running all outstanding migrations")
MigrateUpdate(currpath, driverStr, connStr, dirStr)
} else {
mcmd := args[0]
switch mcmd {
case "rollback":
beeLogger.Log.Info("Rolling back the last migration operation")
MigrateRollback(currpath, driverStr, connStr, dirStr)
case "reset":
beeLogger.Log.Info("Reseting all migrations")
MigrateReset(currpath, driverStr, connStr, dirStr)
case "refresh":
beeLogger.Log.Info("Refreshing all migrations")
MigrateRefresh(currpath, driverStr, connStr, dirStr)
default:
beeLogger.Log.Fatal("Command is missing")
}
}
beeLogger.Log.Success("Migration successful!")
return 0
} | [
"func",
"RunMigration",
"(",
"cmd",
"*",
"commands",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"int",
"{",
"currpath",
",",
"_",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n\n",
"gps",
":=",
"utils",
".",
"GetGOPATHs",
"(",
")",
"\n",
"if",
"len",
"(",
"gps",
")",
"==",
"0",
"{",
"beeLogger",
".",
"Log",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"gopath",
":=",
"gps",
"[",
"0",
"]",
"\n\n",
"beeLogger",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"utils",
".",
"FILE",
"(",
")",
",",
"utils",
".",
"LINE",
"(",
")",
",",
"gopath",
")",
"\n\n",
"// Getting command line arguments",
"if",
"len",
"(",
"args",
")",
"!=",
"0",
"{",
"cmd",
".",
"Flag",
".",
"Parse",
"(",
"args",
"[",
"1",
":",
"]",
")",
"\n",
"}",
"\n",
"if",
"mDriver",
"==",
"\"",
"\"",
"{",
"mDriver",
"=",
"utils",
".",
"DocValue",
"(",
"config",
".",
"Conf",
".",
"Database",
".",
"Driver",
")",
"\n",
"if",
"mDriver",
"==",
"\"",
"\"",
"{",
"mDriver",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"mConn",
"==",
"\"",
"\"",
"{",
"mConn",
"=",
"utils",
".",
"DocValue",
"(",
"config",
".",
"Conf",
".",
"Database",
".",
"Conn",
")",
"\n",
"if",
"mConn",
"==",
"\"",
"\"",
"{",
"mConn",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"mDir",
"==",
"\"",
"\"",
"{",
"mDir",
"=",
"utils",
".",
"DocValue",
"(",
"config",
".",
"Conf",
".",
"Database",
".",
"Dir",
")",
"\n",
"if",
"mDir",
"==",
"\"",
"\"",
"{",
"mDir",
"=",
"utils",
".",
"DocValue",
"(",
"path",
".",
"Join",
"(",
"currpath",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"beeLogger",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"mDriver",
")",
"\n",
"//Log sensitive connection information only when DEBUG is set to true.",
"beeLogger",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"utils",
".",
"FILE",
"(",
")",
",",
"utils",
".",
"LINE",
"(",
")",
",",
"mConn",
")",
"\n",
"beeLogger",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"mDir",
")",
"\n",
"driverStr",
",",
"connStr",
",",
"dirStr",
":=",
"string",
"(",
"mDriver",
")",
",",
"string",
"(",
"mConn",
")",
",",
"string",
"(",
"mDir",
")",
"\n\n",
"dirRune",
":=",
"[",
"]",
"rune",
"(",
"dirStr",
")",
"\n\n",
"if",
"dirRune",
"[",
"0",
"]",
"!=",
"'/'",
"&&",
"dirRune",
"[",
"1",
"]",
"!=",
"':'",
"{",
"dirStr",
"=",
"path",
".",
"Join",
"(",
"currpath",
",",
"dirStr",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"args",
")",
"==",
"0",
"{",
"// run all outstanding migrations",
"beeLogger",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"MigrateUpdate",
"(",
"currpath",
",",
"driverStr",
",",
"connStr",
",",
"dirStr",
")",
"\n",
"}",
"else",
"{",
"mcmd",
":=",
"args",
"[",
"0",
"]",
"\n",
"switch",
"mcmd",
"{",
"case",
"\"",
"\"",
":",
"beeLogger",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"MigrateRollback",
"(",
"currpath",
",",
"driverStr",
",",
"connStr",
",",
"dirStr",
")",
"\n",
"case",
"\"",
"\"",
":",
"beeLogger",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"MigrateReset",
"(",
"currpath",
",",
"driverStr",
",",
"connStr",
",",
"dirStr",
")",
"\n",
"case",
"\"",
"\"",
":",
"beeLogger",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"MigrateRefresh",
"(",
"currpath",
",",
"driverStr",
",",
"connStr",
",",
"dirStr",
")",
"\n",
"default",
":",
"beeLogger",
".",
"Log",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"beeLogger",
".",
"Log",
".",
"Success",
"(",
"\"",
"\"",
")",
"\n",
"return",
"0",
"\n",
"}"
] | // runMigration is the entry point for starting a migration | [
"runMigration",
"is",
"the",
"entry",
"point",
"for",
"starting",
"a",
"migration"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L71-L140 | train |
beego/bee | cmd/commands/migrate/migrate.go | migrate | func migrate(goal, currpath, driver, connStr, dir string) {
if dir == "" {
dir = path.Join(currpath, "database", "migrations")
}
postfix := ""
if runtime.GOOS == "windows" {
postfix = ".exe"
}
binary := "m" + postfix
source := binary + ".go"
// Connect to database
db, err := sql.Open(driver, connStr)
if err != nil {
beeLogger.Log.Fatalf("Could not connect to database using '%s': %s", connStr, err)
}
defer db.Close()
checkForSchemaUpdateTable(db, driver)
latestName, latestTime := getLatestMigration(db, goal)
writeMigrationSourceFile(dir, source, driver, connStr, latestTime, latestName, goal)
buildMigrationBinary(dir, binary)
runMigrationBinary(dir, binary)
removeTempFile(dir, source)
removeTempFile(dir, binary)
} | go | func migrate(goal, currpath, driver, connStr, dir string) {
if dir == "" {
dir = path.Join(currpath, "database", "migrations")
}
postfix := ""
if runtime.GOOS == "windows" {
postfix = ".exe"
}
binary := "m" + postfix
source := binary + ".go"
// Connect to database
db, err := sql.Open(driver, connStr)
if err != nil {
beeLogger.Log.Fatalf("Could not connect to database using '%s': %s", connStr, err)
}
defer db.Close()
checkForSchemaUpdateTable(db, driver)
latestName, latestTime := getLatestMigration(db, goal)
writeMigrationSourceFile(dir, source, driver, connStr, latestTime, latestName, goal)
buildMigrationBinary(dir, binary)
runMigrationBinary(dir, binary)
removeTempFile(dir, source)
removeTempFile(dir, binary)
} | [
"func",
"migrate",
"(",
"goal",
",",
"currpath",
",",
"driver",
",",
"connStr",
",",
"dir",
"string",
")",
"{",
"if",
"dir",
"==",
"\"",
"\"",
"{",
"dir",
"=",
"path",
".",
"Join",
"(",
"currpath",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"postfix",
":=",
"\"",
"\"",
"\n",
"if",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"{",
"postfix",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"binary",
":=",
"\"",
"\"",
"+",
"postfix",
"\n",
"source",
":=",
"binary",
"+",
"\"",
"\"",
"\n\n",
"// Connect to database",
"db",
",",
"err",
":=",
"sql",
".",
"Open",
"(",
"driver",
",",
"connStr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"connStr",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"db",
".",
"Close",
"(",
")",
"\n\n",
"checkForSchemaUpdateTable",
"(",
"db",
",",
"driver",
")",
"\n",
"latestName",
",",
"latestTime",
":=",
"getLatestMigration",
"(",
"db",
",",
"goal",
")",
"\n",
"writeMigrationSourceFile",
"(",
"dir",
",",
"source",
",",
"driver",
",",
"connStr",
",",
"latestTime",
",",
"latestName",
",",
"goal",
")",
"\n",
"buildMigrationBinary",
"(",
"dir",
",",
"binary",
")",
"\n",
"runMigrationBinary",
"(",
"dir",
",",
"binary",
")",
"\n",
"removeTempFile",
"(",
"dir",
",",
"source",
")",
"\n",
"removeTempFile",
"(",
"dir",
",",
"binary",
")",
"\n",
"}"
] | // migrate generates source code, build it, and invoke the binary who does the actual migration | [
"migrate",
"generates",
"source",
"code",
"build",
"it",
"and",
"invoke",
"the",
"binary",
"who",
"does",
"the",
"actual",
"migration"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L143-L168 | train |
beego/bee | cmd/commands/migrate/migrate.go | checkForSchemaUpdateTable | func checkForSchemaUpdateTable(db *sql.DB, driver string) {
showTableSQL := showMigrationsTableSQL(driver)
if rows, err := db.Query(showTableSQL); err != nil {
beeLogger.Log.Fatalf("Could not show migrations table: %s", err)
} else if !rows.Next() {
// No migrations table, create new ones
createTableSQL := createMigrationsTableSQL(driver)
beeLogger.Log.Infof("Creating 'migrations' table...")
if _, err := db.Query(createTableSQL); err != nil {
beeLogger.Log.Fatalf("Could not create migrations table: %s", err)
}
}
// Checking that migrations table schema are expected
selectTableSQL := selectMigrationsTableSQL(driver)
if rows, err := db.Query(selectTableSQL); err != nil {
beeLogger.Log.Fatalf("Could not show columns of migrations table: %s", err)
} else {
for rows.Next() {
var fieldBytes, typeBytes, nullBytes, keyBytes, defaultBytes, extraBytes []byte
if err := rows.Scan(&fieldBytes, &typeBytes, &nullBytes, &keyBytes, &defaultBytes, &extraBytes); err != nil {
beeLogger.Log.Fatalf("Could not read column information: %s", err)
}
fieldStr, typeStr, nullStr, keyStr, defaultStr, extraStr :=
string(fieldBytes), string(typeBytes), string(nullBytes), string(keyBytes), string(defaultBytes), string(extraBytes)
if fieldStr == "id_migration" {
if keyStr != "PRI" || extraStr != "auto_increment" {
beeLogger.Log.Hint("Expecting KEY: PRI, EXTRA: auto_increment")
beeLogger.Log.Fatalf("Column migration.id_migration type mismatch: KEY: %s, EXTRA: %s", keyStr, extraStr)
}
} else if fieldStr == "name" {
if !strings.HasPrefix(typeStr, "varchar") || nullStr != "YES" {
beeLogger.Log.Hint("Expecting TYPE: varchar, NULL: YES")
beeLogger.Log.Fatalf("Column migration.name type mismatch: TYPE: %s, NULL: %s", typeStr, nullStr)
}
} else if fieldStr == "created_at" {
if typeStr != "timestamp" || defaultStr != "CURRENT_TIMESTAMP" {
beeLogger.Log.Hint("Expecting TYPE: timestamp, DEFAULT: CURRENT_TIMESTAMP")
beeLogger.Log.Fatalf("Column migration.timestamp type mismatch: TYPE: %s, DEFAULT: %s", typeStr, defaultStr)
}
}
}
}
} | go | func checkForSchemaUpdateTable(db *sql.DB, driver string) {
showTableSQL := showMigrationsTableSQL(driver)
if rows, err := db.Query(showTableSQL); err != nil {
beeLogger.Log.Fatalf("Could not show migrations table: %s", err)
} else if !rows.Next() {
// No migrations table, create new ones
createTableSQL := createMigrationsTableSQL(driver)
beeLogger.Log.Infof("Creating 'migrations' table...")
if _, err := db.Query(createTableSQL); err != nil {
beeLogger.Log.Fatalf("Could not create migrations table: %s", err)
}
}
// Checking that migrations table schema are expected
selectTableSQL := selectMigrationsTableSQL(driver)
if rows, err := db.Query(selectTableSQL); err != nil {
beeLogger.Log.Fatalf("Could not show columns of migrations table: %s", err)
} else {
for rows.Next() {
var fieldBytes, typeBytes, nullBytes, keyBytes, defaultBytes, extraBytes []byte
if err := rows.Scan(&fieldBytes, &typeBytes, &nullBytes, &keyBytes, &defaultBytes, &extraBytes); err != nil {
beeLogger.Log.Fatalf("Could not read column information: %s", err)
}
fieldStr, typeStr, nullStr, keyStr, defaultStr, extraStr :=
string(fieldBytes), string(typeBytes), string(nullBytes), string(keyBytes), string(defaultBytes), string(extraBytes)
if fieldStr == "id_migration" {
if keyStr != "PRI" || extraStr != "auto_increment" {
beeLogger.Log.Hint("Expecting KEY: PRI, EXTRA: auto_increment")
beeLogger.Log.Fatalf("Column migration.id_migration type mismatch: KEY: %s, EXTRA: %s", keyStr, extraStr)
}
} else if fieldStr == "name" {
if !strings.HasPrefix(typeStr, "varchar") || nullStr != "YES" {
beeLogger.Log.Hint("Expecting TYPE: varchar, NULL: YES")
beeLogger.Log.Fatalf("Column migration.name type mismatch: TYPE: %s, NULL: %s", typeStr, nullStr)
}
} else if fieldStr == "created_at" {
if typeStr != "timestamp" || defaultStr != "CURRENT_TIMESTAMP" {
beeLogger.Log.Hint("Expecting TYPE: timestamp, DEFAULT: CURRENT_TIMESTAMP")
beeLogger.Log.Fatalf("Column migration.timestamp type mismatch: TYPE: %s, DEFAULT: %s", typeStr, defaultStr)
}
}
}
}
} | [
"func",
"checkForSchemaUpdateTable",
"(",
"db",
"*",
"sql",
".",
"DB",
",",
"driver",
"string",
")",
"{",
"showTableSQL",
":=",
"showMigrationsTableSQL",
"(",
"driver",
")",
"\n",
"if",
"rows",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"showTableSQL",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"if",
"!",
"rows",
".",
"Next",
"(",
")",
"{",
"// No migrations table, create new ones",
"createTableSQL",
":=",
"createMigrationsTableSQL",
"(",
"driver",
")",
"\n\n",
"beeLogger",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"_",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"createTableSQL",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Checking that migrations table schema are expected",
"selectTableSQL",
":=",
"selectMigrationsTableSQL",
"(",
"driver",
")",
"\n",
"if",
"rows",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"selectTableSQL",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"var",
"fieldBytes",
",",
"typeBytes",
",",
"nullBytes",
",",
"keyBytes",
",",
"defaultBytes",
",",
"extraBytes",
"[",
"]",
"byte",
"\n",
"if",
"err",
":=",
"rows",
".",
"Scan",
"(",
"&",
"fieldBytes",
",",
"&",
"typeBytes",
",",
"&",
"nullBytes",
",",
"&",
"keyBytes",
",",
"&",
"defaultBytes",
",",
"&",
"extraBytes",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"fieldStr",
",",
"typeStr",
",",
"nullStr",
",",
"keyStr",
",",
"defaultStr",
",",
"extraStr",
":=",
"string",
"(",
"fieldBytes",
")",
",",
"string",
"(",
"typeBytes",
")",
",",
"string",
"(",
"nullBytes",
")",
",",
"string",
"(",
"keyBytes",
")",
",",
"string",
"(",
"defaultBytes",
")",
",",
"string",
"(",
"extraBytes",
")",
"\n",
"if",
"fieldStr",
"==",
"\"",
"\"",
"{",
"if",
"keyStr",
"!=",
"\"",
"\"",
"||",
"extraStr",
"!=",
"\"",
"\"",
"{",
"beeLogger",
".",
"Log",
".",
"Hint",
"(",
"\"",
"\"",
")",
"\n",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"keyStr",
",",
"extraStr",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"fieldStr",
"==",
"\"",
"\"",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"typeStr",
",",
"\"",
"\"",
")",
"||",
"nullStr",
"!=",
"\"",
"\"",
"{",
"beeLogger",
".",
"Log",
".",
"Hint",
"(",
"\"",
"\"",
")",
"\n",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"typeStr",
",",
"nullStr",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"fieldStr",
"==",
"\"",
"\"",
"{",
"if",
"typeStr",
"!=",
"\"",
"\"",
"||",
"defaultStr",
"!=",
"\"",
"\"",
"{",
"beeLogger",
".",
"Log",
".",
"Hint",
"(",
"\"",
"\"",
")",
"\n",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"typeStr",
",",
"defaultStr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // checkForSchemaUpdateTable checks the existence of migrations table.
// It checks for the proper table structures and creates the table using MYSQL_MIGRATION_DDL if it does not exist. | [
"checkForSchemaUpdateTable",
"checks",
"the",
"existence",
"of",
"migrations",
"table",
".",
"It",
"checks",
"for",
"the",
"proper",
"table",
"structures",
"and",
"creates",
"the",
"table",
"using",
"MYSQL_MIGRATION_DDL",
"if",
"it",
"does",
"not",
"exist",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L172-L217 | train |
beego/bee | cmd/commands/migrate/migrate.go | writeMigrationSourceFile | func writeMigrationSourceFile(dir, source, driver, connStr string, latestTime int64, latestName string, task string) {
changeDir(dir)
if f, err := os.OpenFile(source, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0666); err != nil {
beeLogger.Log.Fatalf("Could not create file: %s", err)
} else {
content := strings.Replace(MigrationMainTPL, "{{DBDriver}}", driver, -1)
content = strings.Replace(content, "{{DriverRepo}}", driverImportStatement(driver), -1)
content = strings.Replace(content, "{{ConnStr}}", connStr, -1)
content = strings.Replace(content, "{{LatestTime}}", strconv.FormatInt(latestTime, 10), -1)
content = strings.Replace(content, "{{LatestName}}", latestName, -1)
content = strings.Replace(content, "{{Task}}", task, -1)
if _, err := f.WriteString(content); err != nil {
beeLogger.Log.Fatalf("Could not write to file: %s", err)
}
utils.CloseFile(f)
}
} | go | func writeMigrationSourceFile(dir, source, driver, connStr string, latestTime int64, latestName string, task string) {
changeDir(dir)
if f, err := os.OpenFile(source, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0666); err != nil {
beeLogger.Log.Fatalf("Could not create file: %s", err)
} else {
content := strings.Replace(MigrationMainTPL, "{{DBDriver}}", driver, -1)
content = strings.Replace(content, "{{DriverRepo}}", driverImportStatement(driver), -1)
content = strings.Replace(content, "{{ConnStr}}", connStr, -1)
content = strings.Replace(content, "{{LatestTime}}", strconv.FormatInt(latestTime, 10), -1)
content = strings.Replace(content, "{{LatestName}}", latestName, -1)
content = strings.Replace(content, "{{Task}}", task, -1)
if _, err := f.WriteString(content); err != nil {
beeLogger.Log.Fatalf("Could not write to file: %s", err)
}
utils.CloseFile(f)
}
} | [
"func",
"writeMigrationSourceFile",
"(",
"dir",
",",
"source",
",",
"driver",
",",
"connStr",
"string",
",",
"latestTime",
"int64",
",",
"latestName",
"string",
",",
"task",
"string",
")",
"{",
"changeDir",
"(",
"dir",
")",
"\n",
"if",
"f",
",",
"err",
":=",
"os",
".",
"OpenFile",
"(",
"source",
",",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_EXCL",
"|",
"os",
".",
"O_RDWR",
",",
"0666",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"content",
":=",
"strings",
".",
"Replace",
"(",
"MigrationMainTPL",
",",
"\"",
"\"",
",",
"driver",
",",
"-",
"1",
")",
"\n",
"content",
"=",
"strings",
".",
"Replace",
"(",
"content",
",",
"\"",
"\"",
",",
"driverImportStatement",
"(",
"driver",
")",
",",
"-",
"1",
")",
"\n",
"content",
"=",
"strings",
".",
"Replace",
"(",
"content",
",",
"\"",
"\"",
",",
"connStr",
",",
"-",
"1",
")",
"\n",
"content",
"=",
"strings",
".",
"Replace",
"(",
"content",
",",
"\"",
"\"",
",",
"strconv",
".",
"FormatInt",
"(",
"latestTime",
",",
"10",
")",
",",
"-",
"1",
")",
"\n",
"content",
"=",
"strings",
".",
"Replace",
"(",
"content",
",",
"\"",
"\"",
",",
"latestName",
",",
"-",
"1",
")",
"\n",
"content",
"=",
"strings",
".",
"Replace",
"(",
"content",
",",
"\"",
"\"",
",",
"task",
",",
"-",
"1",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"f",
".",
"WriteString",
"(",
"content",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"utils",
".",
"CloseFile",
"(",
"f",
")",
"\n",
"}",
"\n",
"}"
] | // writeMigrationSourceFile create the source file based on MIGRATION_MAIN_TPL | [
"writeMigrationSourceFile",
"create",
"the",
"source",
"file",
"based",
"on",
"MIGRATION_MAIN_TPL"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L291-L307 | train |
beego/bee | cmd/commands/migrate/migrate.go | changeDir | func changeDir(dir string) {
if err := os.Chdir(dir); err != nil {
beeLogger.Log.Fatalf("Could not find migration directory: %s", err)
}
} | go | func changeDir(dir string) {
if err := os.Chdir(dir); err != nil {
beeLogger.Log.Fatalf("Could not find migration directory: %s", err)
}
} | [
"func",
"changeDir",
"(",
"dir",
"string",
")",
"{",
"if",
"err",
":=",
"os",
".",
"Chdir",
"(",
"dir",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // changeDir changes working directory to dir.
// It exits the system when encouter an error | [
"changeDir",
"changes",
"working",
"directory",
"to",
"dir",
".",
"It",
"exits",
"the",
"system",
"when",
"encouter",
"an",
"error"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L339-L343 | train |
beego/bee | cmd/commands/migrate/migrate.go | removeTempFile | func removeTempFile(dir, file string) {
changeDir(dir)
if err := os.Remove(file); err != nil {
beeLogger.Log.Warnf("Could not remove temporary file: %s", err)
}
} | go | func removeTempFile(dir, file string) {
changeDir(dir)
if err := os.Remove(file); err != nil {
beeLogger.Log.Warnf("Could not remove temporary file: %s", err)
}
} | [
"func",
"removeTempFile",
"(",
"dir",
",",
"file",
"string",
")",
"{",
"changeDir",
"(",
"dir",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"Remove",
"(",
"file",
")",
";",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // removeTempFile removes a file in dir | [
"removeTempFile",
"removes",
"a",
"file",
"in",
"dir"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L346-L351 | train |
beego/bee | cmd/commands/migrate/migrate.go | formatShellErrOutput | func formatShellErrOutput(o string) {
for _, line := range strings.Split(o, "\n") {
if line != "" {
beeLogger.Log.Errorf("|> %s", line)
}
}
} | go | func formatShellErrOutput(o string) {
for _, line := range strings.Split(o, "\n") {
if line != "" {
beeLogger.Log.Errorf("|> %s", line)
}
}
} | [
"func",
"formatShellErrOutput",
"(",
"o",
"string",
")",
"{",
"for",
"_",
",",
"line",
":=",
"range",
"strings",
".",
"Split",
"(",
"o",
",",
"\"",
"\\n",
"\"",
")",
"{",
"if",
"line",
"!=",
"\"",
"\"",
"{",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"line",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // formatShellErrOutput formats the error shell output | [
"formatShellErrOutput",
"formats",
"the",
"error",
"shell",
"output"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L354-L360 | train |
beego/bee | cmd/commands/migrate/migrate.go | formatShellOutput | func formatShellOutput(o string) {
for _, line := range strings.Split(o, "\n") {
if line != "" {
beeLogger.Log.Infof("|> %s", line)
}
}
} | go | func formatShellOutput(o string) {
for _, line := range strings.Split(o, "\n") {
if line != "" {
beeLogger.Log.Infof("|> %s", line)
}
}
} | [
"func",
"formatShellOutput",
"(",
"o",
"string",
")",
"{",
"for",
"_",
",",
"line",
":=",
"range",
"strings",
".",
"Split",
"(",
"o",
",",
"\"",
"\\n",
"\"",
")",
"{",
"if",
"line",
"!=",
"\"",
"\"",
"{",
"beeLogger",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"line",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // formatShellOutput formats the normal shell output | [
"formatShellOutput",
"formats",
"the",
"normal",
"shell",
"output"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L363-L369 | train |
beego/bee | cmd/commands/migrate/migrate.go | MigrateUpdate | func MigrateUpdate(currpath, driver, connStr, dir string) {
migrate("upgrade", currpath, driver, connStr, dir)
} | go | func MigrateUpdate(currpath, driver, connStr, dir string) {
migrate("upgrade", currpath, driver, connStr, dir)
} | [
"func",
"MigrateUpdate",
"(",
"currpath",
",",
"driver",
",",
"connStr",
",",
"dir",
"string",
")",
"{",
"migrate",
"(",
"\"",
"\"",
",",
"currpath",
",",
"driver",
",",
"connStr",
",",
"dir",
")",
"\n",
"}"
] | // MigrateUpdate does the schema update | [
"MigrateUpdate",
"does",
"the",
"schema",
"update"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L438-L440 | train |
beego/bee | cmd/commands/migrate/migrate.go | MigrateRollback | func MigrateRollback(currpath, driver, connStr, dir string) {
migrate("rollback", currpath, driver, connStr, dir)
} | go | func MigrateRollback(currpath, driver, connStr, dir string) {
migrate("rollback", currpath, driver, connStr, dir)
} | [
"func",
"MigrateRollback",
"(",
"currpath",
",",
"driver",
",",
"connStr",
",",
"dir",
"string",
")",
"{",
"migrate",
"(",
"\"",
"\"",
",",
"currpath",
",",
"driver",
",",
"connStr",
",",
"dir",
")",
"\n",
"}"
] | // MigrateRollback rolls back the latest migration | [
"MigrateRollback",
"rolls",
"back",
"the",
"latest",
"migration"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L443-L445 | train |
beego/bee | cmd/commands/migrate/migrate.go | MigrateReset | func MigrateReset(currpath, driver, connStr, dir string) {
migrate("reset", currpath, driver, connStr, dir)
} | go | func MigrateReset(currpath, driver, connStr, dir string) {
migrate("reset", currpath, driver, connStr, dir)
} | [
"func",
"MigrateReset",
"(",
"currpath",
",",
"driver",
",",
"connStr",
",",
"dir",
"string",
")",
"{",
"migrate",
"(",
"\"",
"\"",
",",
"currpath",
",",
"driver",
",",
"connStr",
",",
"dir",
")",
"\n",
"}"
] | // MigrateReset rolls back all migrations | [
"MigrateReset",
"rolls",
"back",
"all",
"migrations"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L448-L450 | train |
beego/bee | cmd/commands/migrate/migrate.go | MigrateRefresh | func MigrateRefresh(currpath, driver, connStr, dir string) {
migrate("refresh", currpath, driver, connStr, dir)
} | go | func MigrateRefresh(currpath, driver, connStr, dir string) {
migrate("refresh", currpath, driver, connStr, dir)
} | [
"func",
"MigrateRefresh",
"(",
"currpath",
",",
"driver",
",",
"connStr",
",",
"dir",
"string",
")",
"{",
"migrate",
"(",
"\"",
"\"",
",",
"currpath",
",",
"driver",
",",
"connStr",
",",
"dir",
")",
"\n",
"}"
] | // MigrateRefresh rolls back all migrations and start over again | [
"MigrateRefresh",
"rolls",
"back",
"all",
"migrations",
"and",
"start",
"over",
"again"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/migrate/migrate.go#L453-L455 | train |
beego/bee | cmd/commands/run/run.go | isExcluded | func isExcluded(filePath string) bool {
for _, p := range excludedPaths {
absP, err := path.Abs(p)
if err != nil {
beeLogger.Log.Errorf("Cannot get absolute path of '%s'", p)
continue
}
absFilePath, err := path.Abs(filePath)
if err != nil {
beeLogger.Log.Errorf("Cannot get absolute path of '%s'", filePath)
break
}
if strings.HasPrefix(absFilePath, absP) {
beeLogger.Log.Infof("'%s' is not being watched", filePath)
return true
}
}
return false
} | go | func isExcluded(filePath string) bool {
for _, p := range excludedPaths {
absP, err := path.Abs(p)
if err != nil {
beeLogger.Log.Errorf("Cannot get absolute path of '%s'", p)
continue
}
absFilePath, err := path.Abs(filePath)
if err != nil {
beeLogger.Log.Errorf("Cannot get absolute path of '%s'", filePath)
break
}
if strings.HasPrefix(absFilePath, absP) {
beeLogger.Log.Infof("'%s' is not being watched", filePath)
return true
}
}
return false
} | [
"func",
"isExcluded",
"(",
"filePath",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"excludedPaths",
"{",
"absP",
",",
"err",
":=",
"path",
".",
"Abs",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"p",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"absFilePath",
",",
"err",
":=",
"path",
".",
"Abs",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"filePath",
")",
"\n",
"break",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"absFilePath",
",",
"absP",
")",
"{",
"beeLogger",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"filePath",
")",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // If a file is excluded | [
"If",
"a",
"file",
"is",
"excluded"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/run/run.go#L235-L253 | train |
beego/bee | logger/colors/color.go | NewModeColorWriter | func NewModeColorWriter(w io.Writer, mode outputMode) io.Writer {
if _, ok := w.(*colorWriter); !ok {
return &colorWriter{
w: w,
mode: mode,
}
}
return w
} | go | func NewModeColorWriter(w io.Writer, mode outputMode) io.Writer {
if _, ok := w.(*colorWriter); !ok {
return &colorWriter{
w: w,
mode: mode,
}
}
return w
} | [
"func",
"NewModeColorWriter",
"(",
"w",
"io",
".",
"Writer",
",",
"mode",
"outputMode",
")",
"io",
".",
"Writer",
"{",
"if",
"_",
",",
"ok",
":=",
"w",
".",
"(",
"*",
"colorWriter",
")",
";",
"!",
"ok",
"{",
"return",
"&",
"colorWriter",
"{",
"w",
":",
"w",
",",
"mode",
":",
"mode",
",",
"}",
"\n",
"}",
"\n",
"return",
"w",
"\n",
"}"
] | // NewModeColorWriter create and initializes a new ansiColorWriter
// by specifying the outputMode. | [
"NewModeColorWriter",
"create",
"and",
"initializes",
"a",
"new",
"ansiColorWriter",
"by",
"specifying",
"the",
"outputMode",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/colors/color.go#L46-L54 | train |
beego/bee | cmd/commands/version/version.go | ShowShortVersionBanner | func ShowShortVersionBanner() {
output := colors.NewColorWriter(os.Stdout)
InitBanner(output, bytes.NewBufferString(colors.MagentaBold(shortVersionBanner)))
} | go | func ShowShortVersionBanner() {
output := colors.NewColorWriter(os.Stdout)
InitBanner(output, bytes.NewBufferString(colors.MagentaBold(shortVersionBanner)))
} | [
"func",
"ShowShortVersionBanner",
"(",
")",
"{",
"output",
":=",
"colors",
".",
"NewColorWriter",
"(",
"os",
".",
"Stdout",
")",
"\n",
"InitBanner",
"(",
"output",
",",
"bytes",
".",
"NewBufferString",
"(",
"colors",
".",
"MagentaBold",
"(",
"shortVersionBanner",
")",
")",
")",
"\n",
"}"
] | // ShowShortVersionBanner prints the short version banner. | [
"ShowShortVersionBanner",
"prints",
"the",
"short",
"version",
"banner",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/version/version.go#L115-L118 | train |
beego/bee | cmd/commands/run/watch.go | NewWatcher | func NewWatcher(paths []string, files []string, isgenerate bool) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
beeLogger.Log.Fatalf("Failed to create watcher: %s", err)
}
go func() {
for {
select {
case e := <-watcher.Events:
isBuild := true
if ifStaticFile(e.Name) && config.Conf.EnableReload {
sendReload(e.String())
continue
}
// Skip ignored files
if shouldIgnoreFile(e.Name) {
continue
}
if !shouldWatchFileWithExtension(e.Name) {
continue
}
mt := utils.GetFileModTime(e.Name)
if t := eventTime[e.Name]; mt == t {
beeLogger.Log.Hintf(colors.Bold("Skipping: ")+"%s", e.String())
isBuild = false
}
eventTime[e.Name] = mt
if isBuild {
beeLogger.Log.Hintf("Event fired: %s", e)
go func() {
// Wait 1s before autobuild until there is no file change.
scheduleTime = time.Now().Add(1 * time.Second)
time.Sleep(time.Until(scheduleTime))
AutoBuild(files, isgenerate)
if config.Conf.EnableReload {
// Wait 100ms more before refreshing the browser
time.Sleep(100 * time.Millisecond)
sendReload(e.String())
}
}()
}
case err := <-watcher.Errors:
beeLogger.Log.Warnf("Watcher error: %s", err.Error()) // No need to exit here
}
}
}()
beeLogger.Log.Info("Initializing watcher...")
for _, path := range paths {
beeLogger.Log.Hintf(colors.Bold("Watching: ")+"%s", path)
err = watcher.Add(path)
if err != nil {
beeLogger.Log.Fatalf("Failed to watch directory: %s", err)
}
}
} | go | func NewWatcher(paths []string, files []string, isgenerate bool) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
beeLogger.Log.Fatalf("Failed to create watcher: %s", err)
}
go func() {
for {
select {
case e := <-watcher.Events:
isBuild := true
if ifStaticFile(e.Name) && config.Conf.EnableReload {
sendReload(e.String())
continue
}
// Skip ignored files
if shouldIgnoreFile(e.Name) {
continue
}
if !shouldWatchFileWithExtension(e.Name) {
continue
}
mt := utils.GetFileModTime(e.Name)
if t := eventTime[e.Name]; mt == t {
beeLogger.Log.Hintf(colors.Bold("Skipping: ")+"%s", e.String())
isBuild = false
}
eventTime[e.Name] = mt
if isBuild {
beeLogger.Log.Hintf("Event fired: %s", e)
go func() {
// Wait 1s before autobuild until there is no file change.
scheduleTime = time.Now().Add(1 * time.Second)
time.Sleep(time.Until(scheduleTime))
AutoBuild(files, isgenerate)
if config.Conf.EnableReload {
// Wait 100ms more before refreshing the browser
time.Sleep(100 * time.Millisecond)
sendReload(e.String())
}
}()
}
case err := <-watcher.Errors:
beeLogger.Log.Warnf("Watcher error: %s", err.Error()) // No need to exit here
}
}
}()
beeLogger.Log.Info("Initializing watcher...")
for _, path := range paths {
beeLogger.Log.Hintf(colors.Bold("Watching: ")+"%s", path)
err = watcher.Add(path)
if err != nil {
beeLogger.Log.Fatalf("Failed to watch directory: %s", err)
}
}
} | [
"func",
"NewWatcher",
"(",
"paths",
"[",
"]",
"string",
",",
"files",
"[",
"]",
"string",
",",
"isgenerate",
"bool",
")",
"{",
"watcher",
",",
"err",
":=",
"fsnotify",
".",
"NewWatcher",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"select",
"{",
"case",
"e",
":=",
"<-",
"watcher",
".",
"Events",
":",
"isBuild",
":=",
"true",
"\n\n",
"if",
"ifStaticFile",
"(",
"e",
".",
"Name",
")",
"&&",
"config",
".",
"Conf",
".",
"EnableReload",
"{",
"sendReload",
"(",
"e",
".",
"String",
"(",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"// Skip ignored files",
"if",
"shouldIgnoreFile",
"(",
"e",
".",
"Name",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"shouldWatchFileWithExtension",
"(",
"e",
".",
"Name",
")",
"{",
"continue",
"\n",
"}",
"\n\n",
"mt",
":=",
"utils",
".",
"GetFileModTime",
"(",
"e",
".",
"Name",
")",
"\n",
"if",
"t",
":=",
"eventTime",
"[",
"e",
".",
"Name",
"]",
";",
"mt",
"==",
"t",
"{",
"beeLogger",
".",
"Log",
".",
"Hintf",
"(",
"colors",
".",
"Bold",
"(",
"\"",
"\"",
")",
"+",
"\"",
"\"",
",",
"e",
".",
"String",
"(",
")",
")",
"\n",
"isBuild",
"=",
"false",
"\n",
"}",
"\n\n",
"eventTime",
"[",
"e",
".",
"Name",
"]",
"=",
"mt",
"\n\n",
"if",
"isBuild",
"{",
"beeLogger",
".",
"Log",
".",
"Hintf",
"(",
"\"",
"\"",
",",
"e",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"// Wait 1s before autobuild until there is no file change.",
"scheduleTime",
"=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"1",
"*",
"time",
".",
"Second",
")",
"\n",
"time",
".",
"Sleep",
"(",
"time",
".",
"Until",
"(",
"scheduleTime",
")",
")",
"\n",
"AutoBuild",
"(",
"files",
",",
"isgenerate",
")",
"\n\n",
"if",
"config",
".",
"Conf",
".",
"EnableReload",
"{",
"// Wait 100ms more before refreshing the browser",
"time",
".",
"Sleep",
"(",
"100",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"sendReload",
"(",
"e",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"case",
"err",
":=",
"<-",
"watcher",
".",
"Errors",
":",
"beeLogger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"// No need to exit here",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"beeLogger",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"path",
":=",
"range",
"paths",
"{",
"beeLogger",
".",
"Log",
".",
"Hintf",
"(",
"colors",
".",
"Bold",
"(",
"\"",
"\"",
")",
"+",
"\"",
"\"",
",",
"path",
")",
"\n",
"err",
"=",
"watcher",
".",
"Add",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // NewWatcher starts an fsnotify Watcher on the specified paths | [
"NewWatcher",
"starts",
"an",
"fsnotify",
"Watcher",
"on",
"the",
"specified",
"paths"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/run/watch.go#L51-L112 | train |
beego/bee | cmd/commands/run/watch.go | AutoBuild | func AutoBuild(files []string, isgenerate bool) {
state.Lock()
defer state.Unlock()
os.Chdir(currpath)
cmdName := "go"
var (
err error
stderr bytes.Buffer
)
// For applications use full import path like "github.com/.../.."
// are able to use "go install" to reduce build time.
if config.Conf.GoInstall {
icmd := exec.Command(cmdName, "install", "-v")
icmd.Stdout = os.Stdout
icmd.Stderr = os.Stderr
icmd.Env = append(os.Environ(), "GOGC=off")
icmd.Run()
}
if isgenerate {
beeLogger.Log.Info("Generating the docs...")
icmd := exec.Command("bee", "generate", "docs")
icmd.Env = append(os.Environ(), "GOGC=off")
err = icmd.Run()
if err != nil {
utils.Notify("", "Failed to generate the docs.")
beeLogger.Log.Errorf("Failed to generate the docs.")
return
}
beeLogger.Log.Success("Docs generated!")
}
appName := appname
if err == nil {
if runtime.GOOS == "windows" {
appName += ".exe"
}
args := []string{"build"}
args = append(args, "-o", appName)
if buildTags != "" {
args = append(args, "-tags", buildTags)
}
args = append(args, files...)
bcmd := exec.Command(cmdName, args...)
bcmd.Env = append(os.Environ(), "GOGC=off")
bcmd.Stderr = &stderr
err = bcmd.Run()
if err != nil {
utils.Notify(stderr.String(), "Build Failed")
beeLogger.Log.Errorf("Failed to build the application: %s", stderr.String())
return
}
}
beeLogger.Log.Success("Built Successfully!")
Restart(appName)
} | go | func AutoBuild(files []string, isgenerate bool) {
state.Lock()
defer state.Unlock()
os.Chdir(currpath)
cmdName := "go"
var (
err error
stderr bytes.Buffer
)
// For applications use full import path like "github.com/.../.."
// are able to use "go install" to reduce build time.
if config.Conf.GoInstall {
icmd := exec.Command(cmdName, "install", "-v")
icmd.Stdout = os.Stdout
icmd.Stderr = os.Stderr
icmd.Env = append(os.Environ(), "GOGC=off")
icmd.Run()
}
if isgenerate {
beeLogger.Log.Info("Generating the docs...")
icmd := exec.Command("bee", "generate", "docs")
icmd.Env = append(os.Environ(), "GOGC=off")
err = icmd.Run()
if err != nil {
utils.Notify("", "Failed to generate the docs.")
beeLogger.Log.Errorf("Failed to generate the docs.")
return
}
beeLogger.Log.Success("Docs generated!")
}
appName := appname
if err == nil {
if runtime.GOOS == "windows" {
appName += ".exe"
}
args := []string{"build"}
args = append(args, "-o", appName)
if buildTags != "" {
args = append(args, "-tags", buildTags)
}
args = append(args, files...)
bcmd := exec.Command(cmdName, args...)
bcmd.Env = append(os.Environ(), "GOGC=off")
bcmd.Stderr = &stderr
err = bcmd.Run()
if err != nil {
utils.Notify(stderr.String(), "Build Failed")
beeLogger.Log.Errorf("Failed to build the application: %s", stderr.String())
return
}
}
beeLogger.Log.Success("Built Successfully!")
Restart(appName)
} | [
"func",
"AutoBuild",
"(",
"files",
"[",
"]",
"string",
",",
"isgenerate",
"bool",
")",
"{",
"state",
".",
"Lock",
"(",
")",
"\n",
"defer",
"state",
".",
"Unlock",
"(",
")",
"\n\n",
"os",
".",
"Chdir",
"(",
"currpath",
")",
"\n\n",
"cmdName",
":=",
"\"",
"\"",
"\n\n",
"var",
"(",
"err",
"error",
"\n",
"stderr",
"bytes",
".",
"Buffer",
"\n",
")",
"\n",
"// For applications use full import path like \"github.com/.../..\"",
"// are able to use \"go install\" to reduce build time.",
"if",
"config",
".",
"Conf",
".",
"GoInstall",
"{",
"icmd",
":=",
"exec",
".",
"Command",
"(",
"cmdName",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"icmd",
".",
"Stdout",
"=",
"os",
".",
"Stdout",
"\n",
"icmd",
".",
"Stderr",
"=",
"os",
".",
"Stderr",
"\n",
"icmd",
".",
"Env",
"=",
"append",
"(",
"os",
".",
"Environ",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"icmd",
".",
"Run",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"isgenerate",
"{",
"beeLogger",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"icmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"icmd",
".",
"Env",
"=",
"append",
"(",
"os",
".",
"Environ",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"err",
"=",
"icmd",
".",
"Run",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"Notify",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"beeLogger",
".",
"Log",
".",
"Success",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"appName",
":=",
"appname",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"{",
"appName",
"+=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"args",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
",",
"appName",
")",
"\n",
"if",
"buildTags",
"!=",
"\"",
"\"",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
",",
"buildTags",
")",
"\n",
"}",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"files",
"...",
")",
"\n\n",
"bcmd",
":=",
"exec",
".",
"Command",
"(",
"cmdName",
",",
"args",
"...",
")",
"\n",
"bcmd",
".",
"Env",
"=",
"append",
"(",
"os",
".",
"Environ",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"bcmd",
".",
"Stderr",
"=",
"&",
"stderr",
"\n",
"err",
"=",
"bcmd",
".",
"Run",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"Notify",
"(",
"stderr",
".",
"String",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"stderr",
".",
"String",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"beeLogger",
".",
"Log",
".",
"Success",
"(",
"\"",
"\"",
")",
"\n",
"Restart",
"(",
"appName",
")",
"\n",
"}"
] | // AutoBuild builds the specified set of files | [
"AutoBuild",
"builds",
"the",
"specified",
"set",
"of",
"files"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/run/watch.go#L115-L176 | train |
beego/bee | cmd/commands/run/watch.go | Kill | func Kill() {
defer func() {
if e := recover(); e != nil {
beeLogger.Log.Infof("Kill recover: %s", e)
}
}()
if cmd != nil && cmd.Process != nil {
// Windows does not support Interrupt
if runtime.GOOS == "windows" {
cmd.Process.Signal(os.Kill)
} else {
cmd.Process.Signal(os.Interrupt)
}
ch := make(chan struct{}, 1)
go func() {
cmd.Wait()
ch <- struct{}{}
}()
select {
case <-ch:
return
case <-time.After(10 * time.Second):
beeLogger.Log.Info("Timeout. Force kill cmd process")
err := cmd.Process.Kill()
if err != nil {
beeLogger.Log.Errorf("Error while killing cmd process: %s", err)
}
return
}
}
} | go | func Kill() {
defer func() {
if e := recover(); e != nil {
beeLogger.Log.Infof("Kill recover: %s", e)
}
}()
if cmd != nil && cmd.Process != nil {
// Windows does not support Interrupt
if runtime.GOOS == "windows" {
cmd.Process.Signal(os.Kill)
} else {
cmd.Process.Signal(os.Interrupt)
}
ch := make(chan struct{}, 1)
go func() {
cmd.Wait()
ch <- struct{}{}
}()
select {
case <-ch:
return
case <-time.After(10 * time.Second):
beeLogger.Log.Info("Timeout. Force kill cmd process")
err := cmd.Process.Kill()
if err != nil {
beeLogger.Log.Errorf("Error while killing cmd process: %s", err)
}
return
}
}
} | [
"func",
"Kill",
"(",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"e",
":=",
"recover",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"e",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"if",
"cmd",
"!=",
"nil",
"&&",
"cmd",
".",
"Process",
"!=",
"nil",
"{",
"// Windows does not support Interrupt",
"if",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"{",
"cmd",
".",
"Process",
".",
"Signal",
"(",
"os",
".",
"Kill",
")",
"\n",
"}",
"else",
"{",
"cmd",
".",
"Process",
".",
"Signal",
"(",
"os",
".",
"Interrupt",
")",
"\n",
"}",
"\n\n",
"ch",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"cmd",
".",
"Wait",
"(",
")",
"\n",
"ch",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"select",
"{",
"case",
"<-",
"ch",
":",
"return",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"10",
"*",
"time",
".",
"Second",
")",
":",
"beeLogger",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"err",
":=",
"cmd",
".",
"Process",
".",
"Kill",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Kill kills the running command process | [
"Kill",
"kills",
"the",
"running",
"command",
"process"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/run/watch.go#L179-L211 | train |
beego/bee | cmd/commands/run/watch.go | Restart | func Restart(appname string) {
beeLogger.Log.Debugf("Kill running process", utils.FILE(), utils.LINE())
Kill()
go Start(appname)
} | go | func Restart(appname string) {
beeLogger.Log.Debugf("Kill running process", utils.FILE(), utils.LINE())
Kill()
go Start(appname)
} | [
"func",
"Restart",
"(",
"appname",
"string",
")",
"{",
"beeLogger",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"utils",
".",
"FILE",
"(",
")",
",",
"utils",
".",
"LINE",
"(",
")",
")",
"\n",
"Kill",
"(",
")",
"\n",
"go",
"Start",
"(",
"appname",
")",
"\n",
"}"
] | // Restart kills the running command process and starts it again | [
"Restart",
"kills",
"the",
"running",
"command",
"process",
"and",
"starts",
"it",
"again"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/run/watch.go#L214-L218 | train |
beego/bee | cmd/commands/run/watch.go | Start | func Start(appname string) {
beeLogger.Log.Infof("Restarting '%s'...", appname)
if !strings.Contains(appname, "./") {
appname = "./" + appname
}
cmd = exec.Command(appname)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if runargs != "" {
r := regexp.MustCompile("'.+'|\".+\"|\\S+")
m := r.FindAllString(runargs, -1)
cmd.Args = append([]string{appname}, m...)
} else {
cmd.Args = append([]string{appname}, config.Conf.CmdArgs...)
}
cmd.Env = append(os.Environ(), config.Conf.Envs...)
go cmd.Run()
beeLogger.Log.Successf("'%s' is running...", appname)
started <- true
} | go | func Start(appname string) {
beeLogger.Log.Infof("Restarting '%s'...", appname)
if !strings.Contains(appname, "./") {
appname = "./" + appname
}
cmd = exec.Command(appname)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if runargs != "" {
r := regexp.MustCompile("'.+'|\".+\"|\\S+")
m := r.FindAllString(runargs, -1)
cmd.Args = append([]string{appname}, m...)
} else {
cmd.Args = append([]string{appname}, config.Conf.CmdArgs...)
}
cmd.Env = append(os.Environ(), config.Conf.Envs...)
go cmd.Run()
beeLogger.Log.Successf("'%s' is running...", appname)
started <- true
} | [
"func",
"Start",
"(",
"appname",
"string",
")",
"{",
"beeLogger",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"appname",
")",
"\n",
"if",
"!",
"strings",
".",
"Contains",
"(",
"appname",
",",
"\"",
"\"",
")",
"{",
"appname",
"=",
"\"",
"\"",
"+",
"appname",
"\n",
"}",
"\n\n",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"appname",
")",
"\n",
"cmd",
".",
"Stdout",
"=",
"os",
".",
"Stdout",
"\n",
"cmd",
".",
"Stderr",
"=",
"os",
".",
"Stderr",
"\n",
"if",
"runargs",
"!=",
"\"",
"\"",
"{",
"r",
":=",
"regexp",
".",
"MustCompile",
"(",
"\"",
"\\\"",
"\\\"",
"\\\\",
"\"",
")",
"\n",
"m",
":=",
"r",
".",
"FindAllString",
"(",
"runargs",
",",
"-",
"1",
")",
"\n",
"cmd",
".",
"Args",
"=",
"append",
"(",
"[",
"]",
"string",
"{",
"appname",
"}",
",",
"m",
"...",
")",
"\n",
"}",
"else",
"{",
"cmd",
".",
"Args",
"=",
"append",
"(",
"[",
"]",
"string",
"{",
"appname",
"}",
",",
"config",
".",
"Conf",
".",
"CmdArgs",
"...",
")",
"\n",
"}",
"\n",
"cmd",
".",
"Env",
"=",
"append",
"(",
"os",
".",
"Environ",
"(",
")",
",",
"config",
".",
"Conf",
".",
"Envs",
"...",
")",
"\n\n",
"go",
"cmd",
".",
"Run",
"(",
")",
"\n",
"beeLogger",
".",
"Log",
".",
"Successf",
"(",
"\"",
"\"",
",",
"appname",
")",
"\n",
"started",
"<-",
"true",
"\n",
"}"
] | // Start starts the command process | [
"Start",
"starts",
"the",
"command",
"process"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/run/watch.go#L221-L242 | train |
beego/bee | cmd/commands/run/watch.go | shouldIgnoreFile | func shouldIgnoreFile(filename string) bool {
for _, regex := range ignoredFilesRegExps {
r, err := regexp.Compile(regex)
if err != nil {
beeLogger.Log.Fatalf("Could not compile regular expression: %s", err)
}
if r.MatchString(filename) {
return true
}
continue
}
return false
} | go | func shouldIgnoreFile(filename string) bool {
for _, regex := range ignoredFilesRegExps {
r, err := regexp.Compile(regex)
if err != nil {
beeLogger.Log.Fatalf("Could not compile regular expression: %s", err)
}
if r.MatchString(filename) {
return true
}
continue
}
return false
} | [
"func",
"shouldIgnoreFile",
"(",
"filename",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"regex",
":=",
"range",
"ignoredFilesRegExps",
"{",
"r",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"regex",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"beeLogger",
".",
"Log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"MatchString",
"(",
"filename",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // shouldIgnoreFile ignores filenames generated by Emacs, Vim or SublimeText.
// It returns true if the file should be ignored, false otherwise. | [
"shouldIgnoreFile",
"ignores",
"filenames",
"generated",
"by",
"Emacs",
"Vim",
"or",
"SublimeText",
".",
"It",
"returns",
"true",
"if",
"the",
"file",
"should",
"be",
"ignored",
"false",
"otherwise",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/run/watch.go#L255-L267 | train |
beego/bee | cmd/commands/run/watch.go | shouldWatchFileWithExtension | func shouldWatchFileWithExtension(name string) bool {
for _, s := range watchExts {
if strings.HasSuffix(name, s) {
return true
}
}
return false
} | go | func shouldWatchFileWithExtension(name string) bool {
for _, s := range watchExts {
if strings.HasSuffix(name, s) {
return true
}
}
return false
} | [
"func",
"shouldWatchFileWithExtension",
"(",
"name",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"watchExts",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"name",
",",
"s",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // shouldWatchFileWithExtension returns true if the name of the file
// hash a suffix that should be watched. | [
"shouldWatchFileWithExtension",
"returns",
"true",
"if",
"the",
"name",
"of",
"the",
"file",
"hash",
"a",
"suffix",
"that",
"should",
"be",
"watched",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/cmd/commands/run/watch.go#L271-L278 | train |
beego/bee | logger/logger.go | GetBeeLogger | func GetBeeLogger(w io.Writer) *BeeLogger {
once.Do(func() {
var (
err error
simpleLogFormat = `{{Now "2006/01/02 15:04:05"}} {{.Level}} ▶ {{.ID}} {{.Message}}{{EndLine}}`
debugLogFormat = `{{Now "2006/01/02 15:04:05"}} {{.Level}} ▶ {{.ID}} {{.Filename}}:{{.LineNo}} {{.Message}}{{EndLine}}`
)
// Initialize and parse logging templates
funcs := template.FuncMap{
"Now": Now,
"EndLine": EndLine,
}
logRecordTemplate, err = template.New("simpleLogFormat").Funcs(funcs).Parse(simpleLogFormat)
if err != nil {
panic(err)
}
debugLogRecordTemplate, err = template.New("debugLogFormat").Funcs(funcs).Parse(debugLogFormat)
if err != nil {
panic(err)
}
instance = &BeeLogger{output: colors.NewColorWriter(w)}
})
return instance
} | go | func GetBeeLogger(w io.Writer) *BeeLogger {
once.Do(func() {
var (
err error
simpleLogFormat = `{{Now "2006/01/02 15:04:05"}} {{.Level}} ▶ {{.ID}} {{.Message}}{{EndLine}}`
debugLogFormat = `{{Now "2006/01/02 15:04:05"}} {{.Level}} ▶ {{.ID}} {{.Filename}}:{{.LineNo}} {{.Message}}{{EndLine}}`
)
// Initialize and parse logging templates
funcs := template.FuncMap{
"Now": Now,
"EndLine": EndLine,
}
logRecordTemplate, err = template.New("simpleLogFormat").Funcs(funcs).Parse(simpleLogFormat)
if err != nil {
panic(err)
}
debugLogRecordTemplate, err = template.New("debugLogFormat").Funcs(funcs).Parse(debugLogFormat)
if err != nil {
panic(err)
}
instance = &BeeLogger{output: colors.NewColorWriter(w)}
})
return instance
} | [
"func",
"GetBeeLogger",
"(",
"w",
"io",
".",
"Writer",
")",
"*",
"BeeLogger",
"{",
"once",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"var",
"(",
"err",
"error",
"\n",
"simpleLogFormat",
"=",
"`{{Now \"2006/01/02 15:04:05\"}} {{.Level}} ▶ {{.ID}} {{.Message}}{{EndLine}}`",
"\n",
"debugLogFormat",
"=",
"`{{Now \"2006/01/02 15:04:05\"}} {{.Level}} ▶ {{.ID}} {{.Filename}}:{{.LineNo}} {{.Message}}{{EndLine}}`",
"\n",
")",
"\n\n",
"// Initialize and parse logging templates",
"funcs",
":=",
"template",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"Now",
",",
"\"",
"\"",
":",
"EndLine",
",",
"}",
"\n",
"logRecordTemplate",
",",
"err",
"=",
"template",
".",
"New",
"(",
"\"",
"\"",
")",
".",
"Funcs",
"(",
"funcs",
")",
".",
"Parse",
"(",
"simpleLogFormat",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"debugLogRecordTemplate",
",",
"err",
"=",
"template",
".",
"New",
"(",
"\"",
"\"",
")",
".",
"Funcs",
"(",
"funcs",
")",
".",
"Parse",
"(",
"debugLogFormat",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"instance",
"=",
"&",
"BeeLogger",
"{",
"output",
":",
"colors",
".",
"NewColorWriter",
"(",
"w",
")",
"}",
"\n",
"}",
")",
"\n",
"return",
"instance",
"\n",
"}"
] | // GetBeeLogger initializes the logger instance with a NewColorWriter output
// and returns a singleton | [
"GetBeeLogger",
"initializes",
"the",
"logger",
"instance",
"with",
"a",
"NewColorWriter",
"output",
"and",
"returns",
"a",
"singleton"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L77-L102 | train |
beego/bee | logger/logger.go | SetOutput | func (l *BeeLogger) SetOutput(w io.Writer) {
l.mu.Lock()
defer l.mu.Unlock()
l.output = colors.NewColorWriter(w)
} | go | func (l *BeeLogger) SetOutput(w io.Writer) {
l.mu.Lock()
defer l.mu.Unlock()
l.output = colors.NewColorWriter(w)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"SetOutput",
"(",
"w",
"io",
".",
"Writer",
")",
"{",
"l",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"l",
".",
"output",
"=",
"colors",
".",
"NewColorWriter",
"(",
"w",
")",
"\n",
"}"
] | // SetOutput sets the logger output destination | [
"SetOutput",
"sets",
"the",
"logger",
"output",
"destination"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L105-L109 | train |
beego/bee | logger/logger.go | mustLog | func (l *BeeLogger) mustLog(level int, message string, args ...interface{}) {
if level > logLevel {
return
}
// Acquire the lock
l.mu.Lock()
defer l.mu.Unlock()
// Create the logging record and pass into the output
record := LogRecord{
ID: fmt.Sprintf("%04d", atomic.AddUint64(&sequenceNo, 1)),
Level: l.getColorLevel(level),
Message: fmt.Sprintf(message, args...),
}
err := logRecordTemplate.Execute(l.output, record)
if err != nil {
panic(err)
}
} | go | func (l *BeeLogger) mustLog(level int, message string, args ...interface{}) {
if level > logLevel {
return
}
// Acquire the lock
l.mu.Lock()
defer l.mu.Unlock()
// Create the logging record and pass into the output
record := LogRecord{
ID: fmt.Sprintf("%04d", atomic.AddUint64(&sequenceNo, 1)),
Level: l.getColorLevel(level),
Message: fmt.Sprintf(message, args...),
}
err := logRecordTemplate.Execute(l.output, record)
if err != nil {
panic(err)
}
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"mustLog",
"(",
"level",
"int",
",",
"message",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"level",
">",
"logLevel",
"{",
"return",
"\n",
"}",
"\n",
"// Acquire the lock",
"l",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"// Create the logging record and pass into the output",
"record",
":=",
"LogRecord",
"{",
"ID",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"atomic",
".",
"AddUint64",
"(",
"&",
"sequenceNo",
",",
"1",
")",
")",
",",
"Level",
":",
"l",
".",
"getColorLevel",
"(",
"level",
")",
",",
"Message",
":",
"fmt",
".",
"Sprintf",
"(",
"message",
",",
"args",
"...",
")",
",",
"}",
"\n\n",
"err",
":=",
"logRecordTemplate",
".",
"Execute",
"(",
"l",
".",
"output",
",",
"record",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // mustLog logs the message according to the specified level and arguments.
// It panics in case of an error. | [
"mustLog",
"logs",
"the",
"message",
"according",
"to",
"the",
"specified",
"level",
"and",
"arguments",
".",
"It",
"panics",
"in",
"case",
"of",
"an",
"error",
"."
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L169-L188 | train |
beego/bee | logger/logger.go | mustLogDebug | func (l *BeeLogger) mustLogDebug(message string, file string, line int, args ...interface{}) {
if !debugMode {
return
}
// Change the output to Stderr
l.SetOutput(os.Stderr)
// Create the log record
record := LogRecord{
ID: fmt.Sprintf("%04d", atomic.AddUint64(&sequenceNo, 1)),
Level: l.getColorLevel(levelDebug),
Message: fmt.Sprintf(message, args...),
LineNo: line,
Filename: filepath.Base(file),
}
err := debugLogRecordTemplate.Execute(l.output, record)
if err != nil {
panic(err)
}
} | go | func (l *BeeLogger) mustLogDebug(message string, file string, line int, args ...interface{}) {
if !debugMode {
return
}
// Change the output to Stderr
l.SetOutput(os.Stderr)
// Create the log record
record := LogRecord{
ID: fmt.Sprintf("%04d", atomic.AddUint64(&sequenceNo, 1)),
Level: l.getColorLevel(levelDebug),
Message: fmt.Sprintf(message, args...),
LineNo: line,
Filename: filepath.Base(file),
}
err := debugLogRecordTemplate.Execute(l.output, record)
if err != nil {
panic(err)
}
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"mustLogDebug",
"(",
"message",
"string",
",",
"file",
"string",
",",
"line",
"int",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"!",
"debugMode",
"{",
"return",
"\n",
"}",
"\n\n",
"// Change the output to Stderr",
"l",
".",
"SetOutput",
"(",
"os",
".",
"Stderr",
")",
"\n\n",
"// Create the log record",
"record",
":=",
"LogRecord",
"{",
"ID",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"atomic",
".",
"AddUint64",
"(",
"&",
"sequenceNo",
",",
"1",
")",
")",
",",
"Level",
":",
"l",
".",
"getColorLevel",
"(",
"levelDebug",
")",
",",
"Message",
":",
"fmt",
".",
"Sprintf",
"(",
"message",
",",
"args",
"...",
")",
",",
"LineNo",
":",
"line",
",",
"Filename",
":",
"filepath",
".",
"Base",
"(",
"file",
")",
",",
"}",
"\n",
"err",
":=",
"debugLogRecordTemplate",
".",
"Execute",
"(",
"l",
".",
"output",
",",
"record",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // mustLogDebug logs a debug message only if debug mode
// is enabled. i.e. DEBUG_ENABLED="1" | [
"mustLogDebug",
"logs",
"a",
"debug",
"message",
"only",
"if",
"debug",
"mode",
"is",
"enabled",
".",
"i",
".",
"e",
".",
"DEBUG_ENABLED",
"=",
"1"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L192-L212 | train |
beego/bee | logger/logger.go | Debug | func (l *BeeLogger) Debug(message string, file string, line int) {
l.mustLogDebug(message, file, line)
} | go | func (l *BeeLogger) Debug(message string, file string, line int) {
l.mustLogDebug(message, file, line)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"Debug",
"(",
"message",
"string",
",",
"file",
"string",
",",
"line",
"int",
")",
"{",
"l",
".",
"mustLogDebug",
"(",
"message",
",",
"file",
",",
"line",
")",
"\n",
"}"
] | // Debug outputs a debug log message | [
"Debug",
"outputs",
"a",
"debug",
"log",
"message"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L215-L217 | train |
beego/bee | logger/logger.go | Debugf | func (l *BeeLogger) Debugf(message string, file string, line int, vars ...interface{}) {
l.mustLogDebug(message, file, line, vars...)
} | go | func (l *BeeLogger) Debugf(message string, file string, line int, vars ...interface{}) {
l.mustLogDebug(message, file, line, vars...)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"Debugf",
"(",
"message",
"string",
",",
"file",
"string",
",",
"line",
"int",
",",
"vars",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"mustLogDebug",
"(",
"message",
",",
"file",
",",
"line",
",",
"vars",
"...",
")",
"\n",
"}"
] | // Debugf outputs a formatted debug log message | [
"Debugf",
"outputs",
"a",
"formatted",
"debug",
"log",
"message"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L220-L222 | train |
beego/bee | logger/logger.go | Infof | func (l *BeeLogger) Infof(message string, vars ...interface{}) {
l.mustLog(levelInfo, message, vars...)
} | go | func (l *BeeLogger) Infof(message string, vars ...interface{}) {
l.mustLog(levelInfo, message, vars...)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"Infof",
"(",
"message",
"string",
",",
"vars",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"mustLog",
"(",
"levelInfo",
",",
"message",
",",
"vars",
"...",
")",
"\n",
"}"
] | // Infof outputs a formatted information log message | [
"Infof",
"outputs",
"a",
"formatted",
"information",
"log",
"message"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L230-L232 | train |
beego/bee | logger/logger.go | Warnf | func (l *BeeLogger) Warnf(message string, vars ...interface{}) {
l.mustLog(levelWarn, message, vars...)
} | go | func (l *BeeLogger) Warnf(message string, vars ...interface{}) {
l.mustLog(levelWarn, message, vars...)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"Warnf",
"(",
"message",
"string",
",",
"vars",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"mustLog",
"(",
"levelWarn",
",",
"message",
",",
"vars",
"...",
")",
"\n",
"}"
] | // Warnf outputs a formatted warning log message | [
"Warnf",
"outputs",
"a",
"formatted",
"warning",
"log",
"message"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L240-L242 | train |
beego/bee | logger/logger.go | Errorf | func (l *BeeLogger) Errorf(message string, vars ...interface{}) {
l.mustLog(levelError, message, vars...)
} | go | func (l *BeeLogger) Errorf(message string, vars ...interface{}) {
l.mustLog(levelError, message, vars...)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"Errorf",
"(",
"message",
"string",
",",
"vars",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"mustLog",
"(",
"levelError",
",",
"message",
",",
"vars",
"...",
")",
"\n",
"}"
] | // Errorf outputs a formatted error log message | [
"Errorf",
"outputs",
"a",
"formatted",
"error",
"log",
"message"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L250-L252 | train |
beego/bee | logger/logger.go | Fatal | func (l *BeeLogger) Fatal(message string) {
l.mustLog(levelFatal, message)
os.Exit(255)
} | go | func (l *BeeLogger) Fatal(message string) {
l.mustLog(levelFatal, message)
os.Exit(255)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"Fatal",
"(",
"message",
"string",
")",
"{",
"l",
".",
"mustLog",
"(",
"levelFatal",
",",
"message",
")",
"\n",
"os",
".",
"Exit",
"(",
"255",
")",
"\n",
"}"
] | // Fatal outputs a fatal log message and exists | [
"Fatal",
"outputs",
"a",
"fatal",
"log",
"message",
"and",
"exists"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L255-L258 | train |
beego/bee | logger/logger.go | Fatalf | func (l *BeeLogger) Fatalf(message string, vars ...interface{}) {
l.mustLog(levelFatal, message, vars...)
os.Exit(255)
} | go | func (l *BeeLogger) Fatalf(message string, vars ...interface{}) {
l.mustLog(levelFatal, message, vars...)
os.Exit(255)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"Fatalf",
"(",
"message",
"string",
",",
"vars",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"mustLog",
"(",
"levelFatal",
",",
"message",
",",
"vars",
"...",
")",
"\n",
"os",
".",
"Exit",
"(",
"255",
")",
"\n",
"}"
] | // Fatalf outputs a formatted log message and exists | [
"Fatalf",
"outputs",
"a",
"formatted",
"log",
"message",
"and",
"exists"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L261-L264 | train |
beego/bee | logger/logger.go | Successf | func (l *BeeLogger) Successf(message string, vars ...interface{}) {
l.mustLog(levelSuccess, message, vars...)
} | go | func (l *BeeLogger) Successf(message string, vars ...interface{}) {
l.mustLog(levelSuccess, message, vars...)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"Successf",
"(",
"message",
"string",
",",
"vars",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"mustLog",
"(",
"levelSuccess",
",",
"message",
",",
"vars",
"...",
")",
"\n",
"}"
] | // Successf outputs a formatted success log message | [
"Successf",
"outputs",
"a",
"formatted",
"success",
"log",
"message"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L272-L274 | train |
beego/bee | logger/logger.go | Hintf | func (l *BeeLogger) Hintf(message string, vars ...interface{}) {
l.mustLog(levelHint, message, vars...)
} | go | func (l *BeeLogger) Hintf(message string, vars ...interface{}) {
l.mustLog(levelHint, message, vars...)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"Hintf",
"(",
"message",
"string",
",",
"vars",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"mustLog",
"(",
"levelHint",
",",
"message",
",",
"vars",
"...",
")",
"\n",
"}"
] | // Hintf outputs a formatted hint log message | [
"Hintf",
"outputs",
"a",
"formatted",
"hint",
"log",
"message"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L282-L284 | train |
beego/bee | logger/logger.go | Criticalf | func (l *BeeLogger) Criticalf(message string, vars ...interface{}) {
l.mustLog(levelCritical, message, vars...)
} | go | func (l *BeeLogger) Criticalf(message string, vars ...interface{}) {
l.mustLog(levelCritical, message, vars...)
} | [
"func",
"(",
"l",
"*",
"BeeLogger",
")",
"Criticalf",
"(",
"message",
"string",
",",
"vars",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"mustLog",
"(",
"levelCritical",
",",
"message",
",",
"vars",
"...",
")",
"\n",
"}"
] | // Criticalf outputs a formatted critical log message | [
"Criticalf",
"outputs",
"a",
"formatted",
"critical",
"log",
"message"
] | 6a86284cec9a17f9aae6fe82ecf3c436aafed68d | https://github.com/beego/bee/blob/6a86284cec9a17f9aae6fe82ecf3c436aafed68d/logger/logger.go#L292-L294 | train |
cloudfoundry/cli | actor/v3action/organization.go | GetOrganizationByName | func (actor Actor) GetOrganizationByName(name string) (Organization, Warnings, error) {
orgs, warnings, err := actor.CloudControllerClient.GetOrganizations(
ccv3.Query{Key: ccv3.NameFilter, Values: []string{name}},
)
if err != nil {
return Organization{}, Warnings(warnings), err
}
if len(orgs) == 0 {
return Organization{}, Warnings(warnings), actionerror.OrganizationNotFoundError{Name: name}
}
return Organization(orgs[0]), Warnings(warnings), nil
} | go | func (actor Actor) GetOrganizationByName(name string) (Organization, Warnings, error) {
orgs, warnings, err := actor.CloudControllerClient.GetOrganizations(
ccv3.Query{Key: ccv3.NameFilter, Values: []string{name}},
)
if err != nil {
return Organization{}, Warnings(warnings), err
}
if len(orgs) == 0 {
return Organization{}, Warnings(warnings), actionerror.OrganizationNotFoundError{Name: name}
}
return Organization(orgs[0]), Warnings(warnings), nil
} | [
"func",
"(",
"actor",
"Actor",
")",
"GetOrganizationByName",
"(",
"name",
"string",
")",
"(",
"Organization",
",",
"Warnings",
",",
"error",
")",
"{",
"orgs",
",",
"warnings",
",",
"err",
":=",
"actor",
".",
"CloudControllerClient",
".",
"GetOrganizations",
"(",
"ccv3",
".",
"Query",
"{",
"Key",
":",
"ccv3",
".",
"NameFilter",
",",
"Values",
":",
"[",
"]",
"string",
"{",
"name",
"}",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Organization",
"{",
"}",
",",
"Warnings",
"(",
"warnings",
")",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"orgs",
")",
"==",
"0",
"{",
"return",
"Organization",
"{",
"}",
",",
"Warnings",
"(",
"warnings",
")",
",",
"actionerror",
".",
"OrganizationNotFoundError",
"{",
"Name",
":",
"name",
"}",
"\n",
"}",
"\n\n",
"return",
"Organization",
"(",
"orgs",
"[",
"0",
"]",
")",
",",
"Warnings",
"(",
"warnings",
")",
",",
"nil",
"\n",
"}"
] | // GetOrganizationByName returns the organization with the given name. | [
"GetOrganizationByName",
"returns",
"the",
"organization",
"with",
"the",
"given",
"name",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/actor/v3action/organization.go#L14-L27 | train |
cloudfoundry/cli | util/configv3/json_config.go | SetOrganizationInformation | func (config *Config) SetOrganizationInformation(guid string, name string) {
config.ConfigFile.TargetedOrganization.GUID = guid
config.ConfigFile.TargetedOrganization.Name = name
config.ConfigFile.TargetedOrganization.QuotaDefinition = QuotaDefinition{}
} | go | func (config *Config) SetOrganizationInformation(guid string, name string) {
config.ConfigFile.TargetedOrganization.GUID = guid
config.ConfigFile.TargetedOrganization.Name = name
config.ConfigFile.TargetedOrganization.QuotaDefinition = QuotaDefinition{}
} | [
"func",
"(",
"config",
"*",
"Config",
")",
"SetOrganizationInformation",
"(",
"guid",
"string",
",",
"name",
"string",
")",
"{",
"config",
".",
"ConfigFile",
".",
"TargetedOrganization",
".",
"GUID",
"=",
"guid",
"\n",
"config",
".",
"ConfigFile",
".",
"TargetedOrganization",
".",
"Name",
"=",
"name",
"\n",
"config",
".",
"ConfigFile",
".",
"TargetedOrganization",
".",
"QuotaDefinition",
"=",
"QuotaDefinition",
"{",
"}",
"\n",
"}"
] | // SetOrganizationInformation sets the currently targeted organization. | [
"SetOrganizationInformation",
"sets",
"the",
"currently",
"targeted",
"organization",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/util/configv3/json_config.go#L140-L144 | train |
cloudfoundry/cli | util/configv3/json_config.go | SetSpaceInformation | func (config *Config) SetSpaceInformation(guid string, name string, allowSSH bool) {
config.V7SetSpaceInformation(guid, name)
config.ConfigFile.TargetedSpace.AllowSSH = allowSSH
} | go | func (config *Config) SetSpaceInformation(guid string, name string, allowSSH bool) {
config.V7SetSpaceInformation(guid, name)
config.ConfigFile.TargetedSpace.AllowSSH = allowSSH
} | [
"func",
"(",
"config",
"*",
"Config",
")",
"SetSpaceInformation",
"(",
"guid",
"string",
",",
"name",
"string",
",",
"allowSSH",
"bool",
")",
"{",
"config",
".",
"V7SetSpaceInformation",
"(",
"guid",
",",
"name",
")",
"\n",
"config",
".",
"ConfigFile",
".",
"TargetedSpace",
".",
"AllowSSH",
"=",
"allowSSH",
"\n",
"}"
] | // SetSpaceInformation sets the currently targeted space. | [
"SetSpaceInformation",
"sets",
"the",
"currently",
"targeted",
"space",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/util/configv3/json_config.go#L152-L155 | train |
cloudfoundry/cli | util/configv3/json_config.go | SetTargetInformation | func (config *Config) SetTargetInformation(api string, apiVersion string, auth string, minCLIVersion string, doppler string, routing string, skipSSLValidation bool) {
config.ConfigFile.Target = api
config.ConfigFile.APIVersion = apiVersion
config.ConfigFile.AuthorizationEndpoint = auth
config.SetMinCLIVersion(minCLIVersion)
config.ConfigFile.DopplerEndpoint = doppler
config.ConfigFile.RoutingEndpoint = routing
config.ConfigFile.SkipSSLValidation = skipSSLValidation
config.UnsetOrganizationAndSpaceInformation()
} | go | func (config *Config) SetTargetInformation(api string, apiVersion string, auth string, minCLIVersion string, doppler string, routing string, skipSSLValidation bool) {
config.ConfigFile.Target = api
config.ConfigFile.APIVersion = apiVersion
config.ConfigFile.AuthorizationEndpoint = auth
config.SetMinCLIVersion(minCLIVersion)
config.ConfigFile.DopplerEndpoint = doppler
config.ConfigFile.RoutingEndpoint = routing
config.ConfigFile.SkipSSLValidation = skipSSLValidation
config.UnsetOrganizationAndSpaceInformation()
} | [
"func",
"(",
"config",
"*",
"Config",
")",
"SetTargetInformation",
"(",
"api",
"string",
",",
"apiVersion",
"string",
",",
"auth",
"string",
",",
"minCLIVersion",
"string",
",",
"doppler",
"string",
",",
"routing",
"string",
",",
"skipSSLValidation",
"bool",
")",
"{",
"config",
".",
"ConfigFile",
".",
"Target",
"=",
"api",
"\n",
"config",
".",
"ConfigFile",
".",
"APIVersion",
"=",
"apiVersion",
"\n",
"config",
".",
"ConfigFile",
".",
"AuthorizationEndpoint",
"=",
"auth",
"\n",
"config",
".",
"SetMinCLIVersion",
"(",
"minCLIVersion",
")",
"\n",
"config",
".",
"ConfigFile",
".",
"DopplerEndpoint",
"=",
"doppler",
"\n",
"config",
".",
"ConfigFile",
".",
"RoutingEndpoint",
"=",
"routing",
"\n",
"config",
".",
"ConfigFile",
".",
"SkipSSLValidation",
"=",
"skipSSLValidation",
"\n\n",
"config",
".",
"UnsetOrganizationAndSpaceInformation",
"(",
")",
"\n",
"}"
] | // SetTargetInformation sets the currently targeted CC API and related other
// related API URLs. | [
"SetTargetInformation",
"sets",
"the",
"currently",
"targeted",
"CC",
"API",
"and",
"related",
"other",
"related",
"API",
"URLs",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/util/configv3/json_config.go#L159-L169 | train |
cloudfoundry/cli | util/configv3/json_config.go | SetUAAClientCredentials | func (config *Config) SetUAAClientCredentials(client string, clientSecret string) {
config.ConfigFile.UAAOAuthClient = client
config.ConfigFile.UAAOAuthClientSecret = clientSecret
} | go | func (config *Config) SetUAAClientCredentials(client string, clientSecret string) {
config.ConfigFile.UAAOAuthClient = client
config.ConfigFile.UAAOAuthClientSecret = clientSecret
} | [
"func",
"(",
"config",
"*",
"Config",
")",
"SetUAAClientCredentials",
"(",
"client",
"string",
",",
"clientSecret",
"string",
")",
"{",
"config",
".",
"ConfigFile",
".",
"UAAOAuthClient",
"=",
"client",
"\n",
"config",
".",
"ConfigFile",
".",
"UAAOAuthClientSecret",
"=",
"clientSecret",
"\n",
"}"
] | // SetUAAClientCredentials sets the client credentials. | [
"SetUAAClientCredentials",
"sets",
"the",
"client",
"credentials",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/util/configv3/json_config.go#L179-L182 | train |
cloudfoundry/cli | util/configv3/json_config.go | V7SetSpaceInformation | func (config *Config) V7SetSpaceInformation(guid string, name string) {
config.ConfigFile.TargetedSpace.GUID = guid
config.ConfigFile.TargetedSpace.Name = name
} | go | func (config *Config) V7SetSpaceInformation(guid string, name string) {
config.ConfigFile.TargetedSpace.GUID = guid
config.ConfigFile.TargetedSpace.Name = name
} | [
"func",
"(",
"config",
"*",
"Config",
")",
"V7SetSpaceInformation",
"(",
"guid",
"string",
",",
"name",
"string",
")",
"{",
"config",
".",
"ConfigFile",
".",
"TargetedSpace",
".",
"GUID",
"=",
"guid",
"\n",
"config",
".",
"ConfigFile",
".",
"TargetedSpace",
".",
"Name",
"=",
"name",
"\n",
"}"
] | // V7SetSpaceInformation sets the currently targeted space. | [
"V7SetSpaceInformation",
"sets",
"the",
"currently",
"targeted",
"space",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/util/configv3/json_config.go#L268-L271 | train |
cloudfoundry/cli | actor/v3action/actor.go | NewActor | func NewActor(client CloudControllerClient, config Config, sharedActor SharedActor, uaaClient UAAClient) *Actor {
return &Actor{
CloudControllerClient: client,
Config: config,
SharedActor: sharedActor,
UAAClient: uaaClient,
}
} | go | func NewActor(client CloudControllerClient, config Config, sharedActor SharedActor, uaaClient UAAClient) *Actor {
return &Actor{
CloudControllerClient: client,
Config: config,
SharedActor: sharedActor,
UAAClient: uaaClient,
}
} | [
"func",
"NewActor",
"(",
"client",
"CloudControllerClient",
",",
"config",
"Config",
",",
"sharedActor",
"SharedActor",
",",
"uaaClient",
"UAAClient",
")",
"*",
"Actor",
"{",
"return",
"&",
"Actor",
"{",
"CloudControllerClient",
":",
"client",
",",
"Config",
":",
"config",
",",
"SharedActor",
":",
"sharedActor",
",",
"UAAClient",
":",
"uaaClient",
",",
"}",
"\n",
"}"
] | // NewActor returns a new V3 actor. | [
"NewActor",
"returns",
"a",
"new",
"V3",
"actor",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/actor/v3action/actor.go#L24-L31 | train |
cloudfoundry/cli | api/cloudcontroller/ccv2/service_binding.go | UnmarshalJSON | func (serviceBinding *ServiceBinding) UnmarshalJSON(data []byte) error {
var ccServiceBinding struct {
Metadata internal.Metadata
Entity struct {
AppGUID string `json:"app_guid"`
ServiceInstanceGUID string `json:"service_instance_guid"`
Name string `json:"name"`
LastOperation LastOperation `json:"last_operation"`
} `json:"entity"`
}
err := cloudcontroller.DecodeJSON(data, &ccServiceBinding)
if err != nil {
return err
}
serviceBinding.AppGUID = ccServiceBinding.Entity.AppGUID
serviceBinding.GUID = ccServiceBinding.Metadata.GUID
serviceBinding.ServiceInstanceGUID = ccServiceBinding.Entity.ServiceInstanceGUID
serviceBinding.Name = ccServiceBinding.Entity.Name
serviceBinding.LastOperation = ccServiceBinding.Entity.LastOperation
return nil
} | go | func (serviceBinding *ServiceBinding) UnmarshalJSON(data []byte) error {
var ccServiceBinding struct {
Metadata internal.Metadata
Entity struct {
AppGUID string `json:"app_guid"`
ServiceInstanceGUID string `json:"service_instance_guid"`
Name string `json:"name"`
LastOperation LastOperation `json:"last_operation"`
} `json:"entity"`
}
err := cloudcontroller.DecodeJSON(data, &ccServiceBinding)
if err != nil {
return err
}
serviceBinding.AppGUID = ccServiceBinding.Entity.AppGUID
serviceBinding.GUID = ccServiceBinding.Metadata.GUID
serviceBinding.ServiceInstanceGUID = ccServiceBinding.Entity.ServiceInstanceGUID
serviceBinding.Name = ccServiceBinding.Entity.Name
serviceBinding.LastOperation = ccServiceBinding.Entity.LastOperation
return nil
} | [
"func",
"(",
"serviceBinding",
"*",
"ServiceBinding",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"ccServiceBinding",
"struct",
"{",
"Metadata",
"internal",
".",
"Metadata",
"\n",
"Entity",
"struct",
"{",
"AppGUID",
"string",
"`json:\"app_guid\"`",
"\n",
"ServiceInstanceGUID",
"string",
"`json:\"service_instance_guid\"`",
"\n",
"Name",
"string",
"`json:\"name\"`",
"\n",
"LastOperation",
"LastOperation",
"`json:\"last_operation\"`",
"\n",
"}",
"`json:\"entity\"`",
"\n",
"}",
"\n",
"err",
":=",
"cloudcontroller",
".",
"DecodeJSON",
"(",
"data",
",",
"&",
"ccServiceBinding",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"serviceBinding",
".",
"AppGUID",
"=",
"ccServiceBinding",
".",
"Entity",
".",
"AppGUID",
"\n",
"serviceBinding",
".",
"GUID",
"=",
"ccServiceBinding",
".",
"Metadata",
".",
"GUID",
"\n",
"serviceBinding",
".",
"ServiceInstanceGUID",
"=",
"ccServiceBinding",
".",
"Entity",
".",
"ServiceInstanceGUID",
"\n",
"serviceBinding",
".",
"Name",
"=",
"ccServiceBinding",
".",
"Entity",
".",
"Name",
"\n",
"serviceBinding",
".",
"LastOperation",
"=",
"ccServiceBinding",
".",
"Entity",
".",
"LastOperation",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalJSON helps unmarshal a Cloud Controller Service Binding response. | [
"UnmarshalJSON",
"helps",
"unmarshal",
"a",
"Cloud",
"Controller",
"Service",
"Binding",
"response",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/api/cloudcontroller/ccv2/service_binding.go#L29-L50 | train |
cloudfoundry/cli | api/cloudcontroller/ccv2/service_binding.go | DeleteServiceBinding | func (client *Client) DeleteServiceBinding(serviceBindingGUID string, acceptsIncomplete bool) (ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.DeleteServiceBindingRequest,
URIParams: map[string]string{"service_binding_guid": serviceBindingGUID},
Query: url.Values{"accepts_incomplete": {fmt.Sprint(acceptsIncomplete)}},
})
if err != nil {
return ServiceBinding{}, nil, err
}
var response cloudcontroller.Response
var serviceBinding ServiceBinding
if acceptsIncomplete {
response = cloudcontroller.Response{
DecodeJSONResponseInto: &serviceBinding,
}
}
err = client.connection.Make(request, &response)
return serviceBinding, response.Warnings, err
} | go | func (client *Client) DeleteServiceBinding(serviceBindingGUID string, acceptsIncomplete bool) (ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.DeleteServiceBindingRequest,
URIParams: map[string]string{"service_binding_guid": serviceBindingGUID},
Query: url.Values{"accepts_incomplete": {fmt.Sprint(acceptsIncomplete)}},
})
if err != nil {
return ServiceBinding{}, nil, err
}
var response cloudcontroller.Response
var serviceBinding ServiceBinding
if acceptsIncomplete {
response = cloudcontroller.Response{
DecodeJSONResponseInto: &serviceBinding,
}
}
err = client.connection.Make(request, &response)
return serviceBinding, response.Warnings, err
} | [
"func",
"(",
"client",
"*",
"Client",
")",
"DeleteServiceBinding",
"(",
"serviceBindingGUID",
"string",
",",
"acceptsIncomplete",
"bool",
")",
"(",
"ServiceBinding",
",",
"Warnings",
",",
"error",
")",
"{",
"request",
",",
"err",
":=",
"client",
".",
"newHTTPRequest",
"(",
"requestOptions",
"{",
"RequestName",
":",
"internal",
".",
"DeleteServiceBindingRequest",
",",
"URIParams",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"serviceBindingGUID",
"}",
",",
"Query",
":",
"url",
".",
"Values",
"{",
"\"",
"\"",
":",
"{",
"fmt",
".",
"Sprint",
"(",
"acceptsIncomplete",
")",
"}",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ServiceBinding",
"{",
"}",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"response",
"cloudcontroller",
".",
"Response",
"\n",
"var",
"serviceBinding",
"ServiceBinding",
"\n",
"if",
"acceptsIncomplete",
"{",
"response",
"=",
"cloudcontroller",
".",
"Response",
"{",
"DecodeJSONResponseInto",
":",
"&",
"serviceBinding",
",",
"}",
"\n",
"}",
"\n\n",
"err",
"=",
"client",
".",
"connection",
".",
"Make",
"(",
"request",
",",
"&",
"response",
")",
"\n",
"return",
"serviceBinding",
",",
"response",
".",
"Warnings",
",",
"err",
"\n",
"}"
] | // DeleteServiceBinding deletes the specified Service Binding. An updated
// service binding is returned only if acceptsIncomplete is true. | [
"DeleteServiceBinding",
"deletes",
"the",
"specified",
"Service",
"Binding",
".",
"An",
"updated",
"service",
"binding",
"is",
"returned",
"only",
"if",
"acceptsIncomplete",
"is",
"true",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/api/cloudcontroller/ccv2/service_binding.go#L98-L118 | train |
cloudfoundry/cli | api/cloudcontroller/ccv2/service_binding.go | GetServiceBinding | func (client *Client) GetServiceBinding(guid string) (ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceBindingRequest,
URIParams: Params{"service_binding_guid": guid},
})
if err != nil {
return ServiceBinding{}, nil, err
}
var serviceBinding ServiceBinding
response := cloudcontroller.Response{
DecodeJSONResponseInto: &serviceBinding,
}
err = client.connection.Make(request, &response)
return serviceBinding, response.Warnings, err
} | go | func (client *Client) GetServiceBinding(guid string) (ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceBindingRequest,
URIParams: Params{"service_binding_guid": guid},
})
if err != nil {
return ServiceBinding{}, nil, err
}
var serviceBinding ServiceBinding
response := cloudcontroller.Response{
DecodeJSONResponseInto: &serviceBinding,
}
err = client.connection.Make(request, &response)
return serviceBinding, response.Warnings, err
} | [
"func",
"(",
"client",
"*",
"Client",
")",
"GetServiceBinding",
"(",
"guid",
"string",
")",
"(",
"ServiceBinding",
",",
"Warnings",
",",
"error",
")",
"{",
"request",
",",
"err",
":=",
"client",
".",
"newHTTPRequest",
"(",
"requestOptions",
"{",
"RequestName",
":",
"internal",
".",
"GetServiceBindingRequest",
",",
"URIParams",
":",
"Params",
"{",
"\"",
"\"",
":",
"guid",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ServiceBinding",
"{",
"}",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"serviceBinding",
"ServiceBinding",
"\n",
"response",
":=",
"cloudcontroller",
".",
"Response",
"{",
"DecodeJSONResponseInto",
":",
"&",
"serviceBinding",
",",
"}",
"\n\n",
"err",
"=",
"client",
".",
"connection",
".",
"Make",
"(",
"request",
",",
"&",
"response",
")",
"\n",
"return",
"serviceBinding",
",",
"response",
".",
"Warnings",
",",
"err",
"\n",
"}"
] | // GetServiceBinding returns back a service binding with the provided GUID. | [
"GetServiceBinding",
"returns",
"back",
"a",
"service",
"binding",
"with",
"the",
"provided",
"GUID",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/api/cloudcontroller/ccv2/service_binding.go#L121-L137 | train |
cloudfoundry/cli | api/cloudcontroller/ccv2/service_binding.go | GetServiceBindings | func (client *Client) GetServiceBindings(filters ...Filter) ([]ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceBindingsRequest,
Query: ConvertFilterParameters(filters),
})
if err != nil {
return nil, nil, err
}
var fullBindingsList []ServiceBinding
warnings, err := client.paginate(request, ServiceBinding{}, func(item interface{}) error {
if binding, ok := item.(ServiceBinding); ok {
fullBindingsList = append(fullBindingsList, binding)
} else {
return ccerror.UnknownObjectInListError{
Expected: ServiceBinding{},
Unexpected: item,
}
}
return nil
})
return fullBindingsList, warnings, err
} | go | func (client *Client) GetServiceBindings(filters ...Filter) ([]ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceBindingsRequest,
Query: ConvertFilterParameters(filters),
})
if err != nil {
return nil, nil, err
}
var fullBindingsList []ServiceBinding
warnings, err := client.paginate(request, ServiceBinding{}, func(item interface{}) error {
if binding, ok := item.(ServiceBinding); ok {
fullBindingsList = append(fullBindingsList, binding)
} else {
return ccerror.UnknownObjectInListError{
Expected: ServiceBinding{},
Unexpected: item,
}
}
return nil
})
return fullBindingsList, warnings, err
} | [
"func",
"(",
"client",
"*",
"Client",
")",
"GetServiceBindings",
"(",
"filters",
"...",
"Filter",
")",
"(",
"[",
"]",
"ServiceBinding",
",",
"Warnings",
",",
"error",
")",
"{",
"request",
",",
"err",
":=",
"client",
".",
"newHTTPRequest",
"(",
"requestOptions",
"{",
"RequestName",
":",
"internal",
".",
"GetServiceBindingsRequest",
",",
"Query",
":",
"ConvertFilterParameters",
"(",
"filters",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"fullBindingsList",
"[",
"]",
"ServiceBinding",
"\n",
"warnings",
",",
"err",
":=",
"client",
".",
"paginate",
"(",
"request",
",",
"ServiceBinding",
"{",
"}",
",",
"func",
"(",
"item",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"binding",
",",
"ok",
":=",
"item",
".",
"(",
"ServiceBinding",
")",
";",
"ok",
"{",
"fullBindingsList",
"=",
"append",
"(",
"fullBindingsList",
",",
"binding",
")",
"\n",
"}",
"else",
"{",
"return",
"ccerror",
".",
"UnknownObjectInListError",
"{",
"Expected",
":",
"ServiceBinding",
"{",
"}",
",",
"Unexpected",
":",
"item",
",",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n\n",
"return",
"fullBindingsList",
",",
"warnings",
",",
"err",
"\n",
"}"
] | // GetServiceBindings returns back a list of Service Bindings based off of the
// provided filters. | [
"GetServiceBindings",
"returns",
"back",
"a",
"list",
"of",
"Service",
"Bindings",
"based",
"off",
"of",
"the",
"provided",
"filters",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/api/cloudcontroller/ccv2/service_binding.go#L141-L164 | train |
cloudfoundry/cli | api/cloudcontroller/ccv2/service_binding.go | GetServiceInstanceServiceBindings | func (client *Client) GetServiceInstanceServiceBindings(serviceInstanceGUID string) ([]ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceInstanceServiceBindingsRequest,
URIParams: map[string]string{"service_instance_guid": serviceInstanceGUID},
})
if err != nil {
return nil, nil, err
}
var fullBindingsList []ServiceBinding
warnings, err := client.paginate(request, ServiceBinding{}, func(item interface{}) error {
if binding, ok := item.(ServiceBinding); ok {
fullBindingsList = append(fullBindingsList, binding)
} else {
return ccerror.UnknownObjectInListError{
Expected: ServiceBinding{},
Unexpected: item,
}
}
return nil
})
return fullBindingsList, warnings, err
} | go | func (client *Client) GetServiceInstanceServiceBindings(serviceInstanceGUID string) ([]ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceInstanceServiceBindingsRequest,
URIParams: map[string]string{"service_instance_guid": serviceInstanceGUID},
})
if err != nil {
return nil, nil, err
}
var fullBindingsList []ServiceBinding
warnings, err := client.paginate(request, ServiceBinding{}, func(item interface{}) error {
if binding, ok := item.(ServiceBinding); ok {
fullBindingsList = append(fullBindingsList, binding)
} else {
return ccerror.UnknownObjectInListError{
Expected: ServiceBinding{},
Unexpected: item,
}
}
return nil
})
return fullBindingsList, warnings, err
} | [
"func",
"(",
"client",
"*",
"Client",
")",
"GetServiceInstanceServiceBindings",
"(",
"serviceInstanceGUID",
"string",
")",
"(",
"[",
"]",
"ServiceBinding",
",",
"Warnings",
",",
"error",
")",
"{",
"request",
",",
"err",
":=",
"client",
".",
"newHTTPRequest",
"(",
"requestOptions",
"{",
"RequestName",
":",
"internal",
".",
"GetServiceInstanceServiceBindingsRequest",
",",
"URIParams",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"serviceInstanceGUID",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"fullBindingsList",
"[",
"]",
"ServiceBinding",
"\n",
"warnings",
",",
"err",
":=",
"client",
".",
"paginate",
"(",
"request",
",",
"ServiceBinding",
"{",
"}",
",",
"func",
"(",
"item",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"binding",
",",
"ok",
":=",
"item",
".",
"(",
"ServiceBinding",
")",
";",
"ok",
"{",
"fullBindingsList",
"=",
"append",
"(",
"fullBindingsList",
",",
"binding",
")",
"\n",
"}",
"else",
"{",
"return",
"ccerror",
".",
"UnknownObjectInListError",
"{",
"Expected",
":",
"ServiceBinding",
"{",
"}",
",",
"Unexpected",
":",
"item",
",",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n\n",
"return",
"fullBindingsList",
",",
"warnings",
",",
"err",
"\n",
"}"
] | // GetServiceInstanceServiceBindings returns back a list of Service Bindings for the provided service instance GUID. | [
"GetServiceInstanceServiceBindings",
"returns",
"back",
"a",
"list",
"of",
"Service",
"Bindings",
"for",
"the",
"provided",
"service",
"instance",
"GUID",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/api/cloudcontroller/ccv2/service_binding.go#L167-L190 | train |
cloudfoundry/cli | api/cloudcontroller/ccv2/feature_flag.go | GetConfigFeatureFlags | func (client Client) GetConfigFeatureFlags() ([]FeatureFlag, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetConfigFeatureFlagsRequest,
})
if err != nil {
return nil, nil, err
}
var featureFlags []FeatureFlag
response := cloudcontroller.Response{
DecodeJSONResponseInto: &featureFlags,
}
err = client.connection.Make(request, &response)
return featureFlags, response.Warnings, err
} | go | func (client Client) GetConfigFeatureFlags() ([]FeatureFlag, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetConfigFeatureFlagsRequest,
})
if err != nil {
return nil, nil, err
}
var featureFlags []FeatureFlag
response := cloudcontroller.Response{
DecodeJSONResponseInto: &featureFlags,
}
err = client.connection.Make(request, &response)
return featureFlags, response.Warnings, err
} | [
"func",
"(",
"client",
"Client",
")",
"GetConfigFeatureFlags",
"(",
")",
"(",
"[",
"]",
"FeatureFlag",
",",
"Warnings",
",",
"error",
")",
"{",
"request",
",",
"err",
":=",
"client",
".",
"newHTTPRequest",
"(",
"requestOptions",
"{",
"RequestName",
":",
"internal",
".",
"GetConfigFeatureFlagsRequest",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"featureFlags",
"[",
"]",
"FeatureFlag",
"\n",
"response",
":=",
"cloudcontroller",
".",
"Response",
"{",
"DecodeJSONResponseInto",
":",
"&",
"featureFlags",
",",
"}",
"\n\n",
"err",
"=",
"client",
".",
"connection",
".",
"Make",
"(",
"request",
",",
"&",
"response",
")",
"\n",
"return",
"featureFlags",
",",
"response",
".",
"Warnings",
",",
"err",
"\n",
"}"
] | // GetConfigFeatureFlags retrieves a list of FeatureFlag from the Cloud
// Controller. | [
"GetConfigFeatureFlags",
"retrieves",
"a",
"list",
"of",
"FeatureFlag",
"from",
"the",
"Cloud",
"Controller",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/api/cloudcontroller/ccv2/feature_flag.go#L21-L36 | train |
cloudfoundry/cli | api/router/connection_wrapper.go | WrapConnection | func (client *Client) WrapConnection(wrapper ConnectionWrapper) {
client.connection = wrapper.Wrap(client.connection)
} | go | func (client *Client) WrapConnection(wrapper ConnectionWrapper) {
client.connection = wrapper.Wrap(client.connection)
} | [
"func",
"(",
"client",
"*",
"Client",
")",
"WrapConnection",
"(",
"wrapper",
"ConnectionWrapper",
")",
"{",
"client",
".",
"connection",
"=",
"wrapper",
".",
"Wrap",
"(",
"client",
".",
"connection",
")",
"\n",
"}"
] | // WrapConnection wraps the current Client connection in the wrapper. | [
"WrapConnection",
"wraps",
"the",
"current",
"Client",
"connection",
"in",
"the",
"wrapper",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/api/router/connection_wrapper.go#L13-L15 | train |
cloudfoundry/cli | actor/v3action/target.go | ClearTarget | func (actor Actor) ClearTarget() {
actor.Config.SetTargetInformation("", "", "", "", "", "", false)
actor.Config.SetTokenInformation("", "", "")
} | go | func (actor Actor) ClearTarget() {
actor.Config.SetTargetInformation("", "", "", "", "", "", false)
actor.Config.SetTokenInformation("", "", "")
} | [
"func",
"(",
"actor",
"Actor",
")",
"ClearTarget",
"(",
")",
"{",
"actor",
".",
"Config",
".",
"SetTargetInformation",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"false",
")",
"\n",
"actor",
".",
"Config",
".",
"SetTokenInformation",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // ClearTarget clears target information from the actor. | [
"ClearTarget",
"clears",
"target",
"information",
"from",
"the",
"actor",
"."
] | 5010c000047f246b870475e2c299556078cdad30 | https://github.com/cloudfoundry/cli/blob/5010c000047f246b870475e2c299556078cdad30/actor/v3action/target.go#L43-L46 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.