From d0576e028f8beabdda340c80a6eac532f2867578 Mon Sep 17 00:00:00 2001
From: dudaodong <dudaodong@gmail.com>
Date: Tue, 13 Dec 2022 19:52:37 +0800
Subject: [PATCH] clean code

---
 strutil/string.go      | 33 +++++++++++++--------------------
 strutil/string_test.go | 42 +++++++++++++++++++++++++++++++-----------
 2 files changed, 44 insertions(+), 31 deletions(-)

diff --git a/strutil/string.go b/strutil/string.go
index 6814156..8fd5e29 100644
--- a/strutil/string.go
+++ b/strutil/string.go
@@ -12,8 +12,6 @@ import (
 
 // CamelCase covert string to camelCase string.
 func CamelCase(s string) string {
-	s = strings.ReplaceAll(s, " ", "")
-
 	var runes [][]rune
 	lastCharType := 0
 	charType := 0
@@ -39,8 +37,6 @@ func CamelCase(s string) string {
 		lastCharType = charType
 	}
 
-	result := ""
-
 	for i := 0; i < len(runes)-1; i++ {
 		if unicode.IsUpper(runes[i][0]) && unicode.IsLower(runes[i+1][0]) {
 			runes[i+1] = append([]rune{runes[i][len(runes[i])-1]}, runes[i+1]...)
@@ -59,6 +55,8 @@ func CamelCase(s string) string {
 		}
 	}
 
+	result := ""
+
 	// capitalize
 	for i, r := range filterRunes {
 		if i == 0 {
@@ -160,14 +158,10 @@ func PadStart(source string, size int, padStr string) string {
 
 // KebabCase covert string to kebab-case
 func KebabCase(s string) string {
-	if len(s) == 0 {
-		return ""
-	}
-
-	regex := regexp.MustCompile(`[\W|_]+`)
-	blankSpace := " "
-	match := regex.ReplaceAllString(s, blankSpace)
-	rs := strings.Split(match, blankSpace)
+	re := regexp.MustCompile(`[\W|_]+`)
+	space := " "
+	match := re.ReplaceAllString(s, space)
+	rs := strings.Split(match, space)
 
 	var result []string
 	for _, v := range rs {
@@ -175,6 +169,9 @@ func KebabCase(s string) string {
 		if len(splitWords) > 0 {
 			result = append(result, splitWords...)
 		}
+		// if v != "" {
+		// 	result = append(result, strings.ToLower(v))
+		// }
 	}
 
 	return strings.Join(result, "-")
@@ -182,14 +179,10 @@ func KebabCase(s string) string {
 
 // SnakeCase covert string to snake_case
 func SnakeCase(s string) string {
-	if len(s) == 0 {
-		return ""
-	}
-
-	regex := regexp.MustCompile(`[\W|_]+`)
-	blankSpace := " "
-	match := regex.ReplaceAllString(s, blankSpace)
-	rs := strings.Split(match, blankSpace)
+	re := regexp.MustCompile(`[\W|_]+`)
+	space := " "
+	match := re.ReplaceAllString(s, space)
+	rs := strings.Split(match, space)
 
 	var result []string
 	for _, v := range rs {
diff --git a/strutil/string_test.go b/strutil/string_test.go
index ae6fde4..1371d0e 100644
--- a/strutil/string_test.go
+++ b/strutil/string_test.go
@@ -48,24 +48,44 @@ func TestCapitalize(t *testing.T) {
 func TestKebabCase(t *testing.T) {
 	assert := internal.NewAssert(t, "TestKebabCase")
 
-	assert.Equal("foo-bar", KebabCase("Foo Bar-"))
-	assert.Equal("foo-bar", KebabCase("foo_Bar"))
-	assert.Equal("foo-bar", KebabCase("fooBar"))
-	assert.Equal("f-o-o-b-a-r", KebabCase("__FOO_BAR__"))
+	cases := map[string]string{
+		"Foo Bar-":                 "foo-bar",
+		"foo_Bar":                  "foo-bar",
+		"fooBar":                   "foo-bar",
+		"FOOBAR":                   "f-o-o-b-a-r",
+		"FOO_BAR":                  "f-o-o-b-a-r",
+		"__FOO_BAR__":              "f-o-o-b-a-r",
+		"$foo@Bar":                 "foo-bar",
+		"   $#$Foo   22    bar   ": "foo-22-bar",
+	}
 
-	assert.NotEqual("foo_bar", KebabCase("fooBar"))
+	for k, v := range cases {
+		assert.Equal(v, KebabCase(k))
+	}
+
+	assert.Equal("", KebabCase(""))
+
+	// assert.Equal("foo-1-1bar", KebabCase("Foo-#1😄$_%^&*(1bar"))
 }
 
 func TestSnakeCase(t *testing.T) {
 	assert := internal.NewAssert(t, "TestSnakeCase")
 
-	assert.Equal("foo_bar", SnakeCase("Foo Bar-"))
-	assert.Equal("foo_bar", SnakeCase("foo_Bar"))
-	assert.Equal("foo_bar", SnakeCase("fooBar"))
-	assert.Equal("f_o_o_b_a_r", SnakeCase("__FOO_BAR__"))
-	assert.Equal("a_bbc_s_a_b_b_c", SnakeCase("aBbc-s$@a&%_B.B^C"))
+	cases := map[string]string{
+		"Foo Bar-":                 "foo_bar",
+		"foo_Bar":                  "foo_bar",
+		"fooBar":                   "foo_bar",
+		"__FOO_BAR__":              "f_o_o_b_a_r",
+		"$foo@Bar":                 "foo_bar",
+		"   $#$Foo   22    bar   ": "foo_22_bar",
+		"aBbc-s$@a&%_B.B^C":        "a_bbc_s_a_b_b_c",
+	}
 
-	assert.NotEqual("foo-bar", SnakeCase("foo_Bar"))
+	for k, v := range cases {
+		assert.Equal(v, SnakeCase(k))
+	}
+
+	assert.Equal("", SnakeCase(""))
 }
 
 func TestUpperFirst(t *testing.T) {