gtsocial-umbx

strings.go (5362B)

---

 // Copyright 2019 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package strs provides string manipulation functionality specific to protobuf.
 package strs
 
 import (
 	"go/token"
 	"strings"
 	"unicode"
 	"unicode/utf8"
 
 	"google.golang.org/protobuf/internal/flags"
 	"google.golang.org/protobuf/reflect/protoreflect"
 )
 
 // EnforceUTF8 reports whether to enforce strict UTF-8 validation.
 func EnforceUTF8(fd protoreflect.FieldDescriptor) bool {
 	if flags.ProtoLegacy {
 		if fd, ok := fd.(interface{ EnforceUTF8() bool }); ok {
 			return fd.EnforceUTF8()
 		}
 	}
 	return fd.Syntax() == protoreflect.Proto3
 }
 
 // GoCamelCase camel-cases a protobuf name for use as a Go identifier.
 //
 // If there is an interior underscore followed by a lower case letter,
 // drop the underscore and convert the letter to upper case.
 func GoCamelCase(s string) string {
 	// Invariant: if the next letter is lower case, it must be converted
 	// to upper case.
 	// That is, we process a word at a time, where words are marked by _ or
 	// upper case letter. Digits are treated as words.
 	var b []byte
 	for i := 0; i < len(s); i++ {
 		c := s[i]
 		switch {
 		case c == '.' && i+1 < len(s) && isASCIILower(s[i+1]):
 			// Skip over '.' in ".{{lowercase}}".
 		case c == '.':
 			b = append(b, '_') // convert '.' to '_'
 		case c == '_' && (i == 0 || s[i-1] == '.'):
 			// Convert initial '_' to ensure we start with a capital letter.
 			// Do the same for '_' after '.' to match historic behavior.
 			b = append(b, 'X') // convert '_' to 'X'
 		case c == '_' && i+1 < len(s) && isASCIILower(s[i+1]):
 			// Skip over '_' in "_{{lowercase}}".
 		case isASCIIDigit(c):
 			b = append(b, c)
 		default:
 			// Assume we have a letter now - if not, it's a bogus identifier.
 			// The next word is a sequence of characters that must start upper case.
 			if isASCIILower(c) {
 				c -= 'a' - 'A' // convert lowercase to uppercase
 			}
 			b = append(b, c)
 
 			// Accept lower case sequence that follows.
 			for ; i+1 < len(s) && isASCIILower(s[i+1]); i++ {
 				b = append(b, s[i+1])
 			}
 		}
 	}
 	return string(b)
 }
 
 // GoSanitized converts a string to a valid Go identifier.
 func GoSanitized(s string) string {
 	// Sanitize the input to the set of valid characters,
 	// which must be '_' or be in the Unicode L or N categories.
 	s = strings.Map(func(r rune) rune {
 		if unicode.IsLetter(r) || unicode.IsDigit(r) {
 			return r
 		}
 		return '_'
 	}, s)
 
 	// Prepend '_' in the event of a Go keyword conflict or if
 	// the identifier is invalid (does not start in the Unicode L category).
 	r, _ := utf8.DecodeRuneInString(s)
 	if token.Lookup(s).IsKeyword() || !unicode.IsLetter(r) {
 		return "_" + s
 	}
 	return s
 }
 
 // JSONCamelCase converts a snake_case identifier to a camelCase identifier,
 // according to the protobuf JSON specification.
 func JSONCamelCase(s string) string {
 	var b []byte
 	var wasUnderscore bool
 	for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
 		c := s[i]
 		if c != '_' {
 			if wasUnderscore && isASCIILower(c) {
 				c -= 'a' - 'A' // convert to uppercase
 			}
 			b = append(b, c)
 		}
 		wasUnderscore = c == '_'
 	}
 	return string(b)
 }
 
 // JSONSnakeCase converts a camelCase identifier to a snake_case identifier,
 // according to the protobuf JSON specification.
 func JSONSnakeCase(s string) string {
 	var b []byte
 	for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
 		c := s[i]
 		if isASCIIUpper(c) {
 			b = append(b, '_')
 			c += 'a' - 'A' // convert to lowercase
 		}
 		b = append(b, c)
 	}
 	return string(b)
 }
 
 // MapEntryName derives the name of the map entry message given the field name.
 // See protoc v3.8.0: src/google/protobuf/descriptor.cc:254-276,6057
 func MapEntryName(s string) string {
 	var b []byte
 	upperNext := true
 	for _, c := range s {
 		switch {
 		case c == '_':
 			upperNext = true
 		case upperNext:
 			b = append(b, byte(unicode.ToUpper(c)))
 			upperNext = false
 		default:
 			b = append(b, byte(c))
 		}
 	}
 	b = append(b, "Entry"...)
 	return string(b)
 }
 
 // EnumValueName derives the camel-cased enum value name.
 // See protoc v3.8.0: src/google/protobuf/descriptor.cc:297-313
 func EnumValueName(s string) string {
 	var b []byte
 	upperNext := true
 	for _, c := range s {
 		switch {
 		case c == '_':
 			upperNext = true
 		case upperNext:
 			b = append(b, byte(unicode.ToUpper(c)))
 			upperNext = false
 		default:
 			b = append(b, byte(unicode.ToLower(c)))
 			upperNext = false
 		}
 	}
 	return string(b)
 }
 
 // TrimEnumPrefix trims the enum name prefix from an enum value name,
 // where the prefix is all lowercase without underscores.
 // See protoc v3.8.0: src/google/protobuf/descriptor.cc:330-375
 func TrimEnumPrefix(s, prefix string) string {
 	s0 := s // original input
 	for len(s) > 0 && len(prefix) > 0 {
 		if s[0] == '_' {
 			s = s[1:]
 			continue
 		}
 		if unicode.ToLower(rune(s[0])) != rune(prefix[0]) {
 			return s0 // no prefix match
 		}
 		s, prefix = s[1:], prefix[1:]
 	}
 	if len(prefix) > 0 {
 		return s0 // no prefix match
 	}
 	s = strings.TrimLeft(s, "_")
 	if len(s) == 0 {
 		return s0 // avoid returning empty string
 	}
 	return s
 }
 
 func isASCIILower(c byte) bool {
 	return 'a' <= c && c <= 'z'
 }
 func isASCIIUpper(c byte) bool {
 	return 'A' <= c && c <= 'Z'
 }
 func isASCIIDigit(c byte) bool {
 	return '0' <= c && c <= '9'
 }