1 // Copyright 2019 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4 5 // Package strs provides string manipulation functionality specific to protobuf.
6 package strs
7 8 import (
9 "go/token"
10 "strings"
11 "unicode"
12 "unicode/utf8"
13 14 "google.golang.org/protobuf/internal/flags"
15 "google.golang.org/protobuf/reflect/protoreflect"
16 )
17 18 // EnforceUTF8 reports whether to enforce strict UTF-8 validation.
19 func EnforceUTF8(fd protoreflect.FieldDescriptor) bool {
20 if flags.ProtoLegacy || fd.Syntax() == protoreflect.Editions {
21 if fd, ok := fd.(interface{ EnforceUTF8() bool }); ok {
22 return fd.EnforceUTF8()
23 }
24 }
25 return fd.Syntax() == protoreflect.Proto3
26 }
27 28 // GoCamelCase camel-cases a protobuf name for use as a Go identifier.
29 //
30 // If there is an interior underscore followed by a lower case letter,
31 // drop the underscore and convert the letter to upper case.
32 func GoCamelCase(s string) string {
33 // Invariant: if the next letter is lower case, it must be converted
34 // to upper case.
35 // That is, we process a word at a time, where words are marked by _ or
36 // upper case letter. Digits are treated as words.
37 var b []byte
38 for i := 0; i < len(s); i++ {
39 c := s[i]
40 switch {
41 case c == '.' && i+1 < len(s) && isASCIILower(s[i+1]):
42 // Skip over '.' in ".{{lowercase}}".
43 case c == '.':
44 b = append(b, '_') // convert '.' to '_'
45 case c == '_' && (i == 0 || s[i-1] == '.'):
46 // Convert initial '_' to ensure we start with a capital letter.
47 // Do the same for '_' after '.' to match historic behavior.
48 b = append(b, 'X') // convert '_' to 'X'
49 case c == '_' && i+1 < len(s) && isASCIILower(s[i+1]):
50 // Skip over '_' in "_{{lowercase}}".
51 case isASCIIDigit(c):
52 b = append(b, c)
53 default:
54 // Assume we have a letter now - if not, it's a bogus identifier.
55 // The next word is a sequence of characters that must start upper case.
56 if isASCIILower(c) {
57 c -= 'a' - 'A' // convert lowercase to uppercase
58 }
59 b = append(b, c)
60 61 // Accept lower case sequence that follows.
62 for ; i+1 < len(s) && isASCIILower(s[i+1]); i++ {
63 b = append(b, s[i+1])
64 }
65 }
66 }
67 return string(b)
68 }
69 70 // GoSanitized converts a string to a valid Go identifier.
71 func GoSanitized(s string) string {
72 // Sanitize the input to the set of valid characters,
73 // which must be '_' or be in the Unicode L or N categories.
74 s = strings.Map(func(r rune) rune {
75 if unicode.IsLetter(r) || unicode.IsDigit(r) {
76 return r
77 }
78 return '_'
79 }, s)
80 81 // Prepend '_' in the event of a Go keyword conflict or if
82 // the identifier is invalid (does not start in the Unicode L category).
83 r, _ := utf8.DecodeRuneInString(s)
84 if token.Lookup(s).IsKeyword() || !unicode.IsLetter(r) {
85 return "_" + s
86 }
87 return s
88 }
89 90 // JSONCamelCase converts a snake_case identifier to a camelCase identifier,
91 // according to the protobuf JSON specification.
92 func JSONCamelCase(s string) string {
93 var b []byte
94 var wasUnderscore bool
95 for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
96 c := s[i]
97 if c != '_' {
98 if wasUnderscore && isASCIILower(c) {
99 c -= 'a' - 'A' // convert to uppercase
100 }
101 b = append(b, c)
102 }
103 wasUnderscore = c == '_'
104 }
105 return string(b)
106 }
107 108 // JSONSnakeCase converts a camelCase identifier to a snake_case identifier,
109 // according to the protobuf JSON specification.
110 func JSONSnakeCase(s string) string {
111 var b []byte
112 for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
113 c := s[i]
114 if isASCIIUpper(c) {
115 b = append(b, '_')
116 c += 'a' - 'A' // convert to lowercase
117 }
118 b = append(b, c)
119 }
120 return string(b)
121 }
122 123 // MapEntryName derives the name of the map entry message given the field name.
124 // See protoc v3.8.0: src/google/protobuf/descriptor.cc:254-276,6057
125 func MapEntryName(s string) string {
126 var b []byte
127 upperNext := true
128 for _, c := range s {
129 switch {
130 case c == '_':
131 upperNext = true
132 case upperNext:
133 b = append(b, byte(unicode.ToUpper(c)))
134 upperNext = false
135 default:
136 b = append(b, byte(c))
137 }
138 }
139 b = append(b, "Entry"...)
140 return string(b)
141 }
142 143 // EnumValueName derives the camel-cased enum value name.
144 // See protoc v3.8.0: src/google/protobuf/descriptor.cc:297-313
145 func EnumValueName(s string) string {
146 var b []byte
147 upperNext := true
148 for _, c := range s {
149 switch {
150 case c == '_':
151 upperNext = true
152 case upperNext:
153 b = append(b, byte(unicode.ToUpper(c)))
154 upperNext = false
155 default:
156 b = append(b, byte(unicode.ToLower(c)))
157 upperNext = false
158 }
159 }
160 return string(b)
161 }
162 163 // TrimEnumPrefix trims the enum name prefix from an enum value name,
164 // where the prefix is all lowercase without underscores.
165 // See protoc v3.8.0: src/google/protobuf/descriptor.cc:330-375
166 func TrimEnumPrefix(s, prefix string) string {
167 s0 := s // original input
168 for len(s) > 0 && len(prefix) > 0 {
169 if s[0] == '_' {
170 s = s[1:]
171 continue
172 }
173 if unicode.ToLower(rune(s[0])) != rune(prefix[0]) {
174 return s0 // no prefix match
175 }
176 s, prefix = s[1:], prefix[1:]
177 }
178 if len(prefix) > 0 {
179 return s0 // no prefix match
180 }
181 s = strings.TrimLeft(s, "_")
182 if len(s) == 0 {
183 return s0 // avoid returning empty string
184 }
185 return s
186 }
187 188 func isASCIILower(c byte) bool {
189 return 'a' <= c && c <= 'z'
190 }
191 func isASCIIUpper(c byte) bool {
192 return 'A' <= c && c <= 'Z'
193 }
194 func isASCIIDigit(c byte) bool {
195 return '0' <= c && c <= '9'
196 }
197