refactor: core/to pkg

cli/families/rootkits/chkrootkit/utils/parser.go

@@ -204,5 +204,5 @@ func processAliensToRootkits(aliensResult string) ([]Rootkit, error) {
 		return nil, fmt.Errorf("failed to get output: %w", err)
 	}
 
-	return to.ValuesSlice(rootkits), nil
+	return to.Values(rootkits), nil
 }

cli/presenter/apimodel.go

@@ -178,10 +178,10 @@ func ConvertMalwareResultToMalwareAndMetadata(malwareResults *malware.MergedResu
 	for _, m := range malwareResults.DetectedMalware {
 		mal := m // Prevent loop variable pointer export
 		malwareList = append(malwareList, apitypes.Malware{
-			MalwareName: to.OmitEmpty(mal.MalwareName),
-			MalwareType: to.OmitEmpty(mal.MalwareType),
-			Path:        to.OmitEmpty(mal.Path),
-			RuleName:    to.OmitEmpty(mal.RuleName),
+			MalwareName: to.PtrOrNil(mal.MalwareName),
+			MalwareType: to.PtrOrNil(mal.MalwareType),
+			Path:        to.PtrOrNil(mal.Path),
+			RuleName:    to.PtrOrNil(mal.RuleName),
 		})
 	}
 

core/to/to.go

@@ -19,7 +19,8 @@ func Ptr[T any](value T) *T {
 	return &value
 }
 
-func OmitEmpty[T comparable](t T) *T {
+// PtrOrNil returns a pointer to t if it has a non-empty value otherwise nil.
+func PtrOrNil[T comparable](t T) *T {
 	var empty T
 	if t == empty {
 		return nil
@@ -49,7 +50,8 @@ func Keys[K comparable, V any](m map[K]V) []K {
 	return s
 }
 
-func ValuesSlice[K comparable, V any](m map[K]V) []V {
+// Values returns a slice of values from m map.
+func Values[K comparable, V any](m map[K]V) []V {
 	s := make([]V, 0, len(m))
 	for _, v := range m {
 		s = append(s, v)

core/to/to_test.go

@@ -105,7 +105,7 @@ func Test_ValuesSlice(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := ValuesSlice(tt.args.m)
+			got := Values(tt.args.m)
 			if got != nil {
 				sort.Slice(got, func(i, j int) bool {
 					switch got[0].(type) {

uibackend/server/dashboard_findings_impact.go

@@ -534,7 +534,7 @@ func processFindings(findings []apitypes.Finding, findingAssetMap map[findingAss
 
 // getSortedFindingInfoCountSlice will return a slice of findingInfoCount desc sorted by AssetCount.
 func getSortedFindingInfoCountSlice(findingAssetMapCount map[string]findingInfoCount) []findingInfoCount {
-	findingInfoCountSlice := to.ValuesSlice(findingAssetMapCount)
+	findingInfoCountSlice := to.Values(findingAssetMapCount)
 	sort.Slice(findingInfoCountSlice, func(i, j int) bool {
 		return findingInfoCountSlice[i].AssetCount > findingInfoCountSlice[j].AssetCount
 	})