Merge branch 'release/v1.4.0'

Author: EvilLord666

README.md

@@ -1,6 +1,7 @@
 # StringFormatter
 
 A set of a ***high performance string tools*** that helps to build strings from templates and process text faster than with `fmt`!!!.
+Slice printing is **50% faster with 8 items** slice and **250% with 20 items** slice 
 
 ![GitHub go.mod Go version (subdirectory of monorepo)](https://img.shields.io/github/go-mod/go-version/wissance/stringFormatter?style=plastic) 
 ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/wissance/stringFormatter?style=plastic) 
@@ -76,6 +77,9 @@ For more convenient lines formatting we should choose how arguments are represen
    - `{0:F8}, 10.4567890 outputs -> 10.45678900`
 5. Percentage output
    - `{0:P100}, 12 outputs -> 12%`
+6. Lists
+   - `{0:L-}, [1,2,3] outputs -> 1-2-3`
+   - `{0:L, }, [1,2,3] outputs -> 1, 2, 3`
 
 ##### 1.2.4 Benchmarks of the Format and FormatComplex functions
 
@@ -107,12 +111,26 @@ str := stringFormatter.MapToString(&options, "{key} : {value}", ", ")
 "connectTimeout : 1000, useSsl : true, login : sa, password : sa"
 ```
 
-#### 2.2 Benchmarks of the MapToStr function
+#### 2.2 Benchmarks of the MapToString function
 
 * to see `MapToStr` result - `go test -bench=MapToStr -benchmem -cpu 1`
 
 ![MapToStr benchmarks](/img/map2str_benchmarks.png)
 
+#### 2.3 Slice to string utility
+
+`SliceToString` - function that converts slice with passed separation between items to string.
+```go
+slice := []any{100, "200", 300, "400", 500, 600, "700", 800, 1.09, "hello"}
+separator := ","
+result := stringFormatter.SliceToString(&slice, &separator)
+```
+
+#### 2.4 Benchmarks of the SliceToString function
+
+`sf` is rather fast then `fmt` 2.5 times (250%) faster on slice with 20 items, see benchmark:
+![SliceToStr benchmarks](/img/slice2str_benchmarks.png)
+
 ### 3. Contributors
 
 <a href="https://github.com/Wissance/stringFormatter/graphs/contributors">

formatter.go

@@ -7,7 +7,7 @@ import (
 )
 
 const argumentFormatSeparator = ":"
-const bytesPerArgDefault = 20
+const bytesPerArgDefault = 16
 
 // Format
 /* Func that makes string formatting from template
@@ -105,8 +105,8 @@ func Format(template string, args ...any) string {
 					formatOptionIndex := strings.Index(argNumberStr, argumentFormatSeparator)
 					// formatOptionIndex can't be == 0, because 0 is a position of arg number
 					if formatOptionIndex > 0 {
-						// trim formatting string to remove spaces
-						argFormatOptions = strings.Trim(argNumberStr[formatOptionIndex+1:], " ")
+						// trimmed was down later due to we could format list with space separator
+						argFormatOptions = argNumberStr[formatOptionIndex+1:]
 						argNumberStrPart := argNumberStr[:formatOptionIndex]
 						argNumber, err = strconv.Atoi(strings.Trim(argNumberStrPart, " "))
 						if err == nil {
@@ -218,7 +218,8 @@ func FormatComplex(template string, args map[string]any) string {
 				if !ok {
 					formatOptionIndex := strings.Index(argNumberStr, argumentFormatSeparator)
 					if formatOptionIndex >= 0 {
-						argFormatOptions = strings.Trim(argNumberStr[formatOptionIndex+1:], " ")
+						// argFormatOptions = strings.Trim(argNumberStr[formatOptionIndex+1:], " ")
+						argFormatOptions = argNumberStr[formatOptionIndex+1:]
 						argNumberStr = strings.Trim(argNumberStr[:formatOptionIndex], " ")
 					}
 
@@ -278,10 +279,11 @@ func getItemAsStr(item *any, itemFormat *string) string {
 		 * OUR own addition:
 		 * 1. O(o) - octahedral number format
 		 */
-		preparedArgFormat = *itemFormat
+		// preparedArgFormat is trimmed format, L type could contain spaces
+		preparedArgFormat = strings.Trim(*itemFormat, " ")
 		postProcessingRequired = len(preparedArgFormat) > 1
 
-		switch rune((*itemFormat)[0]) {
+		switch rune(preparedArgFormat[0]) {
 		case 'd', 'D':
 			base = 10
 			intNumberFormat = true
@@ -331,7 +333,15 @@ func getItemAsStr(item *any, itemFormat *string) string {
 					return strconv.FormatFloat(percentage, floatFormat, 2, 64)
 				}
 			}
-
+		// l(L) is for list(slice)
+		case 'l', 'L':
+			separator := ","
+			if len(*itemFormat) > 1 {
+				separator = (*itemFormat)[1:]
+			}
+			// slice processing converting to {item}{delimiter}{item}{delimiter}{item}
+			slice := (*item).([]any)
+			return SliceToString(&slice, &separator)
 		default:
 			base = 10
 		}

formatter_benchmark_test.go

@@ -1,14 +1,15 @@
-package stringFormatter
+package stringFormatter_test
 
 import (
 	"fmt"
+	"github.com/wissance/stringFormatter"
 	"testing"
 	"time"
 )
 
 func BenchmarkFormat4Arg(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		_ = Format(
+		_ = stringFormatter.Format(
 			"Today is : {0}, atmosphere pressure is : {1} mmHg, temperature: {2}, location: {3}",
 			time.Now().String(), 725, -1.54, "Yekaterinburg",
 		)
@@ -17,7 +18,7 @@ func BenchmarkFormat4Arg(b *testing.B) {
 
 func BenchmarkFormat4ArgAdvanced(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		_ = Format(
+		_ = stringFormatter.Format(
 			"Today is : {0}, atmosphere pressure is : {1:E2} mmHg, temperature: {2:E3}, location: {3}",
 			time.Now().String(), 725, -15.54, "Yekaterinburg",
 		)
@@ -44,7 +45,7 @@ func BenchmarkFmt4ArgAdvanced(b *testing.B) {
 
 func BenchmarkFormat6Arg(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		_ = Format(
+		_ = stringFormatter.Format(
 			"Today is : {0}, atmosphere pressure is : {1} mmHg, temperature: {2}, location: {3}, coord:{4}-{5}",
 			time.Now().String(), 725, -1.54, "Yekaterinburg", "64.245", "37.895",
 		)
@@ -71,7 +72,7 @@ func BenchmarkFormatComplex7Arg(b *testing.B) {
 		"latitude":    "35.489",
 	}
 	for i := 0; i < b.N; i++ {
-		_ = FormatComplex(
+		_ = stringFormatter.FormatComplex(
 			"Today is : {time}, atmosphere pressure is : {pressure} mmHg, humidity: {humidity}, temperature: {temperature}, location: {location}, coords:{longitude}-{latitude}",
 			args,
 		)

formatter_test.go

@@ -183,6 +183,21 @@ func TestFormatWithArgFormatting(t *testing.T) {
 			args:     []any{12, "ass"},
 			expected: "This is the text with percentage format - 12.00 / 11.94, and non normal percentage 0.00",
 		},
+		"list_with_default_sep": {
+			template: "This is a list(slice) test: {0:L}",
+			args:     []any{[]any{"s1", "s2", "s3"}},
+			expected: "This is a list(slice) test: s1,s2,s3",
+		},
+		"list_with_dash_sep": {
+			template: "This is a list(slice) test: {0:L-}",
+			args:     []any{[]any{"s1", "s2", "s3"}},
+			expected: "This is a list(slice) test: s1-s2-s3",
+		},
+		"list_with_space_sep": {
+			template: "This is a list(slice) test: {0:L }",
+			args:     []any{[]any{"s1", "s2", "s3"}},
+			expected: "This is a list(slice) test: s1 s2 s3",
+		},
 	} {
 		// Run test here
 		t.Run(name, func(t *testing.T) {
@@ -284,6 +299,21 @@ func TestFormatComplexWithArgFormatting(t *testing.T) {
 			args:     map[string]any{"float": 10.5467890},
 			expected: "This is the text with an only number formatting: decimal - 10.546789 / 10.5468 / 10.54678900",
 		},
+		"list_with_default_sep": {
+			template: "This is a list(slice) test: {list:L}",
+			args:     map[string]any{"list": []any{"s1", "s2", "s3"}},
+			expected: "This is a list(slice) test: s1,s2,s3",
+		},
+		"list_with_dash_sep": {
+			template: "This is a list(slice) test: {list:L-}",
+			args:     map[string]any{"list": []any{"s1", "s2", "s3"}},
+			expected: "This is a list(slice) test: s1-s2-s3",
+		},
+		"list_with_space_sep": {
+			template: "This is a list(slice) test: {list:L }",
+			args:     map[string]any{"list": []any{"s1", "s2", "s3"}},
+			expected: "This is a list(slice) test: s1 s2 s3",
+		},
 	} {
 		t.Run(name, func(t *testing.T) {
 			assert.Equal(t, test.expected, stringFormatter.FormatComplex(test.template, test.args))

img/slice2str_benchmarks.png

@@ -0,0 +1,25 @@
+package stringFormatter
+
+import "strings"
+
+// SliceToString function that converts slice of any type items to string in format {item}{sep}{item}...
+// TODO(UMV): probably add one more param to wrap item in quotes if necessary
+func SliceToString(data *[]any, separator *string) string {
+	if len(*data) == 0 {
+		return ""
+	}
+
+	sliceStr := &strings.Builder{}
+	// init memory initially
+	sliceStr.Grow(len(*data)*len(*separator)*2 + (len(*data)-1)*len(*separator))
+	isFirst := true
+	for _, item := range *data {
+		if !isFirst {
+			sliceStr.WriteString(*separator)
+		}
+		sliceStr.WriteString(Format("{0}", item))
+		isFirst = false
+	}
+
+	return sliceStr.String()
+}

maptostring_bench_test.go maptostring_benchmark_test.gomaptostring_bench_test.go renamed to maptostring_benchmark_test.go

@@ -0,0 +1,54 @@
+package stringFormatter_test
+
+import (
+	"fmt"
+	"github.com/wissance/stringFormatter"
+	"testing"
+)
+
+func BenchmarkSliceToStringAdvancedWith8IntItems(b *testing.B) {
+	slice := []any{100, 200, 300, 400, 500, 600, 700, 800}
+	separator := ","
+	for i := 0; i < b.N; i++ {
+		_ = stringFormatter.SliceToString(&slice, &separator)
+	}
+}
+
+func BenchmarkSliceStandard8IntItems(b *testing.B) {
+	slice := []any{100, 200, 300, 400, 500, 600, 700, 800}
+	for i := 0; i < b.N; i++ {
+		_ = fmt.Sprintf("%+q", slice)
+	}
+}
+
+func BenchmarkSliceToStringAdvanced10MixedItems(b *testing.B) {
+	slice := []any{100, "200", 300, "400", 500, 600, "700", 800, 1.09, "hello"}
+	separator := ","
+	for i := 0; i < b.N; i++ {
+		_ = stringFormatter.SliceToString(&slice, &separator)
+	}
+}
+
+func BenchmarkSliceStandard10MixedItems(b *testing.B) {
+	slice := []any{100, "200", 300, "400", 500, 600, "700", 800, 1.09, "hello"}
+	for i := 0; i < b.N; i++ {
+		_ = fmt.Sprintf("%+q", slice)
+	}
+}
+
+func BenchmarkSliceToStringAdvanced20StrItems(b *testing.B) {
+	slice := []any{"str1", "str2", "str3", "str4", "str5", "str6", "str7", "str8", "str9", "str10",
+		"str11", "str12", "str13", "str14", "str15", "str16", "str17", "str18", "str19", "str20"}
+	separator := ","
+	for i := 0; i < b.N; i++ {
+		_ = stringFormatter.SliceToString(&slice, &separator)
+	}
+}
+
+func BenchmarkSliceStandard20StrItems(b *testing.B) {
+	slice := []any{"str1", "str2", "str3", "str4", "str5", "str6", "str7", "str8", "str9", "str10",
+		"str11", "str12", "str13", "str14", "str15", "str16", "str17", "str18", "str19", "str20"}
+	for i := 0; i < b.N; i++ {
+		_ = fmt.Sprintf("%+q", slice)
+	}
+}

slicetostring.go

@@ -0,0 +1,31 @@
+package stringFormatter_test
+
+import (
+	"github.com/stretchr/testify/assert"
+	"github.com/wissance/stringFormatter"
+	"testing"
+)
+
+func TestSliceToString(t *testing.T) {
+	for name, test := range map[string]struct {
+		separator      string
+		data           []any
+		expectedResult string
+	}{
+		"comma-separated slice": {
+			separator:      ", ",
+			data:           []any{11, 22, 33, 44, 55, 66, 77, 88, 99},
+			expectedResult: "11, 22, 33, 44, 55, 66, 77, 88, 99",
+		},
+		"dash(kebab) line from slice": {
+			separator:      "-",
+			data:           []any{"str1", "str2", 101, "str3"},
+			expectedResult: "str1-str2-101-str3",
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			actualResult := stringFormatter.SliceToString(&test.data, &test.separator)
+			assert.Equal(t, test.expectedResult, actualResult)
+		})
+	}
+}

slicetostring_benchmark_test.go

@@ -1,5 +1,9 @@
 $root_dir = Resolve-Path -Path ".."
-echo "******** 1. standadrd fmt formatting lib benchmarks ******** "
+echo "******** 1. standard fmt formatting lib benchmarks ******** "
 go test $root_dir -bench=Fmt -benchmem -cpu 1
 echo "******** 2. stringFormatter lib benchmarks ******** "
-go test $root_dir -bench=Format -benchmem -cpu 1
+go test $root_dir -bench=Format -benchmem -cpu 1
+echo "******** 3. slice fmt benchmarks ******** "
+go test $root_dir -bench=SliceStandard -benchmem -cpu 1
+echo "******** 4. stringFormatter lib benchmarks ******** "
+go test $root_dir -bench=SliceToStringAdvanced -benchmem -cpu 1