From 2f0f70a57c6e32bc17a2698ce057b137fd5cc403 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 9 Feb 2026 01:43:53 +0000 Subject: [PATCH] Bump github.com/kenshaw/snaker from 0.2.0 to 0.4.3 Bumps [github.com/kenshaw/snaker](https://github.com/kenshaw/snaker) from 0.2.0 to 0.4.3. - [Commits](https://github.com/kenshaw/snaker/compare/v0.2.0...v0.4.3) --- updated-dependencies: - dependency-name: github.com/kenshaw/snaker dependency-version: 0.4.3 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- go.mod | 2 +- go.sum | 4 +- .../github.com/kenshaw/snaker/.golangci.yml | 20 ++ vendor/github.com/kenshaw/snaker/LICENSE | 2 +- vendor/github.com/kenshaw/snaker/README.md | 28 ++- .../github.com/kenshaw/snaker/initialisms.go | 101 ++++----- vendor/github.com/kenshaw/snaker/snaker.go | 212 ++++++++++-------- vendor/modules.txt | 4 +- 8 files changed, 208 insertions(+), 165 deletions(-) create mode 100644 vendor/github.com/kenshaw/snaker/.golangci.yml diff --git a/go.mod b/go.mod index 9fc6d0b69..2bf4bc2e3 100644 --- a/go.mod +++ b/go.mod @@ -37,7 +37,7 @@ require ( github.com/jackc/pgx/v5 v5.6.0 github.com/joho/godotenv v1.5.1 github.com/kenshaw/inflector v0.2.0 - github.com/kenshaw/snaker v0.2.0 + github.com/kenshaw/snaker v0.4.3 github.com/oapi-codegen/oapi-codegen/v2 v2.3.0 github.com/oapi-codegen/runtime v1.1.1 github.com/oapi-codegen/testutil v1.1.0 diff --git a/go.sum b/go.sum index 65500831b..eeb55ff46 100644 --- a/go.sum +++ b/go.sum @@ -258,8 +258,8 @@ github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHm github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE= github.com/kenshaw/inflector v0.2.0 h1:6HuXXlzqIIptlIkKvZ4fFSgfr0opnV6/LVIg+1+DlqY= github.com/kenshaw/inflector v0.2.0/go.mod h1:g5nxVgwZsIPE0eesk201Sp4YBwDDHZDfJHl6L2PUTM4= -github.com/kenshaw/snaker v0.2.0 h1:DPlxCtAv9mw1wSsvIN1khUAPJUIbFJUckMIDWSQ7TC8= -github.com/kenshaw/snaker v0.2.0/go.mod h1:DNyRUqHMZ18/zioxr6R7m4kSxxf2+QmB0BXoORsXRaY= +github.com/kenshaw/snaker v0.4.3 h1:KhB7v9iouD5RdMvAIRfaj7y3tGTpufLjxQiF7NIikwo= +github.com/kenshaw/snaker v0.4.3/go.mod h1:SChlK7Kp/gq+iwlBqzIW4rimhwpw40HGqRtZbn38M+w= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM= diff --git a/vendor/github.com/kenshaw/snaker/.golangci.yml b/vendor/github.com/kenshaw/snaker/.golangci.yml new file mode 100644 index 000000000..b410e1933 --- /dev/null +++ b/vendor/github.com/kenshaw/snaker/.golangci.yml @@ -0,0 +1,20 @@ +linters: + enable-all: true + disable: + - cyclop + - depguard + - dupl + - err113 + - exhaustruct + - exportloopref + - gochecknoglobals + - gochecknoinits + - mnd + - nlreturn + - paralleltest + - prealloc + - revive + - testpackage + - varnamelen + - wastedassign + - wsl diff --git a/vendor/github.com/kenshaw/snaker/LICENSE b/vendor/github.com/kenshaw/snaker/LICENSE index 323e87a93..9c3985ece 100644 --- a/vendor/github.com/kenshaw/snaker/LICENSE +++ b/vendor/github.com/kenshaw/snaker/LICENSE @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) 2016-2021 Kenneth Shaw +Copyright (c) 2016-2024 Kenneth Shaw Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/vendor/github.com/kenshaw/snaker/README.md b/vendor/github.com/kenshaw/snaker/README.md index e2596ed47..6ca6b5ab3 100644 --- a/vendor/github.com/kenshaw/snaker/README.md +++ b/vendor/github.com/kenshaw/snaker/README.md @@ -1,19 +1,17 @@ # snaker [![Go Package][gopkg]][gopkg-link] -Package `snaker` provides methods to convert `CamelCase` to and from -`snake_case`. Correctly recognizes common (Go idiomatic) initialisms (`HTTP`, -`XML`, etc) and provides a mechanism to override/set recognized initialisms. +Package `snaker` provides methods to convert `CamelCase`, `snake_case`, and +`kebab-case` to and from each other. Correctly recognizes common (Go idiomatic) +initialisms (`HTTP`, `XML`, etc) with the ability to override/set recognized +initialisms. -[gopkg]: https://pkg.go.dev/badge/github.com/kenshaw/snaker.svg (Go Package) +[gopkg]: https://pkg.go.dev/badge/github.com/kenshaw/snaker.svg "Go Package" [gopkg-link]: https://pkg.go.dev/github.com/kenshaw/snaker ## Example -A basic Go example: - ```go -// _example/example.go -package main +package snaker_test import ( "fmt" @@ -21,7 +19,7 @@ import ( "github.com/kenshaw/snaker" ) -func main() { +func Example() { fmt.Println("Change CamelCase -> snake_case:", snaker.CamelToSnake("AnIdentifier")) fmt.Println("Change CamelCase -> snake_case (2):", snaker.CamelToSnake("XMLHTTPACL")) fmt.Println("Change snake_case -> CamelCase:", snaker.SnakeToCamel("an_identifier")) @@ -29,5 +27,17 @@ func main() { fmt.Println("Force lower camelCase:", snaker.ForceLowerCamelIdentifier("APoorly_named_httpMethod")) fmt.Println("Force lower camelCase (2):", snaker.ForceLowerCamelIdentifier("XmlHttpACL")) fmt.Println("Change snake_case identifier -> CamelCase:", snaker.SnakeToCamelIdentifier("__2__xml___thing---")) + // Output: + // Change CamelCase -> snake_case: an_identifier + // Change CamelCase -> snake_case (2): xml_http_acl + // Change snake_case -> CamelCase: AnIdentifier + // Force CamelCase: APoorlyNamedHTTPMethod + // Force lower camelCase: aPoorlyNamedHTTPMethod + // Force lower camelCase (2): xmlHTTPACL + // Change snake_case identifier -> CamelCase: XMLThing } ``` + +See the [package example][example]. + +[example]: https://pkg.go.dev/github.com/kenshaw/snaker/#Example diff --git a/vendor/github.com/kenshaw/snaker/initialisms.go b/vendor/github.com/kenshaw/snaker/initialisms.go index 578a47f47..cb6f76ace 100644 --- a/vendor/github.com/kenshaw/snaker/initialisms.go +++ b/vendor/github.com/kenshaw/snaker/initialisms.go @@ -8,16 +8,16 @@ import ( // Initialisms is a set of initialisms. type Initialisms struct { - m map[string]string - p map[string]string - max int + known map[string]string + post map[string]string + max int } // New creates a new set of initialisms. func New(initialisms ...string) (*Initialisms, error) { ini := &Initialisms{ - m: make(map[string]string), - p: make(map[string]string), + known: make(map[string]string), + post: make(map[string]string), } if err := ini.Add(initialisms...); err != nil { return nil, err @@ -25,26 +25,30 @@ func New(initialisms ...string) (*Initialisms, error) { return ini, nil } -// NewDefaultInitialisms creates a default set of initialisms. -func NewDefaultInitialisms() *Initialisms { +// NewDefaultInitialisms creates a set of known, common initialisms. +func NewDefaultInitialisms() (*Initialisms, error) { ini, err := New(CommonInitialisms()...) if err != nil { - panic(err) + return nil, err + } + var pairs []string + for _, s := range CommonPlurals() { + pairs = append(pairs, s+"S", s+"s") } - if err := ini.Post("IDS", "IDs"); err != nil { - panic(err) + if err := ini.Post(pairs...); err != nil { + return nil, err } - return ini + return ini, nil } -// Add adds initialisms. +// Add adds a known initialisms. func (ini *Initialisms) Add(initialisms ...string) error { for _, s := range initialisms { s = strings.ToUpper(s) if len(s) < 2 { return fmt.Errorf("invalid initialism %q", s) } - ini.m[s], ini.max = s, max(ini.max, len(s)) + ini.known[s], ini.max = s, max(ini.max, len(s)) } return nil } @@ -59,8 +63,8 @@ func (ini *Initialisms) Post(pairs ...string) error { if s != strings.ToUpper(pairs[i+1]) { return fmt.Errorf("invalid pair %q, %q", pairs[i], pairs[i+1]) } - ini.m[s] = pairs[i+1] - ini.p[pairs[i+1]] = pairs[i+1] + ini.known[s] = pairs[i+1] + ini.post[pairs[i+1]] = pairs[i+1] ini.max = max(ini.max, len(s)) } return nil @@ -72,25 +76,22 @@ func (ini *Initialisms) CamelToSnake(name string) string { if name == "" { return "" } - s, r := "", []rune(name) - var lastWasUpper, lastWasLetter, lastWasIsm, isUpper, isLetter bool - for i := 0; i < len(r); { + var s string + var wasUpper, wasLetter, wasIsm, isUpper, isLetter bool + for i, r, next := 0, []rune(name), ""; i < len(r); i, s = i+len(next), s+next { isUpper, isLetter = unicode.IsUpper(r[i]), unicode.IsLetter(r[i]) // append _ when last was not upper and not letter - if (lastWasLetter && isUpper) || (lastWasIsm && isLetter) { + if (wasLetter && isUpper) || (wasIsm && isLetter) { s += "_" } // determine next to append to r - var next string - if ism := ini.Peek(r[i:]); ism != "" && (!lastWasUpper || lastWasIsm) { + if ism := ini.Peek(r[i:]); ism != "" && (!wasUpper || wasIsm) { next = ism } else { next = string(r[i]) } // save for next iteration - lastWasIsm, lastWasUpper, lastWasLetter = len(next) > 1, isUpper, isLetter - s += next - i += len(next) + wasIsm, wasUpper, wasLetter = 1 < len(next), isUpper, isLetter } return strings.ToLower(s) } @@ -108,7 +109,7 @@ func (ini *Initialisms) SnakeToCamel(name string) string { if word == "" { continue } - if u, ok := ini.m[strings.ToUpper(word)]; ok { + if u, ok := ini.known[strings.ToUpper(word)]; ok { s += u } else { s += strings.ToUpper(word[:1]) + strings.ToLower(word[1:]) @@ -139,61 +140,41 @@ func (ini *Initialisms) ForceLowerCamelIdentifier(name string) string { return "" } name = ini.CamelToSnake(name) - first := strings.SplitN(name, "_", -1)[0] + first := strings.Split(name, "_")[0] name = ini.SnakeToCamelIdentifier(name) return strings.ToLower(first) + name[len(first):] } -// Peek returns the next longest possible initialism in r. +// Peek returns the next longest possible initialism in v. func (ini *Initialisms) Peek(r []rune) string { // do no work if len(r) < 2 { return "" } - // grab at most next maxInitialismLen uppercase characters - l := min(len(r), ini.max) - var z []rune - for i := 0; i < l; i++ { - if !unicode.IsLetter(r[i]) { - break - } - z = append(z, r[i]) + // peek next few runes, up to max length of the largest known initialism + var i int + for n := min(len(r), ini.max); i < n && unicode.IsLetter(r[i]); i++ { } - // bail if next few characters were not uppercase. - if len(z) < 2 { + // bail if not enough letters + if i < 2 { return "" } // determine if common initialism - for i := min(ini.max, len(z)); i >= 2; i-- { - r := string(z[:i]) - if s, ok := ini.m[r]; ok { + var k string + for i = min(ini.max, i+1, len(r)); i >= 2; i-- { + k = string(r[:i]) + if s, ok := ini.known[k]; ok { return s } - if s, ok := ini.p[r]; ok { + if s, ok := ini.post[k]; ok { return s } } return "" } -// IsInitialism indicates whether or not s is a registered initialism. -func (ini *Initialisms) IsInitialism(s string) bool { - _, ok := ini.m[strings.ToUpper(s)] +// Is indicates whether or not s is a registered initialism. +func (ini *Initialisms) Is(s string) bool { + _, ok := ini.known[strings.ToUpper(s)] return ok } - -// min returns the minimum of a, b. -func min(a, b int) int { - if a < b { - return a - } - return b -} - -// max returns the max of a, b. -func max(a, b int) int { - if a > b { - return a - } - return b -} diff --git a/vendor/github.com/kenshaw/snaker/snaker.go b/vendor/github.com/kenshaw/snaker/snaker.go index 72cfcbdb2..91b360f16 100644 --- a/vendor/github.com/kenshaw/snaker/snaker.go +++ b/vendor/github.com/kenshaw/snaker/snaker.go @@ -5,14 +5,84 @@ package snaker import ( - "regexp" "strings" "unicode" ) +// DefaultInitialisms is the set of default (common) initialisms used by the +// package level conversions funcs. +var DefaultInitialisms *Initialisms + func init() { - // initialize common default initialisms. - DefaultInitialisms = NewDefaultInitialisms() + // initialize common default initialisms + var err error + if DefaultInitialisms, err = NewDefaultInitialisms(); err != nil { + panic(err) + } +} + +// CamelToSnake converts name from camel case ("AnIdentifier") to snake case +// ("an_identifier"). +func CamelToSnake(name string) string { + return DefaultInitialisms.CamelToSnake(name) +} + +// CamelToSnakeIdentifier converts name from camel case to a snake case +// identifier. +func CamelToSnakeIdentifier(name string) string { + return DefaultInitialisms.CamelToSnakeIdentifier(name) +} + +// SnakeToCamel converts name to CamelCase. +func SnakeToCamel(name string) string { + return DefaultInitialisms.SnakeToCamel(name) +} + +// SnakeToCamelIdentifier converts name to its CamelCase identifier (first +// letter is capitalized). +func SnakeToCamelIdentifier(name string) string { + return DefaultInitialisms.SnakeToCamelIdentifier(name) +} + +// ForceCamelIdentifier forces name to its CamelCase specific to Go +// ("AnIdentifier"). +func ForceCamelIdentifier(name string) string { + return DefaultInitialisms.ForceCamelIdentifier(name) +} + +// ForceLowerCamelIdentifier forces the first portion of an identifier to be +// lower case ("anIdentifier"). +func ForceLowerCamelIdentifier(name string) string { + return DefaultInitialisms.ForceLowerCamelIdentifier(name) +} + +// IsInitialism indicates whether or not s is a registered initialism. +func IsInitialism(s string) bool { + return DefaultInitialisms.Is(s) +} + +// ToIdentifier cleans s so that it is usable as an identifier. +// +// Substitutes invalid characters with an underscore, removes any leading +// numbers/underscores, and removes trailing underscores. +// +// Additionally collapses multiple underscores to a single underscore. +// +// Makes no changes to case. +func ToIdentifier(s string) string { + return toIdent(s, '_') +} + +// ToKebab changes s to kebab case. +// +// Substitutes invalid characters with a hyphen, removes any leading +// numbers/hyphens, and removes trailing hyphens. +// +// Additionally collapses multiple hyphens to a single hyphen. +// +// Converts the string to lower case. +func ToKebab(s string) string { + return strings.ToLower(toIdent(s, '-')) } // CommonInitialisms returns the set of common initialisms. @@ -28,12 +98,14 @@ func CommonInitialisms() []string { "ASCII", "CPU", "CSS", + "CSV", "DNS", "EOF", + "GPU", "GUID", "HTML", - "HTTPS", "HTTP", + "HTTPS", "ID", "IP", "JSON", @@ -48,10 +120,11 @@ func CommonInitialisms() []string { "SSH", "TCP", "TLS", + "TSV", "TTL", "UDP", - "UID", "UI", + "UID", "URI", "URL", "UTC", @@ -66,98 +139,57 @@ func CommonInitialisms() []string { } } -// DefaultInitialisms is a set of default (common) initialisms. -var DefaultInitialisms *Initialisms - -// CamelToSnake converts name from camel case ("AnIdentifier") to snake case -// ("an_identifier"). -func CamelToSnake(name string) string { - return DefaultInitialisms.CamelToSnake(name) -} - -// CamelToSnakeIdentifier converts name from camel case to a snake case -// identifier. -func CamelToSnakeIdentifier(name string) string { - return DefaultInitialisms.CamelToSnakeIdentifier(name) -} - -// SnakeToCamel converts name to CamelCase. -func SnakeToCamel(name string) string { - return DefaultInitialisms.SnakeToCamel(name) -} - -// SnakeToCamelIdentifier converts name to its CamelCase identifier (first -// letter is capitalized). -func SnakeToCamelIdentifier(name string) string { - return DefaultInitialisms.SnakeToCamelIdentifier(name) -} - -// ForceCamelIdentifier forces name to its CamelCase specific to Go -// ("AnIdentifier"). -func ForceCamelIdentifier(name string) string { - return DefaultInitialisms.ForceCamelIdentifier(name) -} - -// ForceLowerCamelIdentifier forces the first portion of an identifier to be -// lower case ("anIdentifier"). -func ForceLowerCamelIdentifier(name string) string { - return DefaultInitialisms.ForceLowerCamelIdentifier(name) -} - -// Peek returns the next longest possible initialism in r. -func Peek(r []rune) string { - return DefaultInitialisms.Peek(r) -} - -// IsInitialism indicates whether or not s is a registered initialism. -func IsInitialism(s string) bool { - return DefaultInitialisms.IsInitialism(s) -} - -// IsIdentifierChar determines if ch is a valid character for a Go identifier. -// -// See: go/src/go/scanner/scanner.go -func IsIdentifierChar(ch rune) bool { - return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= 0x80 && unicode.IsLetter(ch) || - '0' <= ch && ch <= '9' || ch >= 0x80 && unicode.IsDigit(ch) +// CommonPlurals returns initialisms that have a common plural of s. +func CommonPlurals() []string { + return []string{ + "ACL", + "API", + "CPU", + "CSV", + "GPU", + "GUID", + "ID", + "IP", + "TSV", + "UID", + "URI", + "URL", + "UUID", + "VM", + } } -// ToIdentifier cleans s so that it is usable as an identifier. -// -// Substitutes invalid characters with an underscore, removes any leading -// numbers/underscores, and removes trailing underscores. -// -// Additionally collapses multiple underscores to a single underscore. -// -// Makes no changes to case. -func ToIdentifier(s string) string { - // replace bad chars with _ - s = subUnderscores(strings.TrimSpace(s)) - // fix 2 or more __ and remove leading numbers/underscores - s = underscoreRE.ReplaceAllString(s, "_") - s = leadingRE.ReplaceAllString(s, "_") - // remove leading/trailing underscores - s = strings.TrimLeft(s, "_") - s = strings.TrimRight(s, "_") +// toIdent converts s to a identifier. +func toIdent(s string, c rune) string { + // replace bad chars with c, and compact multiple c to single + s = sub(strings.TrimSpace(s), c) + // remove leading numbers and c + s = strings.TrimLeftFunc(s, func(r rune) bool { + return unicode.IsNumber(r) || c == r + }) + // remove trailing c + s = strings.TrimRightFunc(s, func(r rune) bool { + return c == r + }) return s } -// underscoreRE matches underscores. -var underscoreRE = regexp.MustCompile(`_+`) - -// leadingRE matches leading numbers. -var leadingRE = regexp.MustCompile(`^[0-9_]+`) - -// subUnderscores substitues underscrose in place of runes that are invalid for +// sub substitutes underscrose in place of runes that are invalid for // Go identifiers. -func subUnderscores(s string) string { - var r []rune - for _, c := range s { - if IsIdentifierChar(c) { - r = append(r, c) - } else { - r = append(r, '_') +func sub(s string, c rune) string { + r := []rune(s) + for i, ch := range r { + if !isIdentifierChar(ch) { + r[i] = c } } return string(r) } + +// isIdentifierChar determines if ch is a valid character for a Go identifier. +// +// See: go/src/go/scanner/scanner.go. +func isIdentifierChar(ch rune) bool { + return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= 0x80 && unicode.IsLetter(ch) || + '0' <= ch && ch <= '9' || ch >= 0x80 && unicode.IsDigit(ch) +} diff --git a/vendor/modules.txt b/vendor/modules.txt index e06c6a74b..761b9f05e 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -303,8 +303,8 @@ github.com/json-iterator/go # github.com/kenshaw/inflector v0.2.0 ## explicit; go 1.17 github.com/kenshaw/inflector -# github.com/kenshaw/snaker v0.2.0 -## explicit; go 1.16 +# github.com/kenshaw/snaker v0.4.3 +## explicit; go 1.23 github.com/kenshaw/snaker # github.com/klauspost/cpuid/v2 v2.2.7 ## explicit; go 1.15