feat(strcase): add functions (scaleway#275)

* feat: Add strcase functions

Author: remyleone

strcase/camel.go

@@ -0,0 +1,13 @@
+package strcase
+
+import "strings"
+
+func ToCamel(s string) string {
+	if s == "" {
+		return s
+	}
+	if r := rune(s[0]); r >= 'A' && r <= 'Z' {
+		s = strings.ToLower(string(r)) + s[1:]
+	}
+	return toPascalInitCase(s, false)
+}

strcase/camel_test.go

@@ -0,0 +1,22 @@
+package strcase
+
+import (
+	"testing"
+)
+
+func TestToCamel(t *testing.T) {
+	cases := [][]string{
+		{"foo-bar", "fooBar"},
+		{"TestCase", "testCase"},
+		{"", ""},
+		{"AnyKind of_string", "anyKindOfString"},
+	}
+	for _, i := range cases {
+		in := i[0]
+		out := i[1]
+		result := ToCamel(in)
+		if result != out {
+			t.Error("'" + result + "' != '" + out + "'")
+		}
+	}
+}

strcase/goname_test.go

@@ -25,3 +25,24 @@ func TestLowerCaseFirstLetterOrAcronyms(t *testing.T) {
 		}
 	}
 }
+
+func TestTitleFirstWord(t *testing.T) {
+	cases := [][]string{
+		{"", ""},
+		{"t", "T"},
+		{"Test Case", "Test Case"},
+		{"test Case", "Test Case"},
+		{"test case", "Test case"},
+		{"TEST CASE", "TEST CASE"},
+		{"tEST CASE", "TEST CASE"},
+		{"#EST CASE", "#EST CASE"},
+	}
+	for _, i := range cases {
+		in := i[0]
+		out := i[1]
+		result := TitleFirstWord(in)
+		if result != out {
+			t.Error("'" + result + "' != '" + out + "'")
+		}
+	}
+}

strcase/kebab.go

@@ -0,0 +1,13 @@
+package strcase
+
+import "strings"
+
+// Converts a string to kebab-case
+func ToKebab(s string) string {
+	return strings.Replace(ToSnake(s), "_", "-", -1)
+}
+
+// Converts a string to kebab-case
+func ToSpace(s string) string {
+	return strings.Replace(ToSnake(s), "_", " ", -1)
+}

strcase/kebab_test.go

@@ -0,0 +1,35 @@
+package strcase
+
+import (
+	"testing"
+)
+
+func TestToKebab(t *testing.T) {
+	cases := [][]string{
+		{"testCase", "test-case"},
+		{"TestCase", "test-case"},
+		{"Test Case", "test-case"},
+		{" Test Case", "test-case"},
+		{"Test Case ", "test-case"},
+		{" Test Case ", "test-case"},
+		{"test", "test"},
+		{"test_case", "test-case"},
+		{"Test", "test"},
+		{"", ""},
+		{"ManyManyWords", "many-many-words"},
+		{"manyManyWords", "many-many-words"},
+		{"AnyKind of_string", "any-kind-of-string"},
+		{"numbers2and55with000", "numbers2and55with000"},
+		{"JSONData", "json-data"},
+		{"userID", "user-id"},
+		{"AAAbbb", "aa-abbb"},
+	}
+	for _, i := range cases {
+		in := i[0]
+		out := i[1]
+		result := ToKebab(in)
+		if result != out {
+			t.Error("'" + result + "' != '" + out + "'")
+		}
+	}
+}

strcase/number.go

@@ -0,0 +1,14 @@
+package strcase
+
+import (
+	"regexp"
+)
+
+var numberSequence = regexp.MustCompile(`([a-zA-Z])(\d+)([a-zA-Z]?)`)
+var numberReplacement = []byte(`$1 $2 $3`)
+
+func addWordBoundariesToNumbers(s string) string {
+	b := []byte(s)
+	b = numberSequence.ReplaceAll(b, numberReplacement)
+	return string(b)
+}

strcase/pascal.go

@@ -0,0 +1,36 @@
+package strcase
+
+import "strings"
+
+// Converts a string to CamelCase
+func toPascalInitCase(s string, initCase bool) string {
+	s = addWordBoundariesToNumbers(s)
+	s = strings.Trim(s, " ")
+	n := ""
+	capNext := initCase
+	for _, v := range s {
+		if v >= 'A' && v <= 'Z' {
+			n += string(v)
+		}
+		if v >= '0' && v <= '9' {
+			n += string(v)
+		}
+		if v >= 'a' && v <= 'z' {
+			if capNext {
+				n += strings.ToUpper(string(v))
+			} else {
+				n += string(v)
+			}
+		}
+		if v == '_' || v == ' ' || v == '-' {
+			capNext = true
+		} else {
+			capNext = false
+		}
+	}
+	return n
+}
+
+func ToPascal(s string) string {
+	return toPascalInitCase(s, true)
+}

strcase/pascal_test.go

@@ -0,0 +1,25 @@
+package strcase
+
+import "testing"
+
+func TestToPascal(t *testing.T) {
+	cases := [][]string{
+		{"test_case", "TestCase"},
+		{"test", "Test"},
+		{"TestCase", "TestCase"},
+		{" test  case ", "TestCase"},
+		{"", ""},
+		{"many_many_words", "ManyManyWords"},
+		{"AnyKind of_string", "AnyKindOfString"},
+		{"odd-fix", "OddFix"},
+		{"numbers2And55with000", "Numbers2And55With000"},
+	}
+	for _, i := range cases {
+		in := i[0]
+		out := i[1]
+		result := ToPascal(in)
+		if result != out {
+			t.Error("'" + result + "' != '" + out + "'")
+		}
+	}
+}

strcase/snake.go

@@ -0,0 +1,37 @@
+package strcase
+
+import (
+	"strings"
+)
+
+// Converts a string to snake_case
+func ToSnake(s string) string {
+	s = strings.Trim(s, " ")
+	n := ""
+	for i, v := range s {
+		// treat acronyms as words, eg for JSONData -> JSON is a whole word
+		nextCaseIsChanged := false
+		if i+1 < len(s) {
+			next := s[i+1]
+			if (isUpperLetter(v) && isLowerLetter(int32(next))) || (isLowerLetter(v) && isUpperLetter(int32(next))) {
+				nextCaseIsChanged = true
+			}
+		}
+
+		if i > 0 && n[len(n)-1] != '_' && nextCaseIsChanged {
+			// add underscore if next letter case type is changed
+			if isUpperLetter(v) {
+				n += "_" + string(v)
+			} else if isLowerLetter(v) {
+				n += string(v) + "_"
+			}
+		} else if v == ' ' || v == '-' {
+			// replace spaces and dashes with underscores
+			n += "_"
+		} else {
+			n = n + string(v)
+		}
+	}
+	n = strings.ToLower(n)
+	return n
+}

strcase/snake_test.go

@@ -0,0 +1,39 @@
+package strcase
+
+import (
+	"testing"
+)
+
+func TestToSnake(t *testing.T) {
+	cases := [][2]string{
+		{"testCase", "test_case"},
+		{"TestCase", "test_case"},
+		{"Test Case", "test_case"},
+		{" Test Case", "test_case"},
+		{"Test Case ", "test_case"},
+		{" Test Case ", "test_case"},
+		{"test", "test"},
+		{"test_case", "test_case"},
+		{"Test", "test"},
+		{"", ""},
+		{"ManyManyWords", "many_many_words"},
+		{"manyManyWords", "many_many_words"},
+		{"AnyKind of_string", "any_kind_of_string"},
+		{"numbers2and55with000", "numbers2and55with000"},
+		{"ip-v6", "ip_v6"},
+		{"ipV6", "ip_v6"},
+		{"IPV6", "ipv6"},
+		{"ipv6", "ipv6"},
+		{"JSONData", "json_data"},
+		{"userID", "user_id"},
+		{"AAAbbb", "aa_abbb"},
+	}
+	for _, i := range cases {
+		in := i[0]
+		out := i[1]
+		result := ToSnake(in)
+		if result != out {
+			t.Error("'" + result + "' != '" + out + "'")
+		}
+	}
+}