add copyIndexers

Author: davidnewhall

orbit/copier.go

@@ -20,7 +20,7 @@ import (
 var ErrNotPtr = errors.New("must provide a pointer to a non-nil value")
 
 // Copy is an easy way to copy one data structure to another.
-func Copy(src interface{}, dst interface{}) error {
+func Copy(src, dst any) error {
 	if src == nil || reflect.TypeOf(src).Kind() != reflect.Ptr {
 		return fmt.Errorf("copy source: %w", ErrNotPtr)
 	} else if dst == nil || reflect.TypeOf(dst).Kind() != reflect.Ptr {
@@ -41,18 +41,45 @@ func Copy(src interface{}, dst interface{}) error {
 
 // IndexerInput represents all possible Indexer inputs.
 type IndexerInput interface {
-	*lidarr.IndexerInput | *prowlarr.IndexerInput | *radarr.IndexerInput |
-		*readarr.IndexerInput | *sonarr.IndexerInput
+	lidarr.IndexerInput | prowlarr.IndexerInput | radarr.IndexerInput |
+		readarr.IndexerInput | sonarr.IndexerInput
 }
 
 // IndexerOutput represents all possible Indexer outputs.
 type IndexerOutput interface {
-	*lidarr.IndexerOutput | *prowlarr.IndexerOutput | *radarr.IndexerOutput |
-		*readarr.IndexerOutput | *sonarr.IndexerOutput
+	lidarr.IndexerOutput | prowlarr.IndexerOutput | radarr.IndexerOutput |
+		readarr.IndexerOutput | sonarr.IndexerOutput
+}
+
+// CopyIndexers copies a slice of indexers from one type to another, so you may copy them among instances.
+// The destination must be a pointer to a slice, so it can be updated in place.
+// The destination slice may be empty but not nil.
+func CopyIndexers[S IndexerInput | IndexerOutput, D IndexerInput](src []*S, dst *[]*D, keepTags bool) ([]*D, error) {
+	if dst == nil {
+		return nil, ErrNotPtr
+	}
+
+	var err error
+
+	for idx, indexer := range src {
+		if len(*dst)-1 >= idx { // The destination slice location exists, so update it in place.
+			_, err = CopyIndexer(indexer, (*dst)[idx], keepTags)
+		} else { // The destination slice is shorter than the source, so append to it.
+			newIndexer := new(D)
+			newIndexer, err = CopyIndexer(indexer, newIndexer, keepTags)
+			*dst = append(*dst, newIndexer) // This happens before checking the error.
+		}
+
+		if err != nil {
+			break
+		}
+	}
+
+	return *dst, err
 }
 
 // CopyIndexer copies an indexer from one type to another, so you may copy them among instances.
-func CopyIndexer[S IndexerInput | IndexerOutput, D IndexerInput](src S, dst D, keepTags bool) (D, error) {
+func CopyIndexer[S IndexerInput | IndexerOutput, D IndexerInput](src *S, dst *D, keepTags bool) (*D, error) {
 	if err := Copy(src, dst); err != nil {
 		return dst, err
 	}

orbit/copier_test.go

@@ -11,33 +11,66 @@ import (
 	"golift.io/starr/sonarr"
 )
 
-func TestCopyIndexer(t *testing.T) {
+func TestCopyIndexers(t *testing.T) {
 	t.Parallel()
+	src1, dst1 := copyData(t)
+	src2, dst2 := copyData(t)
+	src3, dst3 := copyData(t)
+	src4, _ := copyData(t)
+	src5, _ := copyData(t)
+	// We test for these.
+	src1.Priority = 1
+	src2.Priority = 2
+	src3.Priority = 3
+	src4.Priority = 4
+	src5.Priority = 5
+	// Make two lists.
+	srcs := append([]*prowlarr.IndexerOutput{}, src1, src2, src3, src4, src5)
+	dsts := append([]*sonarr.IndexerInput{}, dst1, dst2, dst3) // short by 2.
+	// Copy the lists.
+	dsts2, err := orbit.CopyIndexers(srcs, &dsts, false)
+	require.NoError(t, err)
+	// Make sure both outputs have a length matching the input.
+	assert.Len(t, dsts, len(srcs))
+	assert.Len(t, dsts2, len(srcs))
+	// Test that values got copied.
+	for idx, src := range srcs {
+		assert.Equal(t, src.Priority, dsts[idx].Priority)
+	}
+}
+
+func copyData(t *testing.T) (*prowlarr.IndexerOutput, *sonarr.IndexerInput) {
+	t.Helper()
 
-	src := &prowlarr.IndexerOutput{
-		ID:             2,
-		Priority:       3,
-		Name:           "yes",
-		Protocol:       "usenet",
-		Implementation: "core",
-		ConfigContract: "hancock",
-		Tags:           []int{1, 2, 5},
-		Fields: []*starr.FieldOutput{
-			{Name: "One", Value: "one"},
-			{Name: "Two", Value: 2.0},
-			{Name: "Three", Value: uint(3)},
-			{Name: "Five", Value: 5},
+	return &prowlarr.IndexerOutput{
+			ID:             2,
+			Priority:       3,
+			Name:           "yes",
+			Protocol:       "usenet",
+			Implementation: "core",
+			ConfigContract: "hancock",
+			Tags:           []int{1, 2, 5},
+			Fields: []*starr.FieldOutput{
+				{Name: "One", Value: "one"},
+				{Name: "Two", Value: 2.0},
+				{Name: "Three", Value: uint(3)},
+				{Name: "Five", Value: 5},
+			},
 		},
-	}
-	// This is a real example of how you'd copy an indexer from Prowlarr to Sonarr.
-	dst := &sonarr.IndexerInput{
-		// These are not part of the used input, so set them before copying.
-		EnableAutomaticSearch:   true,
-		EnableInteractiveSearch: true,
-		EnableRss:               true,
-		DownloadClientID:        15,
-	}
+		// This is a real example of how you'd copy an indexer from Prowlarr to Sonarr.
+		&sonarr.IndexerInput{
+			// These are not part of the used input, so set them before copying.
+			EnableAutomaticSearch:   true,
+			EnableInteractiveSearch: true,
+			EnableRss:               true,
+			DownloadClientID:        15,
+		}
+}
+
+func TestCopyIndexer(t *testing.T) {
+	t.Parallel()
 
+	src, dst := copyData(t)
 	// Verify everything copies over.
 	_, err := orbit.CopyIndexer(src, dst, true)
 	require.NoError(t, err)