feat: add *Case func to stringz package (#101)

Author: ginokent

strings/case.go

@@ -0,0 +1,171 @@
+package stringz
+
+import (
+	"strings"
+)
+
+type _Case struct {
+	allUpper      bool // [A-Z]+
+	allLower      bool // [a-z]+
+	firstUpper    bool // [A-Z][0-9a-z_-]+
+	firstLower    bool // [a-z][0-9a-z_-]+
+	hasUpper      bool // .*[A-Z].*
+	hasLower      bool // .*[a-z].*
+	hasUnderscore bool // .*_.*
+	hasDash       bool // .*-.*
+	hasNumber     bool // .*[0-9].*
+	hasOther      bool // .*[^0-9a-zA-Z_-].*
+}
+
+func ParseCase(s string) _Case { //nolint:cyclop,revive
+	c := _Case{
+		allUpper: true,
+		allLower: true,
+	}
+
+	for idx, r := range s {
+		switch {
+		case r >= 'A' && r <= 'Z':
+			c.allLower = false
+			c.hasUpper = true
+			if idx == 0 {
+				c.firstUpper = true
+			}
+		case r >= 'a' && r <= 'z':
+			c.allUpper = false
+			c.hasLower = true
+			if idx == 0 {
+				c.firstLower = true
+			}
+		case r == '_':
+			c.allUpper = false
+			c.allLower = false
+			c.hasUnderscore = true
+		case r == '-':
+			c.allUpper = false
+			c.allLower = false
+			c.hasDash = true
+		case r >= '0' && r <= '9':
+			c.allUpper = false
+			c.allLower = false
+			c.hasNumber = true
+		default:
+			c.allUpper = false
+			c.allLower = false
+			c.hasOther = true
+		}
+	}
+	return c
+}
+
+// ex. snake_case, go, type_script, postgre_sql.
+func IsSnakeCase(s string) bool {
+	return ParseCase(s).IsSnakeCase()
+}
+
+func (c _Case) IsSnakeCase() bool {
+	return c.hasUnderscore && c.hasLower && !c.hasUpper && !c.hasDash && !c.allLower
+}
+
+// ex. kebab-case, go, type-script, postgre-sql.
+func IsKebabCase(s string) bool {
+	return ParseCase(s).IsKebabCase()
+}
+
+func (c _Case) IsKebabCase() bool {
+	return c.hasDash && c.hasLower && !c.hasUpper && !c.IsSnakeCase()
+}
+
+// ex. PascalCase, Go, TypeScript, PostgreSql.
+func IsPascalCase(s string) bool {
+	return ParseCase(s).IsPascalCase()
+}
+
+func (c _Case) IsPascalCase() bool {
+	return c.firstUpper && !c.hasDash && !c.IsSnakeCase() && !c.IsKebabCase()
+}
+
+// ex. camelCase, go, typeScript, postgreSql.
+func IsCamelCase(s string) bool {
+	return ParseCase(s).IsCamelCase()
+}
+
+func (c _Case) IsCamelCase() bool {
+	return c.firstLower && !c.hasDash && !c.IsSnakeCase() && !c.IsKebabCase() && !c.IsPascalCase()
+}
+
+func SplitSnakeCase(s string) []string {
+	return strings.Split(s, "_")
+}
+
+func SplitKebabCase(s string) []string {
+	return strings.Split(s, "-")
+}
+
+func SplitPascalCase(s string) []string {
+	c := ParseCase(s)
+	return c.splitPascalCase(s)
+}
+
+func (c _Case) splitPascalCase(s string) []string {
+	return splitCamels(s)
+}
+
+func SplitCamelCase(s string) []string {
+	c := ParseCase(s)
+	return c.splitCamelCase(s)
+}
+
+func (c _Case) splitCamelCase(s string) []string {
+	return splitCamels(s)
+}
+
+func SplitCase(s string) []string {
+	c := ParseCase(s)
+
+	switch {
+	case c.IsSnakeCase():
+		return SplitSnakeCase(s)
+	case c.IsKebabCase():
+		return SplitKebabCase(s)
+	case c.IsPascalCase():
+		return c.splitPascalCase(s)
+	case c.IsCamelCase():
+		return c.splitCamelCase(s)
+	default:
+		// as default, use camelCase.
+		return c.splitCamelCase(s)
+	}
+}
+
+func splitCamels(s string) []string { //nolint:cyclop
+	var _words []string
+	var _word []rune //nolint:prealloc
+
+	var before rune
+	for _, current := range s {
+		if !('A' <= before && before <= 'Z' || before == 0) && 'A' <= current && current <= 'Z' {
+			// aaA -> [aa A]
+			//  ~~
+			//	| \
+			//	|  +-- current
+			//  +-- before
+			_words = append(_words, string(_word))
+			_word = _word[:0]
+		} else if 'A' <= before && before <= 'Z' && !('A' <= current && current <= 'Z') && len(_word) > 1 {
+			// aAa -> [a Aa]
+			//  ~~
+			//	| \
+			//	|  +-- current
+			//  +-- before
+			_words = append(_words, string(_word[:len(_word)-1]))
+			_word = _word[len(_word)-1:]
+		}
+		_word = append(_word, current)
+		before = current
+	}
+	if len(_word) > 0 {
+		_words = append(_words, string(_word))
+	}
+	return _words
+}

strings/case_test.go

@@ -0,0 +1,208 @@
+//nolint:dupword
+package stringz_test
+
+import (
+	"fmt"
+
+	stringz "github.com/kunitsucom/util.go/strings"
+)
+
+func ExampleIsSnakeCase() {
+	fmt.Println(stringz.IsSnakeCase("snake_case"))
+	fmt.Println(stringz.IsSnakeCase("kebab-case"))
+	fmt.Println(stringz.IsSnakeCase("camelCase"))
+	fmt.Println(stringz.IsSnakeCase("PascalCase"))
+	fmt.Println(stringz.IsSnakeCase("go"))
+	fmt.Println(stringz.IsSnakeCase("type_script"))
+	fmt.Println(stringz.IsSnakeCase("postgre_sql"))
+	fmt.Println(stringz.IsSnakeCase("goV1_21"))
+	fmt.Println(stringz.IsSnakeCase("MySQLV8"))
+	// Output:
+	// true
+	// false
+	// false
+	// false
+	// false
+	// true
+	// true
+	// false
+	// false
+}
+
+func ExampleIsKebabCase() {
+	fmt.Println(stringz.IsKebabCase("snake_case"))
+	fmt.Println(stringz.IsKebabCase("kebab-case"))
+	fmt.Println(stringz.IsKebabCase("camelCase"))
+	fmt.Println(stringz.IsKebabCase("PascalCase"))
+	fmt.Println(stringz.IsKebabCase("go"))
+	fmt.Println(stringz.IsKebabCase("type-script"))
+	fmt.Println(stringz.IsKebabCase("postgre-sql"))
+	fmt.Println(stringz.IsKebabCase("goV1_21"))
+	fmt.Println(stringz.IsKebabCase("MySQLV8"))
+	// Output:
+	// false
+	// true
+	// false
+	// false
+	// false
+	// true
+	// true
+	// false
+	// false
+}
+
+func ExampleIsCamelCase() {
+	fmt.Println(stringz.IsCamelCase("snake_case"))
+	fmt.Println(stringz.IsCamelCase("kebab-case"))
+	fmt.Println(stringz.IsCamelCase("camelCase"))
+	fmt.Println(stringz.IsCamelCase("PascalCase"))
+	fmt.Println(stringz.IsCamelCase("go"))
+	fmt.Println(stringz.IsCamelCase("typeScript"))
+	fmt.Println(stringz.IsCamelCase("postgreSQL"))
+	fmt.Println(stringz.IsCamelCase("goV1_21"))
+	fmt.Println(stringz.IsCamelCase("MySQLV8"))
+	// Output:
+	// false
+	// false
+	// true
+	// false
+	// true
+	// true
+	// true
+	// true
+	// false
+}
+
+func ExampleIsPascalCase() {
+	fmt.Println(stringz.IsPascalCase("snake_case"))
+	fmt.Println(stringz.IsPascalCase("kebab-case"))
+	fmt.Println(stringz.IsPascalCase("camelCase"))
+	fmt.Println(stringz.IsPascalCase("PascalCase"))
+	fmt.Println(stringz.IsPascalCase("Go"))
+	fmt.Println(stringz.IsPascalCase("TypeScript"))
+	fmt.Println(stringz.IsPascalCase("PostgreSQL"))
+	fmt.Println(stringz.IsPascalCase("goV1_21"))
+	fmt.Println(stringz.IsPascalCase("MySQLV8"))
+	// Output:
+	// false
+	// false
+	// false
+	// true
+	// true
+	// true
+	// true
+	// false
+	// true
+}
+
+func ExampleSplitSnakeCase() {
+	fmt.Println(stringz.SplitSnakeCase("snake_case"))
+	fmt.Println(stringz.SplitSnakeCase("kebab-case"))
+	fmt.Println(stringz.SplitSnakeCase("camelCase"))
+	fmt.Println(stringz.SplitSnakeCase("PascalCase"))
+	fmt.Println(stringz.SplitSnakeCase("go"))
+	fmt.Println(stringz.SplitSnakeCase("type_script"))
+	fmt.Println(stringz.SplitSnakeCase("postgre_sql"))
+	fmt.Println(stringz.SplitSnakeCase("goV1_21"))
+	fmt.Println(stringz.SplitSnakeCase("MySQLV8"))
+	// Output:
+	// [snake case]
+	// [kebab-case]
+	// [camelCase]
+	// [PascalCase]
+	// [go]
+	// [type script]
+	// [postgre sql]
+	// [goV1 21]
+	// [MySQLV8]
+}
+
+func ExampleSplitKebabCase() {
+	fmt.Println(stringz.SplitKebabCase("snake_case"))
+	fmt.Println(stringz.SplitKebabCase("kebab-case"))
+	fmt.Println(stringz.SplitKebabCase("camelCase"))
+	fmt.Println(stringz.SplitKebabCase("PascalCase"))
+	fmt.Println(stringz.SplitKebabCase("go"))
+	fmt.Println(stringz.SplitKebabCase("type-script"))
+	fmt.Println(stringz.SplitKebabCase("postgre-sql"))
+	fmt.Println(stringz.SplitKebabCase("goV1_21"))
+	fmt.Println(stringz.SplitKebabCase("MySQLV8"))
+	// Output:
+	// [snake_case]
+	// [kebab case]
+	// [camelCase]
+	// [PascalCase]
+	// [go]
+	// [type script]
+	// [postgre sql]
+	// [goV1_21]
+	// [MySQLV8]
+}
+
+func ExampleSplitCamelCase() {
+	fmt.Println(stringz.SplitCamelCase("snake_case"))
+	fmt.Println(stringz.SplitCamelCase("kebab-case"))
+	fmt.Println(stringz.SplitCamelCase("camelCase"))
+	fmt.Println(stringz.SplitCamelCase("PascalCase"))
+	fmt.Println(stringz.SplitCamelCase("go"))
+	fmt.Println(stringz.SplitCamelCase("typeScript"))
+	fmt.Println(stringz.SplitCamelCase("postgreSQL"))
+	fmt.Println(stringz.SplitCamelCase("goV1_21"))
+	fmt.Println(stringz.SplitCamelCase("MySQLV8"))
+	// Output:
+	// [snake_case]
+	// [kebab-case]
+	// [camel Case]
+	// [Pascal Case]
+	// [go]
+	// [type Script]
+	// [postgre SQL]
+	// [go V1_21]
+	// [My SQL V8]
+}
+
+func ExampleSplitPascalCase() {
+	fmt.Println(stringz.SplitPascalCase("snake_case"))
+	fmt.Println(stringz.SplitPascalCase("kebab-case"))
+	fmt.Println(stringz.SplitPascalCase("camelCase"))
+	fmt.Println(stringz.SplitPascalCase("PascalCase"))
+	fmt.Println(stringz.SplitPascalCase("Go"))
+	fmt.Println(stringz.SplitPascalCase("TypeScript"))
+	fmt.Println(stringz.SplitPascalCase("PostgreSQL"))
+	fmt.Println(stringz.SplitPascalCase("goV1_21"))
+	fmt.Println(stringz.SplitPascalCase("MySQLV8"))
+	// Output:
+	// [snake_case]
+	// [kebab-case]
+	// [camel Case]
+	// [Pascal Case]
+	// [Go]
+	// [Type Script]
+	// [Postgre SQL]
+	// [go V1_21]
+	// [My SQL V8]
+}
+
+func ExampleSplitCase() {
+	fmt.Println(stringz.SplitCase("snake_case"))
+	fmt.Println(stringz.SplitCase("kebab-case"))
+	fmt.Println(stringz.SplitCase("camelCase"))
+	fmt.Println(stringz.SplitCase("PascalCase"))
+	fmt.Println(stringz.SplitCase("go"))
+	fmt.Println(stringz.SplitCase("typeScript"))
+	fmt.Println(stringz.SplitCase("postgreSQL"))
+	fmt.Println(stringz.SplitCase("goV1_21"))
+	fmt.Println(stringz.SplitCase("MySQLV8"))
+	fmt.Println(stringz.SplitCase("A - 3"))
+	// Output:
+	// [snake case]
+	// [kebab case]
+	// [camel Case]
+	// [Pascal Case]
+	// [go]
+	// [type Script]
+	// [postgre SQL]
+	// [go V1_21]
+	// [My SQL V8]
+	// [A - 3]
+}