feat: add custom cli flags (#48)

Adds two custom cli flags:
- `StringMapFlag` parses JSON to string map used for plugin map options
- `StringSliceFlag` parses comma-separated plugin slice options to slice and supports escaping

Reviewed-on: https://codeberg.org/woodpecker-plugins/go-plugin/pulls/48
Reviewed-by: Patrick Schratz <pat-s@noreply.codeberg.org>
Co-authored-by: Robert Kaussow <mail@thegeeklab.de>
Co-committed-by: Robert Kaussow <mail@thegeeklab.de>

cli/flag_string_map.go

@@ -0,0 +1,84 @@
+package cli
+
+import (
+	"encoding/json"
+
+	"github.com/urfave/cli/v3"
+)
+
+// StringMapFlag is a flag type which supports JSON string maps.
+type (
+	StringMapFlag = cli.FlagBase[map[string]string, StringMapConfig, StringMap]
+)
+
+// StringMapConfig defines the configuration for string map flags.
+type StringMapConfig struct {
+	// Any config options can be added here if needed
+}
+
+// StringMap implements the Value and ValueCreator interfaces for string maps.
+type StringMap struct {
+	destination *map[string]string
+}
+
+// Create implements the ValueCreator interface.
+func (s StringMap) Create(v map[string]string, p *map[string]string, _ StringMapConfig) cli.Value {
+	*p = map[string]string{}
+
+	if v != nil {
+		*p = v
+	}
+
+	return &StringMap{
+		destination: p,
+	}
+}
+
+// ToString implements the ValueCreator interface.
+func (s StringMap) ToString(v map[string]string) string {
+	if len(v) == 0 {
+		return ""
+	}
+
+	jsonBytes, err := json.Marshal(v)
+	if err != nil {
+		return ""
+	}
+
+	return string(jsonBytes)
+}
+
+// Set implements the flag.Value interface.
+func (s *StringMap) Set(v string) error {
+	*s.destination = map[string]string{}
+
+	if v == "" {
+		return nil
+	}
+
+	err := json.Unmarshal([]byte(v), s.destination)
+	if err != nil {
+		(*s.destination)["*"] = v
+	}
+
+	return nil
+}
+
+// Get implements the flag.Value interface.
+func (s *StringMap) Get() any {
+	return *s.destination
+}
+
+// String implements the flag.Value interface.
+func (s *StringMap) String() string {
+	if s.destination == nil || len(*s.destination) == 0 {
+		return ""
+	}
+
+	jsonBytes, err := json.Marshal(*s.destination)
+	if err != nil {
+		return ""
+	}
+
+	return string(jsonBytes)
+}

cli/flag_string_map_test.go

@@ -0,0 +1,221 @@
+package cli
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStringMapSet(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  map[string]string
+	}{
+		{
+			name:  "empty string",
+			input: "",
+			want:  map[string]string{},
+		},
+		{
+			name:  "valid JSON",
+			input: `{"key1":"value1","key2":"value2"}`,
+			want:  map[string]string{"key1": "value1", "key2": "value2"},
+		},
+		{
+			name:  "single key-value",
+			input: `{"key":"value"}`,
+			want:  map[string]string{"key": "value"},
+		},
+		{
+			name:  "non-JSON string",
+			input: "not-json",
+			want:  map[string]string{"*": "not-json"},
+		},
+		{
+			name:  "empty JSON object",
+			input: "{}",
+			want:  map[string]string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var dest map[string]string
+			s := &StringMap{
+				destination: &dest,
+			}
+
+			err := s.Set(tt.input)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.want, dest)
+		})
+	}
+}
+
+func TestStringMapString(t *testing.T) {
+	tests := []struct {
+		name  string
+		input map[string]string
+		want  string
+	}{
+		{
+			name:  "empty map",
+			input: map[string]string{},
+			want:  "",
+		},
+		{
+			name:  "nil map",
+			input: nil,
+			want:  "",
+		},
+		{
+			name:  "single key-value",
+			input: map[string]string{"key": "value"},
+			want:  `{"key":"value"}`,
+		},
+		{
+			name:  "multiple key-values",
+			input: map[string]string{"key1": "value1", "key2": "value2"},
+			want:  `{"key1":"value1","key2":"value2"}`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &StringMap{
+				destination: &tt.input,
+			}
+
+			got := s.String()
+
+			if len(tt.input) > 1 {
+				var expected, actual map[string]string
+				_ = json.Unmarshal([]byte(tt.want), &expected)
+				_ = json.Unmarshal([]byte(got), &actual)
+				assert.EqualValues(t, expected, actual)
+
+				return
+			}
+
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestStringMapGet(t *testing.T) {
+	tests := []struct {
+		name string
+		want map[string]string
+	}{
+		{
+			name: "empty map",
+			want: map[string]string{},
+		},
+		{
+			name: "single key-value",
+			want: map[string]string{"key": "value"},
+		},
+		{
+			name: "multiple key-values",
+			want: map[string]string{"key1": "value1", "key2": "value2"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &StringMap{
+				destination: &tt.want,
+			}
+
+			result := s.Get()
+			assert.Equal(t, tt.want, result)
+		})
+	}
+}
+
+func TestStringMapCreate(t *testing.T) {
+	tests := []struct {
+		name  string
+		input map[string]string
+		want  map[string]string
+	}{
+		{
+			name:  "empty map",
+			input: nil,
+			want:  map[string]string{},
+		},
+		{
+			name:  "empty map",
+			input: map[string]string{},
+			want:  map[string]string{},
+		},
+		{
+			name:  "single key-value",
+			input: map[string]string{"key": "value"},
+			want:  map[string]string{"key": "value"},
+		},
+		{
+			name:  "multiple key-values",
+			input: map[string]string{"key1": "value1", "key2": "value2"},
+			want:  map[string]string{"key1": "value1", "key2": "value2"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var dest map[string]string
+
+			s := StringMap{}
+			config := StringMapConfig{}
+
+			got := s.Create(tt.input, &dest, config)
+			assert.Equal(t, tt.want, dest)
+			assert.Equal(t, &dest, got.(*StringMap).destination)
+		})
+	}
+}
+
+func TestStringMapToString(t *testing.T) {
+	tests := []struct {
+		name  string
+		input map[string]string
+		want  string
+	}{
+		{
+			name:  "empty map",
+			input: map[string]string{},
+			want:  "",
+		},
+		{
+			name:  "single key-value",
+			input: map[string]string{"key": "value"},
+			want:  `{"key":"value"}`,
+		},
+		{
+			name:  "multiple key-values",
+			input: map[string]string{"key1": "value1", "key2": "value2"},
+			want:  `{"key1":"value1","key2":"value2"}`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := StringMap{}
+
+			got := s.ToString(tt.input)
+
+			if len(tt.input) > 1 {
+				var expected, actual map[string]string
+				_ = json.Unmarshal([]byte(tt.want), &expected)
+				_ = json.Unmarshal([]byte(got), &actual)
+				assert.EqualValues(t, expected, actual)
+
+				return
+			}
+
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

cli/flag_string_slice.go

@@ -0,0 +1,83 @@
+package cli
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/urfave/cli/v3"
+)
+
+// StringSliceFlag is a flag type which support comma separated values and escaping to not split at unwanted lines.
+type (
+	StringSliceFlag = cli.FlagBase[[]string, StringSliceConfig, StringSlice]
+)
+
+// StringConfig defines the configuration for string flags.
+type StringSliceConfig struct {
+	Delimiter    string
+	EscapeString string
+}
+
+// StringSlice implements the Value and ValueCreator interfaces for string slices.
+type StringSlice struct {
+	destination  *[]string
+	delimiter    string
+	escapeString string
+}
+
+// Create implements the ValueCreator interface.
+func (s StringSlice) Create(v []string, p *[]string, c StringSliceConfig) cli.Value {
+	*p = v
+
+	return &StringSlice{
+		destination:  p,
+		delimiter:    c.Delimiter,
+		escapeString: c.EscapeString,
+	}
+}
+
+// ToString implements the ValueCreator interface.
+func (s StringSlice) ToString(v []string) string {
+	if len(v) == 0 {
+		return ""
+	}
+
+	return fmt.Sprintf("%q", strings.Join(v, s.delimiter))
+}
+
+// Set implements the flag.Value interface.
+func (s *StringSlice) Set(v string) error {
+	if v == "" {
+		*s.destination = []string{}
+
+		return nil
+	}
+
+	out := strings.Split(v, s.delimiter)
+
+	//nolint:mnd
+	for i := len(out) - 2; i >= 0; i-- {
+		if strings.HasSuffix(out[i], s.escapeString) {
+			out[i] = out[i][:len(out[i])-len(s.escapeString)] + s.delimiter + out[i+1]
+			out = append(out[:i+1], out[i+2:]...)
+		}
+	}
+
+	*s.destination = out
+
+	return nil
+}
+
+// Get implements the flag.Value interface.
+func (s *StringSlice) Get() any {
+	return *s.destination
+}
+
+// String implements the flag.Value interface.
+func (s *StringSlice) String() string {
+	if s.destination == nil || len(*s.destination) == 0 {
+		return ""
+	}
+
+	return strings.Join(*s.destination, s.delimiter)
+}

cli/flag_string_slice_test.go

@@ -0,0 +1,225 @@
+package cli
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStringSliceSet(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  []string
+	}{
+		{
+			name:  "empty string",
+			input: "",
+			want:  []string{},
+		},
+		{
+			name:  "simple comma separated",
+			input: "a,b",
+			want:  []string{"a", "b"},
+		},
+		{
+			name:  "multiple commas",
+			input: ",,,",
+			want:  []string{"", "", "", ""},
+		},
+		{
+			name:  "escaped comma",
+			input: ",a\\,",
+			want:  []string{"", "a,"},
+		},
+		{
+			name:  "escaped backslash",
+			input: "a,b\\,c\\\\d,e",
+			want:  []string{"a", "b,c\\\\d", "e"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var got []string
+			s := &StringSlice{
+				destination:  &got,
+				delimiter:    ",",
+				escapeString: "\\",
+			}
+
+			err := s.Set(tt.input)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestStringSliceString(t *testing.T) {
+	tests := []struct {
+		name  string
+		input []string
+		want  string
+	}{
+		{
+			name:  "empty slice",
+			input: []string{},
+			want:  "",
+		},
+		{
+			name:  "nil slice",
+			input: nil,
+			want:  "",
+		},
+		{
+			name:  "single item",
+			input: []string{"a"},
+			want:  "a",
+		},
+		{
+			name:  "multiple items",
+			input: []string{"a", "b", "c"},
+			want:  "a,b,c",
+		},
+		{
+			name:  "items with commas",
+			input: []string{"a,b", "c"},
+			want:  "a,b,c",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &StringSlice{
+				destination:  &tt.input,
+				delimiter:    ",",
+				escapeString: "\\",
+			}
+
+			assert.Equal(t, tt.want, s.String())
+		})
+	}
+}
+
+func TestStringSliceGet(t *testing.T) {
+	tests := []struct {
+		name string
+		want []string
+	}{
+		{
+			name: "empty slice",
+			want: []string{},
+		},
+		{
+			name: "single item",
+			want: []string{"a"},
+		},
+		{
+			name: "multiple items",
+			want: []string{"a", "b", "c"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &StringSlice{
+				destination:  &tt.want,
+				delimiter:    ",",
+				escapeString: "\\",
+			}
+
+			result := s.Get()
+			assert.Equal(t, tt.want, result)
+		})
+	}
+}
+
+func TestStringSliceCreate(t *testing.T) {
+	tests := []struct {
+		name   string
+		input  []string
+		want   []string
+		config StringSliceConfig
+	}{
+		{
+			name:  "empty slice",
+			input: nil,
+			want:  []string{},
+		},
+		{
+			name:  "default config",
+			input: []string{"a", "b"},
+			want:  []string{"a", "b"},
+			config: StringSliceConfig{
+				Delimiter:    ",",
+				EscapeString: "\\",
+			},
+		},
+		{
+			name:  "custom config",
+			input: []string{"a", "b"},
+			want:  []string{"a", "b"},
+			config: StringSliceConfig{
+				Delimiter:    ";",
+				EscapeString: "#",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var dest []string
+
+			s := StringSlice{}
+			got := s.Create(tt.input, &dest, tt.config)
+
+			assert.Equal(t, tt.input, dest)
+			assert.Equal(t, &dest, got.(*StringSlice).destination)
+			assert.Equal(t, tt.config.Delimiter, got.(*StringSlice).delimiter)
+			assert.Equal(t, tt.config.EscapeString, got.(*StringSlice).escapeString)
+		})
+	}
+}
+
+func TestStringSliceToString(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     []string
+		delimiter string
+		want      string
+	}{
+		{
+			name:      "empty slice",
+			input:     []string{},
+			delimiter: ",",
+			want:      "",
+		},
+		{
+			name:      "single item",
+			input:     []string{"a"},
+			delimiter: ",",
+			want:      `"a"`,
+		},
+		{
+			name:      "multiple items",
+			input:     []string{"a", "b", "c"},
+			delimiter: ",",
+			want:      `"a,b,c"`,
+		},
+		{
+			name:      "custom delimiter",
+			input:     []string{"a", "b", "c"},
+			delimiter: ";",
+			want:      `"a;b;c"`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := StringSlice{delimiter: tt.delimiter}
+
+			got := s.ToString(tt.input)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}