Switch from BoolTrue to optional.Option[bool] (#5693)

shared/optional/option.go

@@ -0,0 +1,82 @@
+// Copyright 2025 Woodpecker Authors.
+// Copyright 2024 The Gitea Authors.
+//
+// Licensed under the MIT License.
+
+package optional
+
+import "reflect"
+
+type Option[T any] []T
+
+func None[T any]() Option[T] {
+	return nil
+}
+
+func Some[T any](v T) Option[T] {
+	return Option[T]{v}
+}
+
+func FromPtr[T any](v *T) Option[T] {
+	if v == nil {
+		return None[T]()
+	}
+	return Some(*v)
+}
+
+func FromNonDefault[T comparable](v T) Option[T] {
+	var zero T
+	if v == zero {
+		return None[T]()
+	}
+	return Some(v)
+}
+
+func (o Option[T]) Has() bool {
+	return o != nil
+}
+
+func (o Option[T]) Value() T {
+	var zero T
+	return o.ValueOrDefault(zero)
+}
+
+func (o Option[T]) ValueOrDefault(v T) T {
+	if o.Has() {
+		return o[0]
+	}
+	return v
+}
+
+func (o Option[T]) ToPtr() *T {
+	if o.Has() {
+		return &o[0]
+	}
+	return nil
+}
+
+// ExtractValue return value or nil and bool if object was an Optional
+// it should only be used if you already have to deal with interface{} values
+// and expect an Option type within it.
+func ExtractValue(obj any) (any, bool) {
+	rt := reflect.TypeOf(obj)
+	if rt.Kind() != reflect.Slice {
+		return nil, false
+	}
+
+	type hasHasFunc interface {
+		Has() bool
+	}
+	if hasObj, ok := obj.(hasHasFunc); !ok {
+		return nil, false
+	} else if !hasObj.Has() {
+		return nil, true
+	}
+
+	rv := reflect.ValueOf(obj)
+	if rv.Len() != 1 {
+		// it's still false as optional.Option[T] types would have reported with hasObj.Has() that it is empty
+		return nil, false
+	}
+	return rv.Index(0).Interface(), true
+}

shared/optional/option_test.go

@@ -0,0 +1,99 @@
+// Copyright 2025 Woodpecker Authors.
+// Copyright 2024 The Gitea Authors.
+//
+// Licensed under the MIT License.
+
+package optional_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"go.woodpecker-ci.org/woodpecker/v3/shared/optional"
+)
+
+func TestOption(t *testing.T) {
+	var uninitialized optional.Option[int]
+	assert.False(t, uninitialized.Has())
+	assert.Equal(t, int(0), uninitialized.Value())
+	assert.Equal(t, int(1), uninitialized.ValueOrDefault(1))
+
+	none := optional.None[int]()
+	assert.False(t, none.Has())
+	assert.Equal(t, int(0), none.Value())
+	assert.Equal(t, int(1), none.ValueOrDefault(1))
+
+	some := optional.Some[int](1)
+	assert.True(t, some.Has())
+	assert.Equal(t, int(1), some.Value())
+	assert.Equal(t, int(1), some.ValueOrDefault(2))
+
+	var ptr *int
+	assert.False(t, optional.FromPtr(ptr).Has())
+
+	var boolPtr *bool
+	assert.Equal(t, boolPtr, optional.None[bool]().ToPtr())
+
+	boolPtr = optional.Some[bool](false).ToPtr()
+	assert.Equal(t, toPtr(false), boolPtr)
+
+	opt1 := optional.FromPtr(toPtr(1))
+	assert.True(t, opt1.Has())
+	assert.Equal(t, int(1), opt1.Value())
+
+	assert.False(t, optional.FromNonDefault("").Has())
+
+	opt2 := optional.FromNonDefault("test")
+	assert.True(t, opt2.Has())
+	assert.Equal(t, "test", opt2.Value())
+
+	assert.False(t, optional.FromNonDefault(0).Has())
+
+	opt3 := optional.FromNonDefault(1)
+	assert.True(t, opt3.Has())
+	assert.Equal(t, int(1), opt3.Value())
+}
+
+func TestExtractValue(t *testing.T) {
+	val, ok := optional.ExtractValue("aaaa")
+	assert.False(t, ok)
+	assert.Nil(t, val)
+
+	val, ok = optional.ExtractValue(optional.Some("aaaa"))
+	assert.True(t, ok)
+	if assert.NotNil(t, val) {
+		val, ok := val.(string)
+		assert.True(t, ok)
+		assert.EqualValues(t, "aaaa", val)
+	}
+
+	val, ok = optional.ExtractValue(optional.None[float64]())
+	assert.True(t, ok)
+	assert.Nil(t, val)
+
+	val, ok = optional.ExtractValue(&fakeHas{})
+	assert.False(t, ok)
+	assert.Nil(t, val)
+
+	wrongType := make(fakeHas2, 0, 1)
+	val, ok = optional.ExtractValue(wrongType)
+	assert.False(t, ok)
+	assert.Nil(t, val)
+}
+
+func toPtr[T any](val T) *T {
+	return &val
+}
+
+type fakeHas struct{}
+
+func (fakeHas) Has() bool {
+	return true
+}
+
+type fakeHas2 []string
+
+func (fakeHas2) Has() bool {
+	return true
+}

shared/optional/serialization.go

@@ -0,0 +1,48 @@
+// Copyright 2025 Woodpecker Authors.
+// Copyright 2024 "6543".
+//
+// Licensed under the MIT License.
+
+package optional
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+func (o *Option[T]) UnmarshalJSON(data []byte) error {
+	var v *T
+	if err := json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	*o = FromPtr(v)
+	return nil
+}
+
+func (o Option[T]) MarshalJSON() ([]byte, error) {
+	if !o.Has() {
+		return []byte("null"), nil
+	}
+
+	return json.Marshal(o.Value())
+}
+
+func (o *Option[T]) UnmarshalYAML(value *yaml.Node) error {
+	var v *T
+	if err := value.Decode(&v); err != nil {
+		return err
+	}
+	*o = FromPtr(v)
+	return nil
+}
+
+func (o Option[T]) MarshalYAML() (any, error) {
+	if !o.Has() {
+		return nil, nil
+	}
+
+	value := new(yaml.Node)
+	err := value.Encode(o.Value())
+	return value, err
+}

shared/optional/serialization_json_test.go

@@ -0,0 +1,91 @@
+// Copyright 2025 Woodpecker Authors.
+// Copyright 2024 "6543".
+//
+// Licensed under the MIT License.
+
+package optional_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/stretchr/testify/assert"
+
+	"go.woodpecker-ci.org/woodpecker/v3/shared/optional"
+)
+
+func TestOptionalToJson(t *testing.T) {
+	tests := []struct {
+		name string
+		obj  *testSerializationStruct
+		want string
+	}{
+		{
+			name: "empty",
+			obj:  new(testSerializationStruct),
+			want: `{"normal_string":"","normal_bool":false,"optional_two_bool":null,"optional_twostring":null}`,
+		},
+		{
+			name: "some",
+			obj: &testSerializationStruct{
+				NormalString: "a string",
+				NormalBool:   true,
+				OptBool:      optional.Some(false),
+				OptString:    optional.Some(""),
+			},
+			want: `{"normal_string":"a string","normal_bool":true,"optional_bool":false,"optional_string":"","optional_two_bool":null,"optional_twostring":null}`,
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			b, err := json.Marshal(tc.obj)
+			assert.NoError(t, err)
+			assert.EqualValues(t, tc.want, string(b), "gitea json module returned unexpected")
+
+			b, err = jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(tc.obj)
+			assert.NoError(t, err)
+			assert.EqualValues(t, tc.want, string(b), "std json module returned unexpected")
+		})
+	}
+}
+
+func TestOptionalFromJson(t *testing.T) {
+	tests := []struct {
+		name string
+		data string
+		want testSerializationStruct
+	}{
+		{
+			name: "empty",
+			data: `{}`,
+			want: testSerializationStruct{
+				NormalString: "",
+				OptBool:      optional.None[bool](),
+			},
+		},
+		{
+			name: "some",
+			data: `{"normal_string":"a string","normal_bool":true,"optional_bool":false,"optional_string":"","optional_two_bool":null,"optional_twostring":null}`,
+			want: testSerializationStruct{
+				NormalString: "a string",
+				NormalBool:   true,
+				OptBool:      optional.Some(false),
+				OptString:    optional.Some(""),
+			},
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			var obj1 testSerializationStruct
+			err := json.Unmarshal([]byte(tc.data), &obj1)
+			assert.NoError(t, err)
+			assert.EqualValues(t, tc.want, obj1, "gitea json module returned unexpected")
+
+			var obj2 testSerializationStruct
+			err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal([]byte(tc.data), &obj2)
+			assert.NoError(t, err)
+			assert.EqualValues(t, tc.want, obj2, "std json module returned unexpected")
+		})
+	}
+}

shared/optional/serialization_test.go

@@ -0,0 +1,19 @@
+// Copyright 2025 Woodpecker Authors.
+// Copyright 2024 "6543".
+//
+// Licensed under the MIT License.
+
+package optional_test
+
+import (
+	"go.woodpecker-ci.org/woodpecker/v3/shared/optional"
+)
+
+type testSerializationStruct struct {
+	NormalString string                  `json:"normal_string" yaml:"normal_string"`
+	NormalBool   bool                    `json:"normal_bool" yaml:"normal_bool"`
+	OptBool      optional.Option[bool]   `json:"optional_bool,omitempty" yaml:"optional_bool,omitempty"`
+	OptString    optional.Option[string] `json:"optional_string,omitempty" yaml:"optional_string,omitempty"`
+	OptTwoBool   optional.Option[bool]   `json:"optional_two_bool" yaml:"optional_two_bool"`
+	OptTwoString optional.Option[string] `json:"optional_twostring" yaml:"optional_two_string"`
+}

shared/optional/serialization_yaml_test.go

@@ -0,0 +1,148 @@
+// Copyright 2025 Woodpecker Authors.
+// Copyright 2024 "6543".
+//
+// Licensed under the MIT License.
+
+package optional_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
+
+	"go.woodpecker-ci.org/woodpecker/v3/shared/optional"
+)
+
+type testBoolStruct struct {
+	OptBoolOmitEmpty1 optional.Option[bool] `json:"opt_bool_omit_empty_1,omitempty" yaml:"opt_bool_omit_empty_1,omitempty"`
+	OptBoolOmitEmpty2 optional.Option[bool] `json:"opt_bool_omit_empty_2,omitempty" yaml:"opt_bool_omit_empty_2,omitempty"`
+	OptBoolOmitEmpty3 optional.Option[bool] `json:"opt_bool_omit_empty_3,omitempty" yaml:"opt_bool_omit_empty_3,omitempty"`
+	OptBool4          optional.Option[bool] `json:"opt_bool_4" yaml:"opt_bool_4"`
+	OptBool5          optional.Option[bool] `json:"opt_bool_5" yaml:"opt_bool_5"`
+	OptBool6          optional.Option[bool] `json:"opt_bool_6" yaml:"opt_bool_6"`
+}
+
+func TestOptionalBoolYaml(t *testing.T) {
+	tYaml := `
+opt_bool_omit_empty_1: false
+opt_bool_omit_empty_2: true
+opt_bool_4: false
+opt_bool_5: true
+`
+
+	tObj := new(testBoolStruct)
+	t.Run("Unmarshal", func(t *testing.T) {
+		err := yaml.Unmarshal([]byte(tYaml), tObj)
+		require.NoError(t, err)
+		assert.EqualValues(t, &testBoolStruct{
+			OptBoolOmitEmpty1: optional.Some(false),
+			OptBoolOmitEmpty2: optional.Some(true),
+			OptBoolOmitEmpty3: optional.None[bool](),
+			OptBool4:          optional.Some(false),
+			OptBool5:          optional.Some(true),
+			OptBool6:          optional.None[bool](),
+		}, tObj)
+	})
+	t.Run("Marshal", func(t *testing.T) {
+		tBytes, err := yaml.Marshal(tObj)
+		require.NoError(t, err)
+		assert.EqualValues(t, `opt_bool_omit_empty_1: false
+opt_bool_omit_empty_2: true
+opt_bool_4: false
+opt_bool_5: true
+opt_bool_6: null
+`, string(tBytes))
+	})
+}
+
+func TestOptionalToYaml(t *testing.T) {
+	tests := []struct {
+		name string
+		obj  *testSerializationStruct
+		want string
+	}{
+		{
+			name: "empty",
+			obj:  new(testSerializationStruct),
+			want: `normal_string: ""
+normal_bool: false
+optional_two_bool: null
+optional_two_string: null
+`,
+		},
+		{
+			name: "some",
+			obj: &testSerializationStruct{
+				NormalString: "a string",
+				NormalBool:   true,
+				OptBool:      optional.Some(false),
+				OptString:    optional.Some(""),
+			},
+			want: `normal_string: a string
+normal_bool: true
+optional_bool: false
+optional_string: ""
+optional_two_bool: null
+optional_two_string: null
+`,
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			b, err := yaml.Marshal(tc.obj)
+			assert.NoError(t, err)
+			assert.EqualValues(t, tc.want, string(b), "yaml module returned unexpected")
+		})
+	}
+}
+
+func TestOptionalFromYaml(t *testing.T) {
+	tests := []struct {
+		name string
+		data string
+		want testSerializationStruct
+	}{
+		{
+			name: "empty",
+			data: ``,
+			want: testSerializationStruct{},
+		},
+		{
+			name: "empty but init",
+			data: `normal_string: ""
+normal_bool: false
+optional_bool:
+optional_two_bool:
+optional_two_string:
+`,
+			want: testSerializationStruct{},
+		},
+		{
+			name: "some",
+			data: `
+normal_string: a string
+normal_bool: true
+optional_bool: false
+optional_string: ""
+optional_two_bool: null
+optional_twostring: null
+`,
+			want: testSerializationStruct{
+				NormalString: "a string",
+				NormalBool:   true,
+				OptBool:      optional.Some(false),
+				OptString:    optional.Some(""),
+			},
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			var obj testSerializationStruct
+			err := yaml.Unmarshal([]byte(tc.data), &obj)
+			assert.NoError(t, err)
+			assert.EqualValues(t, tc.want, obj, "yaml module returned unexpected")
+		})
+	}
+}