FilesExpand file tree

 master

/

stringutils.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

87 lines (76 loc) · 2.03 KB

 master

/

stringutils.go

Copy path

Top

File metadata and controls

• Code
• Blame

87 lines (76 loc) · 2.03 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

// Package stringutils provides helper functions for dealing with strings.

package stringutils

import (

"bytes"

"math/rand"

"strings"

"github.com/docker/docker/pkg/random"

)

// GenerateRandomAlphaOnlyString generates an alphabetical random string with length n.

func GenerateRandomAlphaOnlyString(n int) string {

// make a really long string

letters := []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

b := make([]byte, n)

for i := range b {

b[i] = letters[random.Rand.Intn(len(letters))]

}

return string(b)

}

// GenerateRandomASCIIString generates an ASCII random string with length n.

func GenerateRandomASCIIString(n int) string {

chars := "abcdefghijklmnopqrstuvwxyz" +

"ABCDEFGHIJKLMNOPQRSTUVWXYZ" +

"~!@#$%^&*()-_+={}[]\\|<,>.?/\"';:` "

res := make([]byte, n)

for i := 0; i < n; i++ {

res[i] = chars[rand.Intn(len(chars))]

}

return string(res)

}

// Truncate truncates a string to maxlen.

func Truncate(s string, maxlen int) string {

if len(s) <= maxlen {

return s

}

return s[:maxlen]

}

// InSlice tests whether a string is contained in a slice of strings or not.

// Comparison is case insensitive

func InSlice(slice []string, s string) bool {

for _, ss := range slice {

if strings.ToLower(s) == strings.ToLower(ss) {

return true

}

}

return false

}

func quote(word string, buf *bytes.Buffer) {

// Bail out early for "simple" strings

if word != "" && !strings.ContainsAny(word, "\\'\"`${[|&;<>()~*?! \t\n") {

buf.WriteString(word)

return

}

buf.WriteString("'")

for i := 0; i < len(word); i++ {

b := word[i]

if b == '\'' {

// Replace literal ' with a close ', a \', and a open '

buf.WriteString("'\\''")

} else {

buf.WriteByte(b)

}

}

buf.WriteString("'")

}

// ShellQuoteArguments takes a list of strings and escapes them so they will be

// handled right when passed as arguments to a program via a shell

func ShellQuoteArguments(args []string) string {

var buf bytes.Buffer

for i, arg := range args {

if i != 0 {

buf.WriteByte(' ')

}

quote(arg, &buf)

}

return buf.String()

}