✨ fixes as per @spencerschrock (#3832)

Signed-off-by: Luke Harrison <[email protected]>

checks/packaging.go

@@ -44,21 +44,21 @@ func init() {
 // Packaging runs Packaging check.
 func Packaging(c *checker.CheckRequest) checker.CheckResult {
 	var rawData, rawDataGithub, rawDataGitlab checker.PackagingData
-	var err, errG, errGL error
+	var err, errGithub, errGitlab error
 
 	switch v := c.RepoClient.(type) {
-	case *localdir.LocalDirClient:
+	case *localdir.Client:
 		// Performing both packaging checks since we dont know when local
-		rawDataGithub, errG = github.Packaging(c)
-		rawDataGitlab, errGL = gitlab.Packaging(c)
+		rawDataGithub, errGithub = github.Packaging(c)
+		rawDataGitlab, errGitlab = gitlab.Packaging(c)
 		// Appending results of checks
 		rawData.Packages = append(rawData.Packages, rawDataGithub.Packages...)
 		rawData.Packages = append(rawData.Packages, rawDataGitlab.Packages...)
 		// checking for errors
-		if errG != nil {
-			err = errG
-		} else if errGL != nil {
-			err = errGL
+		if errGithub != nil {
+			err = errGithub
+		} else if errGitlab != nil {
+			err = errGitlab
 		}
 	case *githubrepo.Client:
 		rawData, err = github.Packaging(c)

checks/raw/fuzzing.go

@@ -16,7 +16,6 @@ package raw
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"regexp"
 	"strings"
@@ -209,10 +208,6 @@ func Fuzzing(c *checker.CheckRequest) (checker.FuzzingData, error) {
 
 	langs, err := c.RepoClient.ListProgrammingLanguages()
 	if err != nil {
-		// ListProgrammingLanguages is unsupported by local client so just return
-		if errors.Is(err, clients.ErrUnsupportedFeature) {
-			return checker.FuzzingData{Fuzzers: detectedFuzzers}, nil
-		}
 		return checker.FuzzingData{}, fmt.Errorf("cannot get langs of repo: %w", err)
 	}
 	prominentLangs := getProminentLanguages(langs)
@@ -343,6 +338,8 @@ func getProminentLanguages(langs []clients.Language) []clients.LanguageName {
 	numLangs := len(langs)
 	if numLangs == 0 {
 		return nil
+	} else if len(langs) == 1 && langs[0].Name == clients.All{
+		return getAllLanguages()
 	}
 	totalLoC := 0
 	// Use a map to record languages and their lines of code to drop potential duplicates.
@@ -366,6 +363,14 @@ func getProminentLanguages(langs []clients.Language) []clients.LanguageName {
 	return ret
 }
 
+func getAllLanguages() []clients.LanguageName {
+	allLanguages := make([]clients.LanguageName, 0, len(languageFuzzSpecs))
+	for l := range languageFuzzSpecs {
+		allLanguages = append(allLanguages, l)
+	}
+	return allLanguages
+}
+
 func propertyBasedDescription(language string) *string {
 	s := fmt.Sprintf("Property-based testing in %s generates test instances randomly or exhaustively "+
 		"and test that specific properties are satisfied.", language)

checks/raw/github/packaging.go

@@ -75,7 +75,7 @@ func Packaging(c *checker.CheckRequest) (checker.PackagingData, error) {
 
 		runs, err := c.RepoClient.ListSuccessfulWorkflowRuns(filepath.Base(fp))
 		if err != nil {
-			// appending empty run for localdir client
+			// assume the workflow will have run for localdir client
 			if errors.Is(err, clients.ErrUnsupportedFeature) {
 				runs = append(runs, clients.WorkflowRun{})
 			} else {

checks/raw/security_policy.go

@@ -74,9 +74,7 @@ func SecurityPolicy(c *checker.CheckRequest) (checker.SecurityPolicyData, error)
 	case errors.Is(err, sce.ErrRepoUnreachable), errors.Is(err, clients.ErrUnsupportedFeature):
 		break
 	default:
-		if !errors.Is(err, clients.ErrUnsupportedFeature) {
-			return checker.SecurityPolicyData{}, err
-		}
+		return checker.SecurityPolicyData{}, err
 	}
 
 	// Return raw results.

clients/localdir/client.go

@@ -34,12 +34,12 @@ import (
 )
 
 var (
-	_                clients.RepoClient = &LocalDirClient{}
+	_                clients.RepoClient = &Client{}
 	errInputRepoType                    = errors.New("input repo should be of type repoLocal")
 )
 
 //nolint:govet
-type LocalDirClient struct {
+type Client struct {
 	logger      *log.Logger
 	ctx         context.Context
 	path        string
@@ -50,7 +50,7 @@ type LocalDirClient struct {
 }
 
 // InitRepo sets up the local repo.
-func (client *LocalDirClient) InitRepo(inputRepo clients.Repo, commitSHA string, commitDepth int) error {
+func (client *Client) InitRepo(inputRepo clients.Repo, commitSHA string, commitDepth int) error {
 	localRepo, ok := inputRepo.(*Repo)
 	if !ok {
 		return fmt.Errorf("%w: %v", errInputRepoType, inputRepo)
@@ -66,12 +66,12 @@ func (client *LocalDirClient) InitRepo(inputRepo clients.Repo, commitSHA string,
 }
 
 // URI implements RepoClient.URI.
-func (client *LocalDirClient) URI() string {
+func (client *Client) URI() string {
 	return fmt.Sprintf("file://%s", client.path)
 }
 
 // IsArchived implements RepoClient.IsArchived.
-func (client *LocalDirClient) IsArchived() (bool, error) {
+func (client *Client) IsArchived() (bool, error) {
 	return false, fmt.Errorf("IsArchived: %w", clients.ErrUnsupportedFeature)
 }
 
@@ -148,7 +148,7 @@ func applyPredicate(
 }
 
 // LocalPath implements RepoClient.LocalPath.
-func (client *LocalDirClient) LocalPath() (string, error) {
+func (client *Client) LocalPath() (string, error) {
 	clientPath, err := filepath.Abs(client.path)
 	if err != nil {
 		return "", fmt.Errorf("error during filepath.Abs: %w", err)
@@ -157,7 +157,7 @@ func (client *LocalDirClient) LocalPath() (string, error) {
 }
 
 // ListFiles implements RepoClient.ListFiles.
-func (client *LocalDirClient) ListFiles(predicate func(string) (bool, error)) ([]string, error) {
+func (client *Client) ListFiles(predicate func(string) (bool, error)) ([]string, error) {
 	client.once.Do(func() {
 		client.files, client.errFiles = listFiles(client.path)
 	})
@@ -175,102 +175,103 @@ func getFile(clientpath, filename string) (*os.File, error) {
 }
 
 // GetFileReader implements RepoClient.GetFileReader.
-func (client *LocalDirClient) GetFileReader(filename string) (io.ReadCloser, error) {
+func (client *Client) GetFileReader(filename string) (io.ReadCloser, error) {
 	return getFile(client.path, filename)
 }
 
 // GetBranch implements RepoClient.GetBranch.
-func (client *LocalDirClient) GetBranch(branch string) (*clients.BranchRef, error) {
+func (client *Client) GetBranch(branch string) (*clients.BranchRef, error) {
 	return nil, fmt.Errorf("ListBranches: %w", clients.ErrUnsupportedFeature)
 }
 
 // GetDefaultBranch implements RepoClient.GetDefaultBranch.
-func (client *LocalDirClient) GetDefaultBranch() (*clients.BranchRef, error) {
+func (client *Client) GetDefaultBranch() (*clients.BranchRef, error) {
 	return nil, fmt.Errorf("GetDefaultBranch: %w", clients.ErrUnsupportedFeature)
 }
 
 // GetDefaultBranchName implements RepoClient.GetDefaultBranchName.
-func (client *LocalDirClient) GetDefaultBranchName() (string, error) {
+func (client *Client) GetDefaultBranchName() (string, error) {
 	return "", fmt.Errorf("GetDefaultBranchName: %w", clients.ErrUnsupportedFeature)
 }
 
 // ListCommits implements RepoClient.ListCommits.
-func (client *LocalDirClient) ListCommits() ([]clients.Commit, error) {
+func (client *Client) ListCommits() ([]clients.Commit, error) {
 	return nil, fmt.Errorf("ListCommits: %w", clients.ErrUnsupportedFeature)
 }
 
 // ListIssues implements RepoClient.ListIssues.
-func (client *LocalDirClient) ListIssues() ([]clients.Issue, error) {
+func (client *Client) ListIssues() ([]clients.Issue, error) {
 	return nil, fmt.Errorf("ListIssues: %w", clients.ErrUnsupportedFeature)
 }
 
 // ListReleases implements RepoClient.ListReleases.
-func (client *LocalDirClient) ListReleases() ([]clients.Release, error) {
+func (client *Client) ListReleases() ([]clients.Release, error) {
 	return nil, fmt.Errorf("ListReleases: %w", clients.ErrUnsupportedFeature)
 }
 
 // ListContributors implements RepoClient.ListContributors.
-func (client *LocalDirClient) ListContributors() ([]clients.User, error) {
+func (client *Client) ListContributors() ([]clients.User, error) {
 	return nil, fmt.Errorf("ListContributors: %w", clients.ErrUnsupportedFeature)
 }
 
 // ListSuccessfulWorkflowRuns implements RepoClient.WorkflowRunsByFilename.
-func (client *LocalDirClient) ListSuccessfulWorkflowRuns(filename string) ([]clients.WorkflowRun, error) {
+func (client *Client) ListSuccessfulWorkflowRuns(filename string) ([]clients.WorkflowRun, error) {
 	return nil, fmt.Errorf("ListSuccessfulWorkflowRuns: %w", clients.ErrUnsupportedFeature)
 }
 
 // ListCheckRunsForRef implements RepoClient.ListCheckRunsForRef.
-func (client *LocalDirClient) ListCheckRunsForRef(ref string) ([]clients.CheckRun, error) {
+func (client *Client) ListCheckRunsForRef(ref string) ([]clients.CheckRun, error) {
 	return nil, fmt.Errorf("ListCheckRunsForRef: %w", clients.ErrUnsupportedFeature)
 }
 
 // ListStatuses implements RepoClient.ListStatuses.
-func (client *LocalDirClient) ListStatuses(ref string) ([]clients.Status, error) {
+func (client *Client) ListStatuses(ref string) ([]clients.Status, error) {
 	return nil, fmt.Errorf("ListStatuses: %w", clients.ErrUnsupportedFeature)
 }
 
 // ListWebhooks implements RepoClient.ListWebhooks.
-func (client *LocalDirClient) ListWebhooks() ([]clients.Webhook, error) {
+func (client *Client) ListWebhooks() ([]clients.Webhook, error) {
 	return nil, fmt.Errorf("ListWebhooks: %w", clients.ErrUnsupportedFeature)
 }
 
 // Search implements RepoClient.Search.
-func (client *LocalDirClient) Search(request clients.SearchRequest) (clients.SearchResponse, error) {
+func (client *Client) Search(request clients.SearchRequest) (clients.SearchResponse, error) {
 	return clients.SearchResponse{}, fmt.Errorf("Search: %w", clients.ErrUnsupportedFeature)
 }
 
 // SearchCommits implements RepoClient.SearchCommits.
-func (client *LocalDirClient) SearchCommits(request clients.SearchCommitsOptions) ([]clients.Commit, error) {
+func (client *Client) SearchCommits(request clients.SearchCommitsOptions) ([]clients.Commit, error) {
 	return nil, fmt.Errorf("Search: %w", clients.ErrUnsupportedFeature)
 }
 
-func (client *LocalDirClient) Close() error {
+func (client *Client) Close() error {
 	return nil
 }
 
 // ListProgrammingLanguages implements RepoClient.ListProgrammingLanguages.
 // TODO: add ListProgrammingLanguages support for local directories.
-func (client *LocalDirClient) ListProgrammingLanguages() ([]clients.Language, error) {
-	return nil, fmt.Errorf("ListProgrammingLanguages: %w", clients.ErrUnsupportedFeature)
+func (client *Client) ListProgrammingLanguages() ([]clients.Language, error) {
+	// for now just return all programming languages
+	return []clients.Language{{Name: clients.All, NumLines: 1}}, nil
 }
 
 // ListLicenses implements RepoClient.ListLicenses.
 // TODO: add ListLicenses support for local directories.
-func (client *LocalDirClient) ListLicenses() ([]clients.License, error) {
+func (client *Client) ListLicenses() ([]clients.License, error) {
 	return nil, fmt.Errorf("ListLicenses: %w", clients.ErrUnsupportedFeature)
 }
 
-func (client *LocalDirClient) GetCreatedAt() (time.Time, error) {
+func (client *Client) GetCreatedAt() (time.Time, error) {
 	return time.Time{}, fmt.Errorf("GetCreatedAt: %w", clients.ErrUnsupportedFeature)
 }
 
-func (client *LocalDirClient) GetOrgRepoClient(ctx context.Context) (clients.RepoClient, error) {
+func (client *Client) GetOrgRepoClient(ctx context.Context) (clients.RepoClient, error) {
 	return nil, fmt.Errorf("GetOrgRepoClient: %w", clients.ErrUnsupportedFeature)
 }
 
 // CreateLocalDirClient returns a client which implements RepoClient interface.
 func CreateLocalDirClient(ctx context.Context, logger *log.Logger) clients.RepoClient {
-	return &LocalDirClient{
+	return &Client{
 		ctx:    ctx,
 		logger: logger,
 	}