removes deadcode

Author: timbastin

accesscontrol/members.go

@@ -15,71 +15,3 @@
 
 package accesscontrol
 
-import (
-	"maps"
-
-	"github.com/l3montree-dev/devguard/dtos"
-	"github.com/l3montree-dev/devguard/shared"
-	"github.com/l3montree-dev/devguard/utils"
-	"github.com/ory/client-go"
-)
-
-// FetchMembersOfOrganization retrieves all members of an organization including their roles
-// from both the RBAC system and third-party integrations
-func FetchMembersOfOrganization(ctx shared.Context) ([]dtos.UserDTO, error) {
-	// get all members from the organization
-	organization := shared.GetOrg(ctx)
-	accessControl := shared.GetRBAC(ctx)
-
-	members, err := accessControl.GetAllMembersOfOrganization()
-
-	if err != nil {
-		return nil, err
-	}
-
-	users := make([]dtos.UserDTO, 0, len(members))
-	if len(members) > 0 {
-		// get the auth admin client from the context
-		authAdminClient := shared.GetAuthAdminClient(ctx)
-		// fetch the users from the auth service
-		m, err := authAdminClient.ListUser(client.IdentityAPIListIdentitiesRequest{}.Ids(members))
-		if err != nil {
-			return nil, err
-		}
-
-		// get the roles for the members
-		errGroup := utils.ErrGroup[map[string]shared.Role](10)
-		for _, member := range m {
-			errGroup.Go(func() (map[string]shared.Role, error) {
-				role, err := accessControl.GetDomainRole(member.Id)
-				if err != nil {
-					return map[string]shared.Role{member.Id: shared.RoleUnknown}, nil
-				}
-				return map[string]shared.Role{member.Id: role}, nil
-			})
-		}
-
-		roles, err := errGroup.WaitAndCollect()
-		if err != nil {
-			return nil, err
-		}
-
-		roleMap := utils.Reduce(roles, func(acc map[string]shared.Role, r map[string]shared.Role) map[string]shared.Role {
-			maps.Copy(acc, r)
-			return acc
-		}, make(map[string]shared.Role))
-
-		for _, member := range m {
-			users = append(users, dtos.UserDTO{
-				ID:   member.Id,
-				Name: shared.IdentityName(member.Traits),
-				Role: string(roleMap[member.Id]),
-			})
-		}
-	}
-
-	// fetch all members from third party integrations
-	thirdPartyIntegrations := shared.GetThirdPartyIntegration(ctx)
-	users = append(users, thirdPartyIntegrations.GetUsers(organization)...)
-	return users, nil
-}

cmd/devguard-cli/commands/trustscore.go

@@ -4,17 +4,13 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
-	"math"
-	"strings"
 
 	"github.com/google/uuid"
 	"github.com/l3montree-dev/devguard/database"
 	"github.com/l3montree-dev/devguard/database/repositories"
 	"github.com/l3montree-dev/devguard/shared"
 	"github.com/spf13/cobra"
 	"go.uber.org/fx"
-
-	"github.com/l3montree-dev/devguard/database/models"
 )
 
 type CrowdResult struct {
@@ -164,112 +160,3 @@ func assignTrustScore(ctx context.Context, entityType string, entityID string, s
 
 	return assignErr
 }
-
-func CalculateConfidenceScoreForPath(ctx context.Context, rules []models.VEXRule, markedAsAffected []models.VEXRule, trustedEntities []models.TrustedEntity) ([]CrowdResult, error) {
-	var result []CrowdResult
-	var confidenceValues = make(map[string]float64)
-	var assignErr error
-	app := fx.New(
-		fx.NopLogger,
-		fx.Supply(database.GetPoolConfigFromEnv()),
-		database.Module,
-		repositories.Module,
-		fx.Invoke(func(
-			orgRepo shared.OrganizationRepository,
-			projectRepo shared.ProjectRepository,
-			assetRepo shared.AssetRepository,
-		) error {
-
-			for _, rule := range rules {
-				rulaPath := strings.Join(rule.PathPattern, "->")
-
-				asset, err := assetRepo.Read(ctx, nil, rule.AssetID)
-				if err != nil {
-					slog.Error("failed to read asset for VEX rule", "assetID", rule.AssetID, "error", err)
-					continue
-				}
-				project, err := projectRepo.Read(ctx, nil, asset.ProjectID)
-				if err != nil {
-					slog.Error("failed to read project for asset", "projectID", asset.ProjectID, "error", err)
-					continue
-				}
-				org, err := orgRepo.Read(ctx, nil, project.OrganizationID)
-				if err != nil {
-					slog.Error("failed to read organization for project", "organizationID", project.OrganizationID, "error", err)
-					continue
-				}
-				organizationTrustscore := 0.0
-				projectTrustscore := 0.0
-
-				for _, te := range trustedEntities {
-					if te.OrganizationID != nil && *te.OrganizationID == org.ID {
-						organizationTrustscore = te.TrustScore
-					} else if te.ProjectID != nil && *te.ProjectID == project.ID {
-						projectTrustscore = te.TrustScore
-					}
-				}
-
-				ruleConfidence := 1.0 * math.Max(projectTrustscore, organizationTrustscore)
-				confidenceValues[rulaPath] += ruleConfidence
-			}
-
-			for _, rule := range markedAsAffected {
-				rulaPath := strings.Join(rule.PathPattern, "")
-
-				asset, err := assetRepo.Read(ctx, nil, rule.AssetID)
-				if err != nil {
-					slog.Error("failed to read asset for VEX rule", "assetID", rule.AssetID, "error", err)
-					continue
-				}
-				project, err := projectRepo.Read(ctx, nil, asset.ProjectID)
-				if err != nil {
-					slog.Error("failed to read project for asset", "projectID", asset.ProjectID, "error", err)
-					continue
-				}
-				org, err := orgRepo.Read(ctx, nil, project.OrganizationID)
-				if err != nil {
-					slog.Error("failed to read organization for project", "organizationID", project.OrganizationID, "error", err)
-					continue
-				}
-				organizationTrustscore := 0.0
-				projectTrustscore := 0.0
-
-				for _, te := range trustedEntities {
-					if te.OrganizationID != nil && *te.OrganizationID == org.ID {
-						organizationTrustscore = te.TrustScore
-					} else if te.ProjectID != nil && *te.ProjectID == project.ID {
-						projectTrustscore = te.TrustScore
-					}
-				}
-
-				ruleConfidence := 1.0 * math.Max(projectTrustscore, organizationTrustscore)
-				confidenceValues[rulaPath] += ruleConfidence
-			}
-
-			totalConfidence := 0.0
-			for _, conf := range confidenceValues {
-				totalConfidence += conf
-			}
-			if totalConfidence == 0 {
-				return nil
-			}
-			for key, value := range confidenceValues {
-				result = append(result, CrowdResult{
-					ConfidenceScore: value / totalConfidence,
-					Rule:            key,
-				})
-			}
-			return nil
-		}),
-	)
-
-	if err := app.Start(context.Background()); err != nil {
-		assignErr = err
-	}
-
-	if err := app.Stop(context.Background()); err != nil {
-		assignErr = err
-	}
-
-	return result, assignErr
-}

cmd/devguard-scanner/commands/clean.go

@@ -1,7 +1,6 @@
 package commands
 
 import (
-	"context"
 	"log/slog"
 
 	"github.com/google/go-containerregistry/pkg/authn"
@@ -12,10 +11,6 @@ import (
 	"github.com/spf13/cobra"
 )
 
-func cleanImage(ctx context.Context, regOpts cosignoptions.RegistryOptions, cleanType cosignoptions.CleanType, imageRef string) error {
-	return cosignclean.CleanCmd(ctx, regOpts, cleanType, imageRef, true)
-}
-
 // NewCleanCommand returns a command that removes attestations/signatures from an OCI image.
 func NewCleanCommand() *cobra.Command {
 	cmd := &cobra.Command{

cmd/devguard-scanner/commands/clean_test.go

@@ -25,6 +25,7 @@ import (
 	"github.com/google/go-containerregistry/pkg/registry"
 	"github.com/google/go-containerregistry/pkg/v1/random"
 	"github.com/google/go-containerregistry/pkg/v1/remote"
+	cosignclean "github.com/sigstore/cosign/v2/cmd/cosign/cli"
 	cosignoptions "github.com/sigstore/cosign/v2/cmd/cosign/cli/options"
 	ociremote "github.com/sigstore/cosign/v2/pkg/oci/remote"
 )
@@ -100,7 +101,7 @@ func TestCleanImageCleanTypeAllRemovesAllTags(t *testing.T) {
 		t.Fatal("signature tag should exist before clean")
 	}
 
-	if err := cleanImage(context.Background(), regOpts, cosignoptions.CleanTypeAll, imageRef); err != nil {
+	if err := cosignclean.CleanCmd(context.Background(), regOpts, cosignoptions.CleanTypeAll, imageRef, true); err != nil {
 		t.Fatalf("cleanImage: %v", err)
 	}
 
@@ -130,7 +131,7 @@ func TestCleanImageCleanTypeAttestationLeavesSignatureTag(t *testing.T) {
 	pushDummyImage(t, attTag, remoteOpts)
 	pushDummyImage(t, sigTag, remoteOpts)
 
-	if err := cleanImage(context.Background(), regOpts, cosignoptions.CleanTypeAttestation, imageRef); err != nil {
+	if err := cosignclean.CleanCmd(context.Background(), regOpts, cosignoptions.CleanTypeAttestation, imageRef, true); err != nil {
 		t.Fatalf("cleanImage: %v", err)
 	}
 
@@ -160,7 +161,7 @@ func TestCleanImageCleanTypeSignatureLeavesAttestationTag(t *testing.T) {
 	pushDummyImage(t, attTag, remoteOpts)
 	pushDummyImage(t, sigTag, remoteOpts)
 
-	if err := cleanImage(context.Background(), regOpts, cosignoptions.CleanTypeSignature, imageRef); err != nil {
+	if err := cosignclean.CleanCmd(context.Background(), regOpts, cosignoptions.CleanTypeSignature, imageRef, true); err != nil {
 		t.Fatalf("cleanImage: %v", err)
 	}
 
@@ -179,7 +180,7 @@ func TestCleanImageNoTagsDoesNotError(t *testing.T) {
 	pushBaseImage(t, imageRef, remoteOpts)
 
 	// no attestation/signature tags present — clean should still succeed
-	if err := cleanImage(context.Background(), regOpts, cosignoptions.CleanTypeAll, imageRef); err != nil {
+	if err := cosignclean.CleanCmd(context.Background(), regOpts, cosignoptions.CleanTypeAll, imageRef, true); err != nil {
 		t.Fatalf("cleanImage on image with no sig/att tags failed: %v", err)
 	}
 }

cmd/devguard-scanner/commands/intoto/intoto_record.go

@@ -20,41 +20,14 @@ import (
 	"fmt"
 	"log/slog"
 	"os"
-	"strings"
 
 	toto "github.com/in-toto/in-toto-golang/in_toto"
 	"github.com/l3montree-dev/devguard/cmd/devguard-scanner/config"
 	"github.com/l3montree-dev/devguard/cmd/devguard-scanner/scanner"
-	"github.com/l3montree-dev/devguard/utils"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )
 
-func parseGitIgnore(path string) ([]string, error) {
-	// read .gitignore if exists
-	content, err := os.ReadFile(path)
-	if err == nil {
-		ignorePaths := strings.Split(string(content), "\n")
-
-		// make sure to remove new lines and empty strings
-		ignorePaths = utils.Filter(
-			utils.Map(utils.Map(ignorePaths, strings.TrimSpace), func(e string) string {
-				// nextjs products a gitignore which contains /node_modules but we need to ignore /node_modules/
-				if e == "/node_modules" {
-					return e + "/"
-				}
-				return e
-			}),
-			func(e string) bool {
-				return e != "" && e != "\n" && !strings.HasPrefix(strings.TrimSpace(e), "#")
-			})
-
-		return ignorePaths, nil
-	}
-
-	return nil, err
-}
-
 func stopInTotoRecording(cmd *cobra.Command, args []string) error {
 	if config.RuntimeInTotoConfig.Disabled {
 		return nil

cmd/devguard-scanner/commands/intoto/intoto_record_test.go

@@ -1,32 +1 @@
 package intotocmd
-
-import (
-	"os"
-	"path"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestParseGitIgnore(t *testing.T) {
-	t.Run("parseGitIgnore with empty strings", func(t *testing.T) {
-		// create temp dir for testing
-		dir, err := os.MkdirTemp("", "test")
-		assert.NoError(t, err, "failed to create temporary directory")
-
-		defer os.RemoveAll(dir)
-
-		// Create a temporary .gitignore file for testing
-		gitignoreContent := "\n.DS_Store\n\t\t\t\n"
-
-		filepath := path.Join(dir, ".gitignore")
-
-		err = os.WriteFile(filepath, []byte(gitignoreContent), 0600)
-		assert.NoError(t, err, "failed to create temporary .gitignore file")
-
-		ignorePaths, err := parseGitIgnore(filepath)
-		assert.NoError(t, err, "expected no error when reading .gitignore")
-		assert.Equal(t, []string{".DS_Store"}, ignorePaths, "unexpected ignore paths")
-
-	})
-}

controllers/asset_controller.go

@@ -476,7 +476,7 @@ func (a *AssetController) GetBadges(ctx shared.Context) error {
 	}
 	var artifactName *string
 	artifact, err := shared.MaybeGetArtifact(ctx)
-	if err == nil {
+	if err == nil && artifact != nil {
 		artifactName = &artifact.ArtifactName
 	}
 

controllers/dependencyfirewall/oci.go

@@ -25,6 +25,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	
 	"regexp"
 	"strings"
 	"time"

controllers/helpers.go

@@ -28,7 +28,7 @@ func ctxToBOMMetadata(ctx shared.Context) normalize.BOMMetadata {
 	assetVersion := shared.GetAssetVersion(ctx)
 	artifactName := ""
 	artifact, err := shared.MaybeGetArtifact(ctx)
-	if err != nil {
+	if err != nil || artifact == nil {
 		org := shared.GetOrg(ctx)
 		project := shared.GetProject(ctx)