Remove unused parameters from service-specific repository functions

Each get*Repositories function was receiving all 8 parameters from
getRepositories, even though most were unused. For example,
getGitlabRepositories received githubRepoType, githubNamespaceWhitelist,
ignoreFork, and forgejoRepoType — none of which it uses.

Now each function only accepts what it needs and uses typed client
pointers instead of interface{}, with type assertions moved to the
getRepositories dispatcher.

Author: Rachel Dowavic

bitbucket.go

@@ -8,27 +8,24 @@ import (
 )
 
 func getBitbucketRepositories(
-	client interface{},
-	service string, githubRepoType string, githubNamespaceWhitelist []string,
-	gitlabProjectVisibility string, gitlabProjectMembershipType string,
-	ignoreFork bool, forgejoRepoType string,
+	client *bitbucket.Client,
 ) ([]*Repository, error) {
 
 	if client == nil {
-		log.Fatalf("Couldn't acquire a client to talk to %s", service)
+		log.Fatal("Couldn't acquire a client to talk to bitbucket")
 	}
 
 	var repositories []*Repository
 
-	resp, err := client.(*bitbucket.Client).Workspaces.List()
+	resp, err := client.Workspaces.List()
 	if err != nil {
 		return nil, err
 	}
 
 	for _, workspace := range resp.Workspaces {
 		options := &bitbucket.RepositoriesOptions{Owner: workspace.Slug}
 
-		resp, err := client.(*bitbucket.Client).Repositories.ListForAccount(options)
+		resp, err := client.Repositories.ListForAccount(options)
 		if err != nil {
 			return nil, err
 		}

forgejo.go

@@ -8,45 +8,42 @@ import (
 )
 
 func getForgejoRepositories(
-	client interface{},
-	service string, githubRepoType string, githubNamespaceWhitelist []string,
-	gitlabProjectVisibility string, gitlabProjectMembershipType string,
-	ignoreFork bool, forgejoRepoType string,
+	client *forgejo.Client,
+	forgejoRepoType string,
 ) ([]*Repository, error) {
+
 	if client == nil {
-		log.Fatalf("Couldn't acquire a client to talk to %s", service)
+		log.Fatal("Couldn't acquire a client to talk to forgejo")
 	}
 
-	forgejoClient := client.(*forgejo.Client)
-
 	switch forgejoRepoType {
 	case "starred":
-		user, _, err := forgejoClient.GetMyUserInfo()
+		user, _, err := client.GetMyUserInfo()
 		if err != nil {
-			log.Fatalf("Error fetching user info from %s: %v", service, err)
+			log.Fatalf("Error fetching user info from forgejo: %v", err)
 		}
 
 		log.Printf("Found user %s with ID %d", user.UserName, user.ID)
 
 		repos, err := paginateForgejoRepositories(func(page int) ([]*forgejo.Repository, *forgejo.Response, error) {
-			return forgejoClient.SearchRepos(forgejo.SearchRepoOptions{
+			return client.SearchRepos(forgejo.SearchRepoOptions{
 				ListOptions:     forgejo.ListOptions{Page: page},
 				StarredByUserID: user.ID,
 			})
 		})
 		if err != nil {
-			return nil, fmt.Errorf("fetching starred repositories from %s: %v", service, err)
+			return nil, fmt.Errorf("fetching starred repositories from forgejo: %v", err)
 		}
 
 		return repos, nil
 	case "user", "":
 		repos, err := paginateForgejoRepositories(func(page int) ([]*forgejo.Repository, *forgejo.Response, error) {
-			return forgejoClient.ListMyRepos(forgejo.ListReposOptions{
+			return client.ListMyRepos(forgejo.ListReposOptions{
 				ListOptions: forgejo.ListOptions{Page: page},
 			})
 		})
 		if err != nil {
-			return nil, fmt.Errorf("fetching user repositories from %s: %v", service, err)
+			return nil, fmt.Errorf("fetching user repositories from forgejo: %v", err)
 		}
 
 		return repos, nil

github.go

@@ -9,28 +9,27 @@ import (
 )
 
 func getGithubRepositories(
-	client interface{},
-	service string, githubRepoType string, githubNamespaceWhitelist []string,
-	gitlabProjectVisibility string, gitlabProjectMembershipType string,
-	ignoreFork bool, forgejoRepoType string,
+	client *github.Client,
+	githubRepoType string, githubNamespaceWhitelist []string,
+	ignoreFork bool,
 ) ([]*Repository, error) {
 
 	if client == nil {
-		log.Fatalf("Couldn't acquire a client to talk to %s", service)
+		log.Fatal("Couldn't acquire a client to talk to github")
 	}
 
 	var repositories []*Repository
 
 	ctx := context.Background()
 
 	if githubRepoType == "starred" {
-		return getGithubStarredRepositories(ctx, client.(*github.Client), ignoreFork)
+		return getGithubStarredRepositories(ctx, client, ignoreFork)
 	}
 
 	options := github.RepositoryListOptions{Type: githubRepoType}
 
 	for {
-		repos, resp, err := client.(*github.Client).Repositories.List(ctx, "", &options)
+		repos, resp, err := client.Repositories.List(ctx, "", &options)
 		if err != nil {
 			return nil, err
 		}

gitlab.go

@@ -8,14 +8,12 @@ import (
 )
 
 func getGitlabRepositories(
-	client interface{},
-	service string, githubRepoType string, githubNamespaceWhitelist []string,
+	client *gitlab.Client,
 	gitlabProjectVisibility string, gitlabProjectMembershipType string,
-	ignoreFork bool, forgejoRepoType string,
 ) ([]*Repository, error) {
 
 	if client == nil {
-		log.Fatalf("Couldn't acquire a client to talk to %s", service)
+		log.Fatal("Couldn't acquire a client to talk to gitlab")
 	}
 
 	var repositories []*Repository
@@ -53,7 +51,7 @@ func getGitlabRepositories(
 	}
 
 	for {
-		repos, resp, err := client.(*gitlab.Client).Projects.ListProjects(&gitlabListOptions)
+		repos, resp, err := client.Projects.ListProjects(&gitlabListOptions)
 		if err != nil {
 			return nil, err
 		}

repositories.go

@@ -2,6 +2,11 @@ package main
 
 import (
 	"net/http"
+
+	forgejo "codeberg.org/mvdkleijn/forgejo-sdk/forgejo/v2"
+	"github.com/google/go-github/v34/github"
+	bitbucket "github.com/ktrysmt/go-bitbucket"
+	gitlab "github.com/xanzy/go-gitlab"
 )
 
 // Response is derived from the following sources:
@@ -43,47 +48,24 @@ func getRepositories(
 	switch service {
 	case "github":
 		repositories, err = getGithubRepositories(
-			client,
-			service,
+			client.(*github.Client),
 			githubRepoType,
 			githubNamespaceWhitelist,
-			gitlabProjectVisibility,
-			gitlabProjectMembershipType,
 			ignoreFork,
-			forgejoRepoType,
 		)
-
 	case "gitlab":
 		repositories, err = getGitlabRepositories(
-			client,
-			service,
-			githubRepoType,
-			githubNamespaceWhitelist,
+			client.(*gitlab.Client),
 			gitlabProjectVisibility,
 			gitlabProjectMembershipType,
-			ignoreFork,
-			forgejoRepoType,
 		)
 	case "bitbucket":
 		repositories, err = getBitbucketRepositories(
-			client,
-			service,
-			githubRepoType,
-			githubNamespaceWhitelist,
-			gitlabProjectVisibility,
-			gitlabProjectMembershipType,
-			ignoreFork,
-			forgejoRepoType,
+			client.(*bitbucket.Client),
 		)
 	case "forgejo":
 		repositories, err = getForgejoRepositories(
-			client,
-			service,
-			githubRepoType,
-			githubNamespaceWhitelist,
-			gitlabProjectVisibility,
-			gitlabProjectMembershipType,
-			ignoreFork,
+			client.(*forgejo.Client),
 			forgejoRepoType,
 		)
 	}