Decomposed cleanup. Implementing StringFiltering by Rune func

Author: Evan Marcey

string_filters.go

@@ -0,0 +1,43 @@
+package gostringconverters
+
+import (
+	"strings"
+	"unicode"
+)
+
+// FilterStringChars - given a string, removes all characters meeting filter conditions
+func FilterStringChars(s string, filters []RuneFilterFunc) string {
+	var result strings.Builder
+	for _, r := range s {
+		if !runeIsFiltered(r, filters) {
+			result.WriteRune(r)
+		}
+	}
+	return result.String()
+}
+
+func runeIsFiltered(r rune, filters []RuneFilterFunc) bool {
+	for _, filter := range filters {
+		if filter(r) {
+			return true
+		}
+	}
+	return false
+}
+
+// RuneFilterFunc - function that accepts a rune and returns a true if the rune meets a given condition
+type RuneFilterFunc func(rune) bool
+
+// ControlCharFilterFunc - checks if rune is a control character
+func ControlCharFilterFunc() RuneFilterFunc {
+	return func(r rune) bool {
+		return unicode.IsControl(r)
+	}
+}
+
+// RemoveControlCharsFromString - wraps FilterStringByRune to remove all control characters from a string
+func RemoveControlCharsFromString(s string) string {
+	return FilterStringChars(s, []RuneFilterFunc{
+		ControlCharFilterFunc(),
+	})
+}

string_filters_test.go

@@ -0,0 +1,175 @@
+package gostringconverters
+
+import (
+	"testing"
+)
+
+func RuneIsA() RuneFilterFunc {
+	return func(r rune) bool {
+		return r == 'a'
+	}
+}
+
+func RuneIsNotA() RuneFilterFunc {
+	return func(r rune) bool {
+		return r != 'a'
+	}
+}
+
+func RuneFilterAlwaysTrue() RuneFilterFunc {
+	return func(r rune) bool {
+		return true
+	}
+}
+
+func RuneFilterAlwaysFalse() RuneFilterFunc {
+	return func(r rune) bool {
+		return false
+	}
+}
+
+func TestRuneIsFiltered(t *testing.T) {
+	var testCases = []struct {
+		givenRune    rune
+		givenFilters []RuneFilterFunc
+		expected     bool
+	}{
+		{
+			givenRune:    'a',
+			givenFilters: []RuneFilterFunc{},
+			expected:     false,
+		},
+		{
+			givenRune: 'a',
+			givenFilters: []RuneFilterFunc{
+				RuneIsNotA(),
+			},
+			expected: false,
+		},
+		{
+			givenRune: 'a',
+			givenFilters: []RuneFilterFunc{
+				RuneIsA(),
+			},
+			expected: true,
+		},
+		{
+			givenRune: 'a',
+			givenFilters: []RuneFilterFunc{
+				RuneIsNotA(),
+				RuneFilterAlwaysTrue(),
+				RuneIsA(),
+			},
+			expected: true,
+		},
+		{
+			givenRune: 'a',
+			givenFilters: []RuneFilterFunc{
+				RuneIsA(),
+				RuneIsNotA(),
+				RuneFilterAlwaysTrue(),
+			},
+			expected: true,
+		},
+	}
+
+	for i, testCase := range testCases {
+		result := runeIsFiltered(testCase.givenRune, testCase.givenFilters)
+		if result != testCase.expected {
+			t.Error("test", i, "given", testCase.givenRune, "and", testCase.givenFilters, "expected", testCase.expected, "result", result)
+		}
+	}
+}
+
+func TestFilterStringChars(t *testing.T) {
+	var testCases = []struct {
+		givenString  string
+		givenFilters []RuneFilterFunc
+		expected     string
+	}{
+		{
+			givenString:  "",
+			givenFilters: []RuneFilterFunc{},
+			expected:     "",
+		},
+		{
+			givenString:  "abc",
+			givenFilters: []RuneFilterFunc{},
+			expected:     "abc",
+		},
+		{
+			givenString: "abc",
+			givenFilters: []RuneFilterFunc{
+				RuneFilterAlwaysFalse(),
+			},
+			expected: "abc",
+		},
+		{
+			givenString: "abc",
+			givenFilters: []RuneFilterFunc{
+				RuneFilterAlwaysTrue(),
+			},
+			expected: "",
+		},
+		{
+			givenString: "abc",
+			givenFilters: []RuneFilterFunc{
+				RuneIsA(),
+			},
+			expected: "bc",
+		},
+		{
+			givenString: "abc",
+			givenFilters: []RuneFilterFunc{
+				RuneIsNotA(),
+			},
+			expected: "a",
+		},
+		{
+			givenString: "abc",
+			givenFilters: []RuneFilterFunc{
+				RuneIsNotA(),
+				RuneIsA(),
+			},
+			expected: "",
+		},
+	}
+
+	for i, testCase := range testCases {
+		result := FilterStringChars(testCase.givenString, testCase.givenFilters)
+		if result != testCase.expected {
+			t.Error("test", i, "given", testCase.givenString, "and", testCase.givenFilters, "expected", testCase.expected, "result", result)
+		}
+	}
+}
+
+func TestRemoveControlCharsFromString(t *testing.T) {
+	var testCases = []struct {
+		given    string
+		expected string
+	}{
+		{
+			given:    "",
+			expected: "",
+		},
+		{
+			given:    "adfadgafdag32412@!@$",
+			expected: "adfadgafdag32412@!@$",
+		},
+		{
+			given:    "adfadgafda" + string(rune(1)) + "g32412@!@$",
+			expected: "adfadgafdag32412@!@$",
+		},
+		{
+			given:    string(rune(1)) + "adfadgafda" + string(rune(1)) + "g32412@!@$" + string(rune(1)),
+			expected: "adfadgafdag32412@!@$",
+		},
+	}
+
+	for i, testCase := range testCases {
+		result := RemoveControlCharsFromString(testCase.given)
+		if result != testCase.expected {
+			t.Error("test", i, "given", testCase.given, "expected", testCase.expected, "result", result)
+		}
+	}
+}

types.go

@@ -6,8 +6,3 @@ type SeparatedCaseOptions struct {
 	Separator   rune
 	IsScreaming bool
 }
-
-type DecomposedRune struct {
-	NextRunes map[rune]DecomposedRune
-	Value     rune
-}

utils.go

@@ -56,7 +56,7 @@ func RuneMapToMapFunc(runeMap map[rune]rune, caseSensitive bool) func(rune) rune
 	}
 }
 
-// RuneMapConversion - given a string and a map, converts every rune in string to corresponding map value
+// RuneMapToStringConversion - given a string and a map, converts every rune in string to corresponding map value
 func RuneMapToStringConversion(s string, m map[rune]string, caseSensitive bool) string {
 	var output strings.Builder
 	for _, r := range s {
@@ -77,24 +77,3 @@ func RuneMapToStringConversion(s string, m map[rune]string, caseSensitive bool)
 	}
 	return output.String()
 }
-
-type RuneFilterFunc func(rune) bool
-
-func FilterStringByRune(s string, filters []RuneFilterFunc) string {
-	var result strings.Builder
-	for _, r := range s {
-		if !runeIsFiltered(r) {
-			result.WriteRune(r)
-		}
-	}
-	return result.String()
-}
-
-func runeIsFiltered(r rune, filters []RuneFilterFunc) bool {
-	for _, filter := range filters {
-		if filter(r) {
-			return true
-		}
-	}
-	return false
-}