chore: modernize code (#857)

Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/857 Reviewed-by: earl-warren <earl-warren@noreply.code.forgejo.org> Reviewed-by: Gusted <gusted@noreply.code.forgejo.org> Co-authored-by: Michael Kriese <michael.kriese@visualon.de> Co-committed-by: Michael Kriese <michael.kriese@visualon.de>
2025-09-15 18:57:01 +00:00 · 2025-08-15 04:54:13 +00:00 · 2025-08-15 04:54:13 +00:00 · 27f425987c
commit 27f425987c
parent 886bf2a4f3
49 changed files with 316 additions and 363 deletions
--- a/act/model/action.go
+++ b/act/model/action.go
@ -12,7 +12,7 @@ import (
 // ActionRunsUsing is the type of runner for the action
 type ActionRunsUsing string

-func (a *ActionRunsUsing) UnmarshalYAML(unmarshal func(interface{}) error) error {
+func (a *ActionRunsUsing) UnmarshalYAML(unmarshal func(any) error) error {
 	var using string
 	if err := unmarshal(&using); err != nil {
 		return err
--- a/act/model/github_context.go
+++ b/act/model/github_context.go
@ -10,39 +10,39 @@ import (
 )

 type GithubContext struct {
-	Event            map[string]interface{} `json:"event"`
-	EventPath        string                 `json:"event_path"`
-	Workflow         string                 `json:"workflow"`
-	RunAttempt       string                 `json:"run_attempt"`
-	RunID            string                 `json:"run_id"`
-	RunNumber        string                 `json:"run_number"`
-	Actor            string                 `json:"actor"`
-	Repository       string                 `json:"repository"`
-	EventName        string                 `json:"event_name"`
-	Sha              string                 `json:"sha"`
-	Ref              string                 `json:"ref"`
-	RefName          string                 `json:"ref_name"`
-	RefType          string                 `json:"ref_type"`
-	HeadRef          string                 `json:"head_ref"`
-	BaseRef          string                 `json:"base_ref"`
-	Token            string                 `json:"token"`
-	Workspace        string                 `json:"workspace"`
-	Action           string                 `json:"action"`
-	ActionPath       string                 `json:"action_path"`
-	ActionRef        string                 `json:"action_ref"`
-	ActionRepository string                 `json:"action_repository"`
-	Job              string                 `json:"job"`
-	JobName          string                 `json:"job_name"`
-	RepositoryOwner  string                 `json:"repository_owner"`
-	RetentionDays    string                 `json:"retention_days"`
-	RunnerPerflog    string                 `json:"runner_perflog"`
-	RunnerTrackingID string                 `json:"runner_tracking_id"`
-	ServerURL        string                 `json:"server_url"`
-	APIURL           string                 `json:"api_url"`
-	GraphQLURL       string                 `json:"graphql_url"`
+	Event            map[string]any `json:"event"`
+	EventPath        string         `json:"event_path"`
+	Workflow         string         `json:"workflow"`
+	RunAttempt       string         `json:"run_attempt"`
+	RunID            string         `json:"run_id"`
+	RunNumber        string         `json:"run_number"`
+	Actor            string         `json:"actor"`
+	Repository       string         `json:"repository"`
+	EventName        string         `json:"event_name"`
+	Sha              string         `json:"sha"`
+	Ref              string         `json:"ref"`
+	RefName          string         `json:"ref_name"`
+	RefType          string         `json:"ref_type"`
+	HeadRef          string         `json:"head_ref"`
+	BaseRef          string         `json:"base_ref"`
+	Token            string         `json:"token"`
+	Workspace        string         `json:"workspace"`
+	Action           string         `json:"action"`
+	ActionPath       string         `json:"action_path"`
+	ActionRef        string         `json:"action_ref"`
+	ActionRepository string         `json:"action_repository"`
+	Job              string         `json:"job"`
+	JobName          string         `json:"job_name"`
+	RepositoryOwner  string         `json:"repository_owner"`
+	RetentionDays    string         `json:"retention_days"`
+	RunnerPerflog    string         `json:"runner_perflog"`
+	RunnerTrackingID string         `json:"runner_tracking_id"`
+	ServerURL        string         `json:"server_url"`
+	APIURL           string         `json:"api_url"`
+	GraphQLURL       string         `json:"graphql_url"`
 }

-func asString(v interface{}) string {
+func asString(v any) string {
 	if v == nil {
 		return ""
 	} else if s, ok := v.(string); ok {
@ -51,7 +51,7 @@ func asString(v interface{}) string {
 	return ""
 }

-func nestedMapLookup(m map[string]interface{}, ks ...string) (rval interface{}) {
+func nestedMapLookup(m map[string]any, ks ...string) (rval any) {
 	var ok bool

 	if len(ks) == 0 { // degenerate input
@ -61,20 +61,20 @@ func nestedMapLookup(m map[string]interface{}, ks ...string) (rval interface{})
 		return nil
 	} else if len(ks) == 1 { // we've reached the final key
 		return rval
-	} else if m, ok = rval.(map[string]interface{}); !ok {
+	} else if m, ok = rval.(map[string]any); !ok {
 		return nil
 	}
 	// 1+ more keys
 	return nestedMapLookup(m, ks[1:]...)
 }

-func withDefaultBranch(ctx context.Context, b string, event map[string]interface{}) map[string]interface{} {
+func withDefaultBranch(ctx context.Context, b string, event map[string]any) map[string]any {
 	repoI, ok := event["repository"]
 	if !ok {
-		repoI = make(map[string]interface{})
+		repoI = make(map[string]any)
 	}

-	repo, ok := repoI.(map[string]interface{})
+	repo, ok := repoI.(map[string]any)
 	if !ok {
 		common.Logger(ctx).Warnf("unable to set default branch to %v", b)
 		return event
--- a/act/model/github_context_test.go
+++ b/act/model/github_context_test.go
@ -27,19 +27,19 @@ func TestSetRef(t *testing.T) {

 	tables := []struct {
 		eventName string
-		event     map[string]interface{}
+		event     map[string]any
 		ref       string
 		refName   string
 	}{
 		{
 			eventName: "pull_request_target",
-			event:     map[string]interface{}{},
+			event:     map[string]any{},
 			ref:       "refs/heads/master",
 			refName:   "master",
 		},
 		{
 			eventName: "pull_request",
-			event: map[string]interface{}{
+			event: map[string]any{
 				"number": 1234.,
 			},
 			ref:     "refs/pull/1234/merge",
@ -47,8 +47,8 @@ func TestSetRef(t *testing.T) {
 		},
 		{
 			eventName: "deployment",
-			event: map[string]interface{}{
-				"deployment": map[string]interface{}{
+			event: map[string]any{
+				"deployment": map[string]any{
 					"ref": "refs/heads/somebranch",
 				},
 			},
@ -57,8 +57,8 @@ func TestSetRef(t *testing.T) {
 		},
 		{
 			eventName: "release",
-			event: map[string]interface{}{
-				"release": map[string]interface{}{
+			event: map[string]any{
+				"release": map[string]any{
 					"tag_name": "v1.0.0",
 				},
 			},
@ -67,7 +67,7 @@ func TestSetRef(t *testing.T) {
 		},
 		{
 			eventName: "push",
-			event: map[string]interface{}{
+			event: map[string]any{
 				"ref": "refs/heads/somebranch",
 			},
 			ref:     "refs/heads/somebranch",
@ -75,8 +75,8 @@ func TestSetRef(t *testing.T) {
 		},
 		{
 			eventName: "unknown",
-			event: map[string]interface{}{
-				"repository": map[string]interface{}{
+			event: map[string]any{
+				"repository": map[string]any{
 					"default_branch": "main",
 				},
 			},
@ -85,7 +85,7 @@ func TestSetRef(t *testing.T) {
 		},
 		{
 			eventName: "no-event",
-			event:     map[string]interface{}{},
+			event:     map[string]any{},
 			ref:       "refs/heads/master",
 			refName:   "master",
 		},
@ -114,7 +114,7 @@ func TestSetRef(t *testing.T) {

 		ghc := &GithubContext{
 			EventName: "no-default-branch",
-			Event:     map[string]interface{}{},
+			Event:     map[string]any{},
 		}

 		ghc.SetRef(t.Context(), "", "/some/dir")
@ -141,14 +141,14 @@ func TestSetSha(t *testing.T) {

 	tables := []struct {
 		eventName string
-		event     map[string]interface{}
+		event     map[string]any
 		sha       string
 	}{
 		{
 			eventName: "pull_request_target",
-			event: map[string]interface{}{
-				"pull_request": map[string]interface{}{
-					"base": map[string]interface{}{
+			event: map[string]any{
+				"pull_request": map[string]any{
+					"base": map[string]any{
 						"sha": "pr-base-sha",
 					},
 				},
@ -157,15 +157,15 @@ func TestSetSha(t *testing.T) {
 		},
 		{
 			eventName: "pull_request",
-			event: map[string]interface{}{
+			event: map[string]any{
 				"number": 1234.,
 			},
 			sha: "1234fakesha",
 		},
 		{
 			eventName: "deployment",
-			event: map[string]interface{}{
-				"deployment": map[string]interface{}{
+			event: map[string]any{
+				"deployment": map[string]any{
 					"sha": "deployment-sha",
 				},
 			},
@ -173,12 +173,12 @@ func TestSetSha(t *testing.T) {
 		},
 		{
 			eventName: "release",
-			event:     map[string]interface{}{},
+			event:     map[string]any{},
 			sha:       "1234fakesha",
 		},
 		{
 			eventName: "push",
-			event: map[string]interface{}{
+			event: map[string]any{
 				"after":   "push-sha",
 				"deleted": false,
 			},
@ -186,12 +186,12 @@ func TestSetSha(t *testing.T) {
 		},
 		{
 			eventName: "unknown",
-			event:     map[string]interface{}{},
+			event:     map[string]any{},
 			sha:       "1234fakesha",
 		},
 		{
 			eventName: "no-event",
-			event:     map[string]interface{}{},
+			event:     map[string]any{},
 			sha:       "1234fakesha",
 		},
 	}
--- a/act/model/planner.go
+++ b/act/model/planner.go
@ -8,7 +8,7 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
-	"sort"
+	"slices"

 	log "github.com/sirupsen/logrus"
 )
@ -286,11 +286,8 @@ func (wp *workflowPlanner) GetEvents() []string {
 	for _, w := range wp.workflows {
 		found := false
 		for _, e := range events {
-			for _, we := range w.On() {
-				if e == we {
-					found = true
-					break
-				}
+			if slices.Contains(w.On(), e) {
+				found = true
 			}
 			if found {
 				break
@ -303,9 +300,7 @@ func (wp *workflowPlanner) GetEvents() []string {
 	}

 	// sort the list based on depth of dependencies
-	sort.Slice(events, func(i, j int) bool {
-		return events[i] < events[j]
-	})
+	slices.Sort(events)

 	return events
 }
@ -336,7 +331,7 @@ func (s *Stage) GetJobIDs() []string {
 // Merge stages with existing stages in plan
 func (p *Plan) mergeStages(stages []*Stage) {
 	newStages := make([]*Stage, int(math.Max(float64(len(p.Stages)), float64(len(stages)))))
-	for i := 0; i < len(newStages); i++ {
+	for i := range newStages {
 		newStages[i] = new(Stage)
 		if i >= len(p.Stages) {
 			newStages[i].Runs = append(newStages[i].Runs, stages[i].Runs...)
--- a/act/model/workflow.go
+++ b/act/model/workflow.go
@ -4,9 +4,11 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"maps"
 	"path/filepath"
 	"reflect"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"

@ -47,7 +49,7 @@ func (w *Workflow) On() []string {
 		}
 		return val
 	case yaml.MappingNode:
-		var val map[string]interface{}
+		var val map[string]any
 		err := w.RawOn.Decode(&val)
 		if err != nil {
 			log.Fatal(err)
@ -61,9 +63,9 @@ func (w *Workflow) On() []string {
 	return nil
 }

-func (w *Workflow) OnEvent(event string) interface{} {
+func (w *Workflow) OnEvent(event string) any {
 	if w.RawOn.Kind == yaml.MappingNode {
-		var val map[string]interface{}
+		var val map[string]any
 		if !decodeNode(w.RawOn, &val) {
 			return nil
 		}
@ -79,10 +81,10 @@ func (w *Workflow) OnSchedule() []string {
 	}

 	switch val := schedules.(type) {
-	case []interface{}:
+	case []any:
 		allSchedules := []string{}
 		for _, v := range val {
-			for k, cron := range v.(map[string]interface{}) {
+			for k, cron := range v.(map[string]any) {
 				if k != "cron" {
 					continue
 				}
@ -137,10 +139,8 @@ func (w *Workflow) WorkflowDispatchConfig() *WorkflowDispatch {
 		if !decodeNode(w.RawOn, &val) {
 			return nil
 		}
-		for _, v := range val {
-			if v == "workflow_dispatch" {
-				return &WorkflowDispatch{}
-			}
+		if slices.Contains(val, "workflow_dispatch") {
+			return &WorkflowDispatch{}
 		}
 	case yaml.MappingNode:
 		var val map[string]yaml.Node
@ -215,7 +215,7 @@ type Job struct {
 	Defaults       Defaults                  `yaml:"defaults"`
 	Outputs        map[string]string         `yaml:"outputs"`
 	Uses           string                    `yaml:"uses"`
-	With           map[string]interface{}    `yaml:"with"`
+	With           map[string]any            `yaml:"with"`
 	RawSecrets     yaml.Node                 `yaml:"secrets"`
 	Result         string
 }
@ -393,9 +393,9 @@ func (j *Job) Environment() map[string]string {
 }

 // Matrix decodes RawMatrix YAML node
-func (j *Job) Matrix() map[string][]interface{} {
+func (j *Job) Matrix() map[string][]any {
 	if j.Strategy.RawMatrix.Kind == yaml.MappingNode {
-		var val map[string][]interface{}
+		var val map[string][]any
 		if !decodeNode(j.Strategy.RawMatrix, &val) {
 			return nil
 		}
@ -406,20 +406,20 @@ func (j *Job) Matrix() map[string][]interface{} {

 // GetMatrixes returns the matrix cross product
 // It skips includes and hard fails excludes for non-existing keys
-func (j *Job) GetMatrixes() ([]map[string]interface{}, error) {
-	matrixes := make([]map[string]interface{}, 0)
+func (j *Job) GetMatrixes() ([]map[string]any, error) {
+	matrixes := make([]map[string]any, 0)
 	if j.Strategy != nil {
 		j.Strategy.FailFast = j.Strategy.GetFailFast()
 		j.Strategy.MaxParallel = j.Strategy.GetMaxParallel()

 		if m := j.Matrix(); m != nil {
-			includes := make([]map[string]interface{}, 0)
-			extraIncludes := make([]map[string]interface{}, 0)
+			includes := make([]map[string]any, 0)
+			extraIncludes := make([]map[string]any, 0)
 			for _, v := range m["include"] {
 				switch t := v.(type) {
-				case []interface{}:
+				case []any:
 					for _, i := range t {
-						i := i.(map[string]interface{})
+						i := i.(map[string]any)
 						extraInclude := true
 						for k := range i {
 							if _, ok := m[k]; ok {
@ -432,8 +432,8 @@ func (j *Job) GetMatrixes() ([]map[string]interface{}, error) {
 							extraIncludes = append(extraIncludes, i)
 						}
 					}
-				case interface{}:
-					v := v.(map[string]interface{})
+				case any:
+					v := v.(map[string]any)
 					extraInclude := true
 					for k := range v {
 						if _, ok := m[k]; ok {
@ -449,9 +449,9 @@ func (j *Job) GetMatrixes() ([]map[string]interface{}, error) {
 			}
 			delete(m, "include")

-			excludes := make([]map[string]interface{}, 0)
+			excludes := make([]map[string]any, 0)
 			for _, e := range m["exclude"] {
-				e := e.(map[string]interface{})
+				e := e.(map[string]any)
 				for k := range e {
 					if _, ok := m[k]; ok {
 						excludes = append(excludes, e)
@ -480,9 +480,7 @@ func (j *Job) GetMatrixes() ([]map[string]interface{}, error) {
 					if commonKeysMatch2(matrix, include, m) {
 						matched = true
 						log.Debugf("Adding include values '%v' to existing entry", include)
-						for k, v := range include {
-							matrix[k] = v
-						}
+						maps.Copy(matrix, include)
 					}
 				}
 				if !matched {
@ -494,19 +492,19 @@ func (j *Job) GetMatrixes() ([]map[string]interface{}, error) {
 				matrixes = append(matrixes, include)
 			}
 			if len(matrixes) == 0 {
-				matrixes = append(matrixes, make(map[string]interface{}))
+				matrixes = append(matrixes, make(map[string]any))
 			}
 		} else {
-			matrixes = append(matrixes, make(map[string]interface{}))
+			matrixes = append(matrixes, make(map[string]any))
 		}
 	} else {
-		matrixes = append(matrixes, make(map[string]interface{}))
+		matrixes = append(matrixes, make(map[string]any))
 		log.Debugf("Empty Strategy, matrixes=%v", matrixes)
 	}
 	return matrixes, nil
 }

-func commonKeysMatch(a, b map[string]interface{}) bool {
+func commonKeysMatch(a, b map[string]any) bool {
 	for aKey, aVal := range a {
 		if bVal, ok := b[aKey]; ok && !reflect.DeepEqual(aVal, bVal) {
 			return false
@ -515,7 +513,7 @@ func commonKeysMatch(a, b map[string]interface{}) bool {
 	return true
 }

-func commonKeysMatch2(a, b map[string]interface{}, m map[string][]interface{}) bool {
+func commonKeysMatch2(a, b map[string]any, m map[string][]any) bool {
 	for aKey, aVal := range a {
 		_, useKey := m[aKey]
 		if bVal, ok := b[aKey]; useKey && ok && !reflect.DeepEqual(aVal, bVal) {
@ -778,11 +776,11 @@ func (w *Workflow) GetJobIDs() []string {
 	return ids
 }

-var OnDecodeNodeError = func(node yaml.Node, out interface{}, err error) {
+var OnDecodeNodeError = func(node yaml.Node, out any, err error) {
 	log.Errorf("Failed to decode node %v into %T: %v", node, out, err)
 }

-func decodeNode(node yaml.Node, out interface{}) bool {
+func decodeNode(node yaml.Node, out any) bool {
 	if err := node.Decode(out); err != nil {
 		if OnDecodeNodeError != nil {
 			OnDecodeNodeError(node, out, err)
@ -825,7 +823,7 @@ func (r *RawConcurrency) UnmarshalYAML(n *yaml.Node) error {
 	return n.Decode((*objectConcurrency)(r))
 }

-func (r *RawConcurrency) MarshalYAML() (interface{}, error) {
+func (r *RawConcurrency) MarshalYAML() (any, error) {
 	if r.RawExpression != "" {
 		return r.RawExpression, nil
 	}
--- a/act/model/workflow_test.go
+++ b/act/model/workflow_test.go
@ -493,24 +493,24 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 	job := wf.Jobs["strategy-only-max-parallel"]
 	matrixes, err := job.GetMatrixes()
 	assert.NoError(t, err)
-	assert.Equal(t, matrixes, []map[string]interface{}{{}})
-	assert.Equal(t, job.Matrix(), map[string][]interface{}(nil))
+	assert.Equal(t, matrixes, []map[string]any{{}})
+	assert.Equal(t, job.Matrix(), map[string][]any(nil))
 	assert.Equal(t, job.Strategy.MaxParallel, 2)
 	assert.Equal(t, job.Strategy.FailFast, true)

 	job = wf.Jobs["strategy-only-fail-fast"]
 	matrixes, err = job.GetMatrixes()
 	assert.NoError(t, err)
-	assert.Equal(t, matrixes, []map[string]interface{}{{}})
-	assert.Equal(t, job.Matrix(), map[string][]interface{}(nil))
+	assert.Equal(t, matrixes, []map[string]any{{}})
+	assert.Equal(t, job.Matrix(), map[string][]any(nil))
 	assert.Equal(t, job.Strategy.MaxParallel, 4)
 	assert.Equal(t, job.Strategy.FailFast, false)

 	job = wf.Jobs["strategy-no-matrix"]
 	matrixes, err = job.GetMatrixes()
 	assert.NoError(t, err)
-	assert.Equal(t, matrixes, []map[string]interface{}{{}})
-	assert.Equal(t, job.Matrix(), map[string][]interface{}(nil))
+	assert.Equal(t, matrixes, []map[string]any{{}})
+	assert.Equal(t, job.Matrix(), map[string][]any(nil))
 	assert.Equal(t, job.Strategy.MaxParallel, 2)
 	assert.Equal(t, job.Strategy.FailFast, false)

@ -518,7 +518,7 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 	matrixes, err = job.GetMatrixes()
 	assert.NoError(t, err)
 	assert.Equal(t, matrixes,
-		[]map[string]interface{}{
+		[]map[string]any{
 			{"datacenter": "site-c", "node-version": "14.x", "site": "staging"},
 			{"datacenter": "site-c", "node-version": "16.x", "site": "staging"},
 			{"datacenter": "site-d", "node-version": "16.x", "site": "staging"},
@ -528,15 +528,15 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 		},
 	)
 	assert.Equal(t, job.Matrix(),
-		map[string][]interface{}{
+		map[string][]any{
 			"datacenter": {"site-c", "site-d"},
 			"exclude": {
-				map[string]interface{}{"datacenter": "site-d", "node-version": "14.x", "site": "staging"},
+				map[string]any{"datacenter": "site-d", "node-version": "14.x", "site": "staging"},
 			},
 			"include": {
-				map[string]interface{}{"php-version": 5.4},
-				map[string]interface{}{"datacenter": "site-a", "node-version": "10.x", "site": "prod"},
-				map[string]interface{}{"datacenter": "site-b", "node-version": "12.x", "site": "dev"},
+				map[string]any{"php-version": 5.4},
+				map[string]any{"datacenter": "site-a", "node-version": "10.x", "site": "prod"},
+				map[string]any{"datacenter": "site-b", "node-version": "12.x", "site": "dev"},
 			},
 			"node-version": {"14.x", "16.x"},
 			"site":         {"staging"},