func main() {
fmt.Println(strings.Index("chicken", "ken"))
fmt.Println(strings.Index("chicken", "dmr"))
fmt.Println(strings.ContainsAny("team", "e"))
fmt.Println(strings.ContainsAny("failure", "u & i"))
fmt.Println(strings.ContainsAny("foo", ""))
fmt.Println(strings.ContainsAny("", ""))
fmt.Println(1 & 1)
fmt.Println(2 & 1)
fmt.Println(4 & 1)
fmt.Println(5 & 1)
pow, sq := HashTest("1234567")
fmt.Println(pow)
fmt.Println(sq)
str := "df 世 界 asd"
s := "1界"
index := strings.IndexAny(str, "界")
fmt.Printf("%d......\n", index)
for i, c := range str {
fmt.Println(i)
for _, m := range s {
fmt.Printf("%c\t%c\n", c, m)
}
}
for i := len(str); i > 0; {
rune, size := utf8.DecodeLastRuneInString(str[0:i])
fmt.Printf("%v\t", i)
i -= size
for _, m := range s {
fmt.Printf("%c\t%v\t%v\n", rune, size, m)
}
}
fmt.Println("bytes =", len(str))
fmt.Println("runes =", utf8.RuneCountInString(str))
for _, ss := range strings.Fields(str) {
fmt.Println(ss)
}
fmt.Println(strings.ToTitle(str))
str = "Hello, 世界"
// for len(str) > 0 {
// r, size := utf8.DecodeRuneInString(str)
// fmt.Printf("%c %v\n", r, size)
// str = str[size:]
// }
fmt.Println(Replace(str, "", "f", -1))
hulu := new(huluwa)
hello(hulu)
}
func (s *DockerSuite) TestKillWithInvalidSignal(c *check.C) {
testRequires(c, DaemonIsLinux)
out, _ := dockerCmd(c, "run", "-d", "busybox", "top")
cid := strings.TrimSpace(out)
c.Assert(waitRun(cid), check.IsNil)
out, _, err := dockerCmdWithError("kill", "-s", "0", cid)
c.Assert(err, check.NotNil)
if !strings.ContainsAny(out, "Invalid signal: 0") {
c.Fatal("Kill with an invalid signal didn't error out correctly")
}
running, _ := inspectField(cid, "State.Running")
if running != "true" {
c.Fatal("Container should be in running state after an invalid signal")
}
out, _ = dockerCmd(c, "run", "-d", "busybox", "top")
cid = strings.TrimSpace(out)
c.Assert(waitRun(cid), check.IsNil)
out, _, err = dockerCmdWithError("kill", "-s", "SIG42", cid)
c.Assert(err, check.NotNil)
if !strings.ContainsAny(out, "Invalid signal: SIG42") {
c.Fatal("Kill with an invalid signal error out correctly")
}
running, _ = inspectField(cid, "State.Running")
if running != "true" {
c.Fatal("Container should be in running state after an invalid signal")
}
}
func testGenericRecursive(t *testing.T, beforeErr error, beforeWant []string, list []wrapper, maxDepth int) {
if len(beforeWant) == 0 {
panic("beforeWant must not be empty")
}
for _, w := range list {
if len(w.want) == 0 {
panic("want must not be empty")
}
err := w.wrap(beforeErr)
// Copy required cause append(beforeWant, ..) modified beforeWant subtly.
beforeCopy := make([]string, len(beforeWant))
copy(beforeCopy, beforeWant)
beforeWant := beforeCopy
last := len(beforeWant) - 1
var want []string
// Merge two stacks behind each other.
if strings.ContainsAny(beforeWant[last], "\n") && strings.ContainsAny(w.want[0], "\n") {
want = append(beforeWant[:last], append([]string{beforeWant[last] + "((?s).*)" + w.want[0]}, w.want[1:]...)...)
} else {
want = append(beforeWant, w.want...)
}
testFormatCompleteCompare(t, maxDepth, err, "%+v", want, false)
if maxDepth > 0 {
testGenericRecursive(t, err, want, list, maxDepth-1)
}
}
}
// reads the videoId property and try to find what we need inside
func (cfg *Config) findVideoId() (videoId string, err error) {
videoId = cfg.videoId
if strings.Contains(videoId, "youtu") || strings.ContainsAny(videoId, "\"?&/<%=") {
log("Provided video id seems to be an url, trying to detect")
re_list := []*regexp.Regexp{
regexp.MustCompile(`(?:v|embed|watch\?v)(?:=|/)([^"&?/=%]{11})`),
regexp.MustCompile(`(?:=|/)([^"&?/=%]{11})`),
regexp.MustCompile(`([^"&?/=%]{11})`),
}
for _, re := range re_list {
if is_match := re.MatchString(videoId); is_match {
subs := re.FindStringSubmatch(videoId)
videoId = subs[1]
}
}
}
log("Found video id: '%s'", videoId)
if strings.ContainsAny(videoId, "?&/<%=") {
return videoId, errors.New("invalid characters in video id")
}
if len(videoId) < 10 {
return videoId, errors.New("the video id must be at least 10 characters long")
}
return videoId, nil
}
func preprocess(input string) (string, bool, bool) {
ok := true
end := false
output := input
var buffer bytes.Buffer
//skip words with numerals
nums := "1234567890"
if strings.ContainsAny(input, nums) {
ok = false
return output, ok, end
}
//remove parenthesis
i := strings.IndexAny(input, "()")
if i > -1 {
buffer.WriteString(input[:i])
buffer.WriteString(input[i+1:])
output = buffer.String()
}
if strings.ContainsAny(input, ".!?") {
end = true
}
return output, ok, end
}
func GetBlog(w http.ResponseWriter, r *http.Request) {
u := User{}
// Check if offset and limit were provided for pagination
vars := mux.Vars(r)
offset, err := strconv.Atoi(vars["offset"])
if err != nil {
// If var is empty assign default value
if strings.ContainsAny(err.Error(), "invalid syntax") {
offset = 0
} else {
log.Printf("No offset query parameter: %s", err)
}
}
limit, err := strconv.Atoi(vars["limit"])
if err != nil {
// If var is empty assign default value
if strings.ContainsAny(err.Error(), "invalid syntax") {
limit = 10
} else {
log.Printf("No offset query parameter: %s", err)
}
}
b, err := selectPageBlogEntries(limit, offset)
if err != nil {
log.Printf("ERROR: could not retrieve blog entries")
}
bFmt := []Post{}
for _, post := range b {
blogpost := Post{
Id: post.Id,
Postdate: post.PostDate.Format("15:04:05 Mon Jan 2 2006"),
Title: post.Title,
Tags: post.Tags,
Body: template.HTML(string(blackfriday.MarkdownCommon([]byte(post.Body)))),
}
bFmt = append(bFmt, blogpost)
}
data := struct {
Blog []Post
User User
}{
bFmt,
u,
}
t, err := template.ParseFiles("tmpl/base.html",
"tmpl/header.tmpl",
"tmpl/navbar.tmpl",
"tmpl/blog-body.tmpl",
"tmpl/footer.tmpl",
"tmpl/js.tmpl")
if err != nil {
log.Printf("ERROR: error creating blog HTML template: %s", err)
}
t.Execute(w, data)
}
//ConvertBandwidth will change the format of the bandwidth to int64 format and return the updated bw.
//eg:- 2 kb bandwidth will be converted to 2*1024 and the result in Int64 format will be returned.
func ConvertBandwidth(bandwidth string) int64 {
var rate int64
const (
kilobytes = 1024
megabytes = 1024 * kilobytes
gigabytes = 1024 * megabytes
)
regex := regexp.MustCompile("[0-9]+")
bw := regex.FindAllString(bandwidth, -1)
bwParseInt, err := strconv.ParseInt(bw[0], 10, 64)
if err != nil {
log.Errorf("error converting bandwidth string to uint64 %+v", err)
}
if strings.ContainsAny(bandwidth, "g|G") {
rate = gigabytes
} else if strings.ContainsAny(bandwidth, "m|M") {
rate = megabytes
} else if strings.ContainsAny(bandwidth, "k|K") {
rate = kilobytes
}
bwInt := bwParseInt * rate
bwInt = bwInt / 1000
return bwInt
}
// ContainsAny reports whether any Unicode code points in chars within s
func ContainsAny(s, chars string) bool {
fmt.Println(strings.ContainsAny("team", "i")) // false
fmt.Println(strings.ContainsAny("failure", "u & i")) // true
fmt.Println(strings.ContainsAny("foo", "")) // false
fmt.Println(strings.ContainsAny("", "")) // false
return strings.ContainsAny(s, chars)
}
func BwConvertInt64(bandwidth string) (int64, error) {
var rate int64
const (
kiloBytes = 1024
magaBytes = 1024 * kiloBytes
gigaBytes = 1024 * magaBytes
)
regex := regexp.MustCompile("[0-9]+")
bwStr := regex.FindAllString(bandwidth, -1)
bwInt, err := strconv.ParseInt(bwStr[0], 10, 64)
if err != nil {
logrus.Errorf("error converting bandwidth string to uint64 %+v", err)
return 0, err
}
if strings.ContainsAny(bandwidth, "g|G") {
rate = gigaBytes
} else if strings.ContainsAny(bandwidth, "m|M") {
rate = magaBytes
} else if strings.ContainsAny(bandwidth, "k|K") {
rate = kiloBytes
}
bwInt64 := bwInt * rate
bwInt64 = bwInt64 / 1000
return bwInt64, nil
}
func cuter(line string) (it Item, suc bool) {
items := strings.FieldsFunc(line, fieldFilter)
if len(items) < 2 {
// fmt.Println(line)
return it, false
}
it.word = strings.Replace(items[0], " ", "", -1)
ext_start := 1
for ; ext_start < len(items); ext_start++ {
if strings.ContainsAny(items[ext_start], "[]【】") {
it.ext += strings.Trim(items[ext_start], "[]【】><+ \t")
} else {
break
}
}
meanings := ""
for i := ext_start; i < len(items); i++ {
if strings.ContainsAny(items[i], "0123456789") {
if len(meanings) != 0 {
meanings += "-"
}
meanings += strings.Trim(items[i], "[]【】 \t\r\n-")
}
}
if len(meanings) == 0 {
meanings = items[ext_start]
}
it.meanings = strings.Split(meanings, "-")
return it, true
}
func check_syntax(insane string) bool {
/* State machine; Sane == S3, S1
~ 0\-9 , - * /
S0 S + 2 Err Err S + 3 Err
S1 Err Err Err Err Err
S2 S++ Err Err Err Err
S3 Err S - 3 S + 2 Err S + 2
S4 S - 3 Err Err Err Err
S5 S-- Err Err Err Err
*/
state := 0
for i := 0; i != len(insane); i++ {
if strings.ContainsAny(string(insane[i]), "0123456789") {
if state == 0 {
state += 2
} else if state == 2 {
state++
} else if state == 4 {
state -= 3
} else if state == 5 {
state--
} else {
return false
}
} else if strings.ContainsAny(string(insane[i]), ",") {
if state == 3 {
state -= 3
} else {
return false
}
} else if strings.ContainsAny(string(insane[i]), "-") {
if state == 3 {
state += 2
} else {
return false
}
} else if strings.ContainsAny(string(insane[i]), "*") {
if state == 0 {
state += 3
} else {
return false
}
} else if strings.ContainsAny(string(insane[i]), "/") {
if state == 3 {
state += 2
} else {
return false
}
} else {
return false
}
}
if state == 3 || state == 1 {
return true
} else {
return false
}
}
func main() {
defer func() {
if r := recover(); r != nil {
fmt.Println(r)
os.Exit(1)
}
}()
utils.LogInfo("\nDeploying Agent Server...")
var ln string
var e error
rd := bufio.NewReader(os.Stdin)
for {
ln, e = rd.ReadString('\n')
println(ln)
if e != nil {
panic(e)
} else if strings.ContainsAny(ln, "AGENT_KUBER_API") {
break
}
}
if !strings.ContainsAny(ln, "AGENT_KUBER_API") {
panic("Missing Key, AGENT_KUBER_API. Cannot proceed.")
}
kv := strings.Split(ln, "=")
utils.SetKey("AGENT_KUBER_API", kv[1])
pk, puk, _ := utils.CreateSSHKey()
c := deploy.CenturyLink{
PublicSSHKey: puk,
APIUsername: os.Getenv("USERNAME"),
APIPassword: os.Getenv("PASSWORD"),
GroupID: os.Getenv("GROUP_ID"),
CPU: 1,
MemoryGB: 1,
TCPOpenPorts: []int{3001},
ServerName: "AGENT",
ServerTemplate: "UBUNTU-14-64-TEMPLATE",
}
utils.LogInfo("\nWaiting for server creation...")
s, e := c.DeployVM()
if e != nil {
panic(e)
}
utils.SetKey("AGENT_PRIVATE_KEY", base64.StdEncoding.EncodeToString([]byte(pk)))
utils.SetKey("AGENT_PUBLIC_IP", s.PublicIP)
utils.LogInfo("\nAgent server deployment complete!!")
}
func TestStrings() {
fmt.Println("testStrings---------------------------------")
a := "jiangkou jiangkou"
b := "ang"
fmt.Println("[a=", a, "][b=", b, "]")
//查找某个字符是否在这个字符串中存在，存在返回true
fmt.Println("strings.Contains(a, b) = ", strings.Contains(a, b))
fmt.Println("strings.Contains(b, a) = ", strings.Contains(b, a))
//查询字符串中是否包含多个字符
c := "h&z"
d := "i&o"
fmt.Println("[c=", c, "][d=", d, "]")
fmt.Println("strings.ContainsAny(a, c) = ", strings.ContainsAny(a, c))
fmt.Println("strings.ContainsAny(a, d) = ", strings.ContainsAny(a, d))
//一段字符串中有多少匹配到的字符
fmt.Println("strings.Count(a, b) = ", strings.Count(a, b))
//两个字符串在完全小写的情况下是否相等
e := "JiAnGKOu"
fmt.Println("e=", e)
fmt.Println("strings.EqualFold(a, e) = ", strings.EqualFold(a, e))
//空格来分割字符串最后返回的是[]string的切片
f := "aa bcd efghij"
fmt.Println("f=", f)
fmt.Println("strings.Fields(f) = ", strings.Fields(f))
//根据自定义函数来切分
i := "aa|bcd_d|fgh_i|ej"
j := '|'
fmt.Println("[i=", i, "][j=", j, "]")
fmt.Println(strings.FieldsFunc(i, func(s rune) bool {
if s == rune(j) {
return true
}
return false
}))
fmt.Println("strings.Split(i, string(j)) = ", strings.Split(i, string(j)))
//判断是否以某个字符串开头
g := "jia"
fmt.Println("g=", g)
fmt.Println("strings.HasPrefix(a, g) = ", strings.HasPrefix(a, g))
//判断是否以某个字符串结尾
h := "ou"
fmt.Println("h=", h)
fmt.Println("strings.HasSuffix(a, h) = ", strings.HasSuffix(a, h))
// 字符串替换
r := "welcome to shenzhen china"
fmt.Print("orld str : ", r)
r = strings.Replace(r, " ", ",", -1)
fmt.Print(",replace str : ", r)
}
func (s *XLSuite) noDotsOrDashes(rng *xr.PRNG) string {
var length int = 3 + rng.Intn(16)
var name = rng.NextFileName(length)
for len(name) < 3 || strings.ContainsAny(name, ".-") ||
strings.ContainsAny(name[0:1], "0123456789") {
name = rng.NextFileName(length)
}
return name
}
func main() {
fmt.Println(strings.Contains("Assume", "Ass"))
fmt.Println(strings.ContainsAny("team", "i"))
fmt.Println(strings.ContainsAny("Hello", "aeiou&y"))
fmt.Println(strings.HasPrefix("Hello World", "Hello"))
fmt.Println(strings.HasSuffix("Hello World", "World"))
}
func validVersion(version VersionInfo) bool {
stopChars := " \t\r\n/"
if strings.ContainsAny(version.Name(), stopChars) {
return false
}
if strings.ContainsAny(version.Version(), stopChars) {
return false
}
return true
}
func main() {
s := "Hello world"
s_equal := "Hello world"
s_not := "world, Hello"
// Simply iterate over string
for _, c := range s {
fmt.Printf("%c\n", c)
}
arr := []rune(s)
for _, r := range arr {
fmt.Printf("%d\n", r)
}
fmt.Printf("s := %s\n", s)
fmt.Printf("s_equal := %s\n", s_equal)
fmt.Printf("s_not := %s\n", s_not)
//Compare returns an integer comparing two strings lexicographically.
// The result will be 0 if a==b, -1 if a < b, and +1 if a > b
fmt.Printf("equal: %d\n", strings.Compare(s, s_equal))
fmt.Printf("not equal: %d\n", strings.Compare(s, s_not))
//Contains reports whether substr is within s.
fmt.Printf("check if \"world\" is substr of s: %v\n", strings.Contains(s, "world"))
fmt.Printf("check in \"cat\" is substr of s: %v\n", strings.Contains(s, "cat"))
// ContainsAny reports whether any Unicode code points in chars are within s.
fmt.Printf("any of \"abcd\" in s: %v\n", strings.ContainsAny(s, "abcd"))
fmt.Printf("any of \"mkt\" in s: %v\n", strings.ContainsAny(s, "mkt"))
// ContainsRune reports whether the Unicode code point r is within s.
fmt.Printf("find rune 72 is s: %v\n", strings.ContainsRune(s, 72))
//ToLower
fmt.Printf("lowercase: %s\n", strings.ToLower(s))
//ToUpper
fmt.Printf("uppercase: %s\n", strings.ToUpper(s))
sentence := "Simple sentence with many words"
words := strings.Split(sentence, " ")
fmt.Printf("%v\n", words)
//Split with many whitespaces : strings.Fields
words = strings.Fields(sentence)
fmt.Printf("%v\n", words)
}
// Validate runs sanity checks on a Template struct.
// This should catch most errors before attempting a doomed API call.
func (t *Template) Validate() error {
if t == nil {
return fmt.Errorf("Can't Validate a nil Template")
}
if t.Content.EmailRFC822 != "" {
// TODO: optionally validate MIME structure
// if MIME content is present, clobber all other Content options
t.Content = Content{EmailRFC822: t.Content.EmailRFC822}
return nil
}
// enforce required parameters
if t.Content.Subject == "" {
return fmt.Errorf("Template requires a non-empty Content.Subject")
} else if t.Content.HTML == "" && t.Content.Text == "" {
return fmt.Errorf("Template requires either Content.HTML or Content.Text")
}
_, err := ParseFrom(t.Content.From)
if err != nil {
return err
}
if len(t.Content.Attachments) > 0 {
for _, att := range t.Content.Attachments {
if len(att.Filename) > 255 {
return fmt.Errorf("Attachment name length must be <= 255: [%s]", att.Filename)
} else if strings.ContainsAny(att.B64Data, "\r\n") {
return fmt.Errorf("Attachment data may not contain line breaks [\\r\\n]")
}
}
}
if len(t.Content.InlineImages) > 0 {
for _, img := range t.Content.InlineImages {
if len(img.Filename) > 255 {
return fmt.Errorf("InlineImage name length must be <= 255: [%s]", img.Filename)
} else if strings.ContainsAny(img.B64Data, "\r\n") {
return fmt.Errorf("InlineImage data may not contain line breaks [\\r\\n]")
}
}
}
// enforce max lengths
if len(t.ID) > 64 {
return fmt.Errorf("Template id may not be longer than 64 bytes")
} else if len(t.Name) > 1024 {
return fmt.Errorf("Template name may not be longer than 1024 bytes")
} else if len(t.Description) > 1024 {
return fmt.Errorf("Template description may not be longer than 1024 bytes")
}
return nil
}
func (s *XLSuite) getAName(rng *xr.PRNG) (name string) {
name = string(rng.NextFileName(8))
for {
first := string(name[0])
if !strings.ContainsAny(name, "-_.") && !strings.ContainsAny(first, "0123456789") {
break
}
name = string(rng.NextFileName(8))
}
return
}
func ExampleContainsAny() {
fmt.Println(strings.ContainsAny("team", "i"))
fmt.Println(strings.ContainsAny("failure", "u & i"))
fmt.Println(strings.ContainsAny("foo", ""))
fmt.Println(strings.ContainsAny("", ""))
// Output:
// false
// true
// false
// false
}
func IsPasswordValid(password string) *model.AppError {
id := "model.user.is_valid.pwd"
isError := false
min := model.PASSWORD_MINIMUM_LENGTH
if IsLicensed && *License.Features.PasswordRequirements {
if len(password) < *Cfg.PasswordSettings.MinimumLength || len(password) > model.PASSWORD_MAXIMUM_LENGTH {
isError = true
}
if *Cfg.PasswordSettings.Lowercase {
if !strings.ContainsAny(password, model.LOWERCASE_LETTERS) {
isError = true
}
id = id + "_lowercase"
}
if *Cfg.PasswordSettings.Uppercase {
if !strings.ContainsAny(password, model.UPPERCASE_LETTERS) {
isError = true
}
id = id + "_uppercase"
}
if *Cfg.PasswordSettings.Number {
if !strings.ContainsAny(password, model.NUMBERS) {
isError = true
}
id = id + "_number"
}
if *Cfg.PasswordSettings.Symbol {
if !strings.ContainsAny(password, model.SYMBOLS) {
isError = true
}
id = id + "_symbol"
}
min = *Cfg.PasswordSettings.MinimumLength
} else if len(password) > model.PASSWORD_MAXIMUM_LENGTH || len(password) < model.PASSWORD_MINIMUM_LENGTH {
isError = true
min = model.PASSWORD_MINIMUM_LENGTH
}
if isError {
return model.NewLocAppError("User.IsValid", id+".app_error", map[string]interface{}{"Min": min}, "")
}
return nil
}
func TestPasswordGeneration(t *testing.T) {
assert := assert.Assert(t)
generator := NewPasswordGenerator("lunc20")
assert.Equal(generator.length, 20)
password := generator.generate()
assert.Equal(len(password), 20)
assert.True(strings.ContainsAny(password, LOWERCASE), "missing characters")
assert.True(strings.ContainsAny(password, UPPERCASE), "missing characters")
assert.True(strings.ContainsAny(password, NUMBERS), "missing characters")
assert.True(strings.ContainsAny(password, CHARACTERS), "missing characters")
}
// Function EditKey guides the user through editing a key in the key store.
func EditKey(ks KeyStore, KeyID string, secret []byte) {
var editKey Key
ks.Open(secret)
editKey, ok := ks[KeyID]
if ok {
reader := bufio.NewReader(os.Stdin)
fmt.Printf("What would you like to change?\n")
fmt.Printf("Enter the first letter of each item you wish to edit: -\n")
fmt.Printf("(L)oginname, (P)assword, (D)etail or (A)ll : ")
input, err := reader.ReadString('\n')
if err != nil {
handleUserError(err)
}
// Edit the Login name
if strings.ContainsAny(input, "LA") {
fmt.Printf("Enter the new login name: ")
newLoginname, err := reader.ReadString('\n')
if err != nil {
handleUserError(err)
}
newLoginname = strings.Trim(newLoginname, "\n")
editKey.LoginName = newLoginname
}
// Edit the password
if strings.ContainsAny(input, "PA") {
fmt.Printf("Enter the new password: "******"\n")
editKey.OldPassword = editKey.Password
editKey.Password = newPassword
}
// Edit the Detail
if strings.ContainsAny(input, "DA") {
fmt.Printf("Enter the new details: ")
newDetail, err := reader.ReadString('\n')
if err != nil {
handleUserError(err)
}
newDetail = strings.Trim(newDetail, "\n")
editKey.Detail = newDetail
}
ks[KeyID] = editKey
ks.Close(secret)
}
}
// PartBagByName finds a PartBag with the given name.
func PartBagByName(name string, origin string) *PartBag {
if strings.ContainsAny(name, ".*?/") || strings.ContainsAny(origin, ".*?/") {
panic("invalid name " + name + "." + origin)
}
for _, v := range find(name, origin) {
return v
}
return nil
}
func validVersion(version VersionInfo) bool {
const stopChars = " \t\r\n/"
name := version.Name()
vers := version.Version()
if len(name) == 0 || strings.ContainsAny(name, stopChars) {
return false
}
if len(vers) == 0 || strings.ContainsAny(vers, stopChars) {
return false
}
return true
}
func (vi *UAVersionInfo) isValid() bool {
const stopChars = " \t\r\n/"
name := vi.Name
vers := vi.Version
if len(name) == 0 || strings.ContainsAny(name, stopChars) {
return false
}
if len(vers) == 0 || strings.ContainsAny(vers, stopChars) {
return false
}
return true
}
func (p *UserAgent) normalizeApple(comments []string) {
if p.Platform == "IPhone" ||
p.Platform == "IPad" ||
p.Platform == "IPod" ||
p.Platform == "AppleTV" {
// some Apple UAs don't separate by "; ", but by ";"
if strings.Contains(p.Platform, ";") {
tmp := strings.Split(p.Platform, ";")
p.Platform = tmp[0]
comments = tmp[1:]
}
// set OS to IOS with the version limited to Major.Minor
for _, com := range comments {
if strings.ContainsAny(com, "0123456789") {
o := strings.Split(com, " ")
v := []string{}
if len(o) >= 4 && strings.ContainsAny(o[3], "0123456789") {
v = strings.Split(o[3], "_")
} else if len(o) >= 3 && strings.ContainsAny(o[2], "0123456789") {
v = strings.Split(o[2], "_")
}
if len(v) >= 2 {
p.OS = "IOS"
p.OSVer = v[0] + "." + v[1]
return
}
}
}
p.OS = "IOS Unknown"
return
} else if p.Platform == "Macintosh" {
// set OS to OSX with the version limited to Major.Minor
for _, com := range comments {
if strings.ContainsAny(com, "0123456789") {
o := strings.Split(com, " ")
if len(o) >= 5 && strings.ContainsAny(o[4], "0123456789") {
v := strings.Split(o[4], "_")
if len(v) >= 2 {
p.OS = "OSX"
p.OSVer = v[0] + "." + v[1]
return
}
}
}
}
p.OS = "OSX Unknown"
return
}
}
// 查询条件处理（TODO:暂时没有处理between和in）
func (this *Dao) Where(condition string) {
this.whereVal = make([]interface{}, 0)
stringBuilder := util.NewBuffer()
conditions := SplitIn(condition, []string{" and ", " AND ", " or ", " OR "}...)
for _, condition := range conditions {
condition = strings.TrimSpace(condition)
parts := SplitIn(condition, "=", "<", ">")
if len(parts) >= 3 {
// 处理不等于
if strings.HasSuffix(parts[0], "!") {
stringBuilder.Append("`" + strings.Trim(parts[0], "` !") + "` !")
} else {
stringBuilder.Append("`" + strings.Trim(parts[0], "` ") + "`")
}
stringBuilder.Append(strings.TrimSpace(parts[1]))
if len(parts) > 3 {
// 判断是不是 ">="或"<="
if strings.ContainsAny(parts[2], "= & < & >") {
stringBuilder.Append(strings.TrimSpace(parts[2]))
}
start := len(parts[0]) + len(parts[1]) + 1
this.whereVal = append(this.whereVal, strings.TrimSpace(condition[start:]))
} else {
this.whereVal = append(this.whereVal, strings.TrimSpace(parts[2]))
}
stringBuilder.Append("?")
} else {
tmp := strings.ToUpper(parts[0])
if tmp == "OR" || tmp == "AND" {
stringBuilder.Append(" ").Append(tmp).Append(" ")
} else {
// 处理"in"语句（TODO:用正则处理？）
if strings.ContainsAny(strings.ToLower(parts[0]), "in & ( & )") {
ins := Split(parts[0], "(", ")")
if len(ins) == 3 {
inVals := strings.Split(ins[1], ",")
for _, inVal := range inVals {
this.whereVal = append(this.whereVal, inVal)
}
// in中有多少个值
inLen := len(inVals)
qms := strings.Repeat("?,", inLen)
field := ins[0][:len(ins[0])-3]
stringBuilder.Append("`" + strings.Trim(field, "` ") + "` in").Append("(").Append(qms[:len(qms)-1]).Append(")")
}
} else {
stringBuilder.Append("`" + strings.Trim(parts[0], "` ") + "`")
}
}
}
}
this.where = stringBuilder.String()
}
func intMode(mode string) types.IntMode {
var m types.IntMode
if strings.ContainsAny(mode, "dD") {
m |= types.Dec
}
if strings.ContainsAny(mode, "hH") {
m |= types.Hex
}
if strings.ContainsAny(mode, "oO") {
m |= types.Oct
}
return m
}
// Testing class output
func TestAddingHtmlProperties(t *testing.T) {
m := make(map[string]string)
m["class"] = "testclass"
m["data-id"] = "3"
field := NewField()
field.Props = m
prop := field.getHtmlProperties()
assert.Equal(t, true, strings.ContainsAny(prop, "class=\"testclass\""))
assert.Equal(t, true, strings.ContainsAny(prop, "data-id=\"3\""))
}