+61

internal/str/path.go

reviewed

··· 1 1 + // Copyright 2018 The CUE Authors 2 2 + // 3 3 + // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 + // you may not use this file except in compliance with the License. 5 5 + // You may obtain a copy of the License at 6 6 + // 7 7 + // http://www.apache.org/licenses/LICENSE-2.0 8 8 + // 9 9 + // Unless required by applicable law or agreed to in writing, software 10 10 + // distributed under the License is distributed on an "AS IS" BASIS, 11 11 + // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 + // See the License for the specific language governing permissions and 13 13 + // limitations under the License. 14 14 + 15 15 + package str 16 16 + 17 17 + import ( 18 18 + "path/filepath" 19 19 + "strings" 20 20 + ) 21 21 + 22 22 + // HasPath reports whether the slash-separated path s 23 23 + // begins with the elements in prefix. 24 24 + func HasPathPrefix(s, prefix string) bool { 25 25 + if len(s) == len(prefix) { 26 26 + return s == prefix 27 27 + } 28 28 + if prefix == "" { 29 29 + return true 30 30 + } 31 31 + if len(s) > len(prefix) { 32 32 + if prefix[len(prefix)-1] == '/' || s[len(prefix)] == '/' { 33 33 + return s[:len(prefix)] == prefix 34 34 + } 35 35 + } 36 36 + return false 37 37 + } 38 38 + 39 39 + // HasFilePathPrefix reports whether the filesystem path s 40 40 + // begins with the elements in prefix. 41 41 + func HasFilePathPrefix(s, prefix string) bool { 42 42 + sv := strings.ToUpper(filepath.VolumeName(s)) 43 43 + pv := strings.ToUpper(filepath.VolumeName(prefix)) 44 44 + s = s[len(sv):] 45 45 + prefix = prefix[len(pv):] 46 46 + switch { 47 47 + default: 48 48 + return false 49 49 + case sv != pv: 50 50 + return false 51 51 + case len(s) == len(prefix): 52 52 + return s == prefix 53 53 + case prefix == "": 54 54 + return true 55 55 + case len(s) > len(prefix): 56 56 + if prefix[len(prefix)-1] == filepath.Separator { 57 57 + return strings.HasPrefix(s, prefix) 58 58 + } 59 59 + return s[len(prefix)] == filepath.Separator && s[:len(prefix)] == prefix 60 60 + } 61 61 + }

+151

internal/str/str.go

reviewed

··· 1 1 + // Copyright 2018 The CUE Authors 2 2 + // 3 3 + // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 + // you may not use this file except in compliance with the License. 5 5 + // You may obtain a copy of the License at 6 6 + // 7 7 + // http://www.apache.org/licenses/LICENSE-2.0 8 8 + // 9 9 + // Unless required by applicable law or agreed to in writing, software 10 10 + // distributed under the License is distributed on an "AS IS" BASIS, 11 11 + // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 + // See the License for the specific language governing permissions and 13 13 + // limitations under the License. 14 14 + 15 15 + // Package str provides string manipulation utilities. 16 16 + package str // import "cuelang.org/go/internal/str" 17 17 + 18 18 + import ( 19 19 + "bytes" 20 20 + "fmt" 21 21 + "unicode" 22 22 + "unicode/utf8" 23 23 + ) 24 24 + 25 25 + // StringList flattens its arguments into a single []string. 26 26 + // Each argument in args must have type string or []string. 27 27 + func StringList(args ...interface{}) []string { 28 28 + var x []string 29 29 + for _, arg := range args { 30 30 + switch arg := arg.(type) { 31 31 + case []string: 32 32 + x = append(x, arg...) 33 33 + case string: 34 34 + x = append(x, arg) 35 35 + default: 36 36 + panic("stringList: invalid argument of type " + fmt.Sprintf("%T", arg)) 37 37 + } 38 38 + } 39 39 + return x 40 40 + } 41 41 + 42 42 + // ToFold returns a string with the property that 43 43 + // strings.EqualFold(s, t) iff ToFold(s) == ToFold(t) 44 44 + // This lets us test a large set of strings for fold-equivalent 45 45 + // duplicates without making a quadratic number of calls 46 46 + // to EqualFold. Note that strings.ToUpper and strings.ToLower 47 47 + // do not have the desired property in some corner cases. 48 48 + func ToFold(s string) string { 49 49 + // Fast path: all ASCII, no upper case. 50 50 + // Most paths look like this already. 51 51 + for i := 0; i < len(s); i++ { 52 52 + c := s[i] 53 53 + if c >= utf8.RuneSelf || 'A' <= c && c <= 'Z' { 54 54 + goto Slow 55 55 + } 56 56 + } 57 57 + return s 58 58 + 59 59 + Slow: 60 60 + var buf bytes.Buffer 61 61 + for _, r := range s { 62 62 + // SimpleFold(x) cycles to the next equivalent rune > x 63 63 + // or wraps around to smaller values. Iterate until it wraps, 64 64 + // and we've found the minimum value. 65 65 + for { 66 66 + r0 := r 67 67 + r = unicode.SimpleFold(r0) 68 68 + if r <= r0 { 69 69 + break 70 70 + } 71 71 + } 72 72 + // Exception to allow fast path above: A-Z => a-z 73 73 + if 'A' <= r && r <= 'Z' { 74 74 + r += 'a' - 'A' 75 75 + } 76 76 + buf.WriteRune(r) 77 77 + } 78 78 + return buf.String() 79 79 + } 80 80 + 81 81 + // FoldDup reports a pair of strings from the list that are 82 82 + // equal according to strings.EqualFold. 83 83 + // It returns "", "" if there are no such strings. 84 84 + func FoldDup(list []string) (string, string) { 85 85 + clash := map[string]string{} 86 86 + for _, s := range list { 87 87 + fold := ToFold(s) 88 88 + if t := clash[fold]; t != "" { 89 89 + if s > t { 90 90 + s, t = t, s 91 91 + } 92 92 + return s, t 93 93 + } 94 94 + clash[fold] = s 95 95 + } 96 96 + return "", "" 97 97 + } 98 98 + 99 99 + // Contains reports whether x contains s. 100 100 + func Contains(x []string, s string) bool { 101 101 + for _, t := range x { 102 102 + if t == s { 103 103 + return true 104 104 + } 105 105 + } 106 106 + return false 107 107 + } 108 108 + 109 109 + func isSpaceByte(c byte) bool { 110 110 + return c == ' ' || c == '\t' || c == '\n' || c == '\r' 111 111 + } 112 112 + 113 113 + // SplitQuotedFields splits s into a list of fields, 114 114 + // allowing single or double quotes around elements. 115 115 + // There is no unescaping or other processing within 116 116 + // quoted fields. 117 117 + func SplitQuotedFields(s string) ([]string, error) { 118 118 + // Split fields allowing '' or "" around elements. 119 119 + // Quotes further inside the string do not count. 120 120 + var f []string 121 121 + for len(s) > 0 { 122 122 + for len(s) > 0 && isSpaceByte(s[0]) { 123 123 + s = s[1:] 124 124 + } 125 125 + if len(s) == 0 { 126 126 + break 127 127 + } 128 128 + // Accepted quoted string. No unescaping inside. 129 129 + if s[0] == '"' || s[0] == '\'' { 130 130 + quote := s[0] 131 131 + s = s[1:] 132 132 + i := 0 133 133 + for i < len(s) && s[i] != quote { 134 134 + i++ 135 135 + } 136 136 + if i >= len(s) { 137 137 + return nil, fmt.Errorf("unterminated %c string", quote) 138 138 + } 139 139 + f = append(f, s[:i]) 140 140 + s = s[i+1:] 141 141 + continue 142 142 + } 143 143 + i := 0 144 144 + for i < len(s) && !isSpaceByte(s[i]) { 145 145 + i++ 146 146 + } 147 147 + f = append(f, s[:i]) 148 148 + s = s[i:] 149 149 + } 150 150 + return f, nil 151 151 + }