map refactor

xray/audit/java/gradle.go

@@ -45,44 +45,50 @@ allprojects {
  }`
 )
 
-type gradleDepsMap map[string]any
-
-func (gdg *gradleDepsMap) appendTree(jsonDepTree []byte) error {
- var rootNode map[string]any
- if err := json.Unmarshal(jsonDepTree, &rootNode); err != nil {
-  return err
- }
+type depTreeManager struct {
+ DependenciesMap
+ server *config.ServerDetails
+ releasesRepo string
+ depsRepo string
+ useWrapper bool
+}
 
- for gav, node := range rootNode["children"].(map[string]any) {
- if _, exists := (*gdg)[gav]; !exists {
- (*gdg)[gav] = node
- }
- }
- return nil
+// DependenciesMap key in this map is the "GAV" of a dependency, and the value is its children dependencies.
+type DependenciesMap struct {
+ Dependencies map[string]DependenciesMap `json:"children"`
 }
 
 // The gradle-dep-tree generates a JSON representation for the dependencies for each gradle build file in the project.
-// parseDepTreeFiles iterates over those JSONs, and append them to the map of dependencies in gradleDepsMap struct.
-func (gdg *gradleDepsMap) parseDepTreeFiles(jsonFiles []byte) error {
+// parseDepTreeFiles iterates over those JSONs, and append them to the map of dependencies in DependenciesMap struct.
+func (dtp *depTreeManager) parseDepTreeFiles(jsonFiles []byte) error {
  outputFiles := strings.Split(strings.TrimSpace(string(jsonFiles)), "\n")
  for _, path := range outputFiles {
  tree, err := os.ReadFile(strings.TrimSpace(path))
  if err != nil {
  return err
  }
- if err = gdg.appendTree(tree); err != nil {
+ if err = dtp.appendDependenciesTree(tree); err != nil {
  return err
  }
 
  }
  return nil
 }
 
-type depTreeManager struct {
- server *config.ServerDetails
- releasesRepo string
- depsRepo string
- useWrapper bool
+func (dtp *depTreeManager) appendDependenciesTree(jsonDepTree []byte) error {
+ var deps DependenciesMap
+ if err := json.Unmarshal(jsonDepTree, &deps); err != nil {
+ return err
+ }
+ for gav, children := range deps.Dependencies {
+ if dtp.Dependencies == nil {
+ dtp.Dependencies = make(map[string]DependenciesMap)
+ }
+ if _, exists := dtp.Dependencies[gav]; !exists {
+ dtp.Dependencies[gav] = children
+ }
+ }
+ return nil
 }
 
 func buildGradleDependencyTree(useWrapper bool, server *config.ServerDetails, depsRepo, releasesRepo string) (dependencyTree []*services.GraphNode, err error) {
@@ -178,25 +184,24 @@ func (dtp *depTreeManager) execGradleDepTree() (outputFileContent []byte, err er
 
 // Assuming we ran gradle-dep-tree, getGraphFromDepTree receives the content of the depTreeOutputFile as input
 func (dtp *depTreeManager) getGraphFromDepTree(outputFileContent []byte) ([]*services.GraphNode, error) {
- dependencyMap := gradleDepsMap{}
- if err := dependencyMap.parseDepTreeFiles(outputFileContent); err != nil {
+ if err := dtp.parseDepTreeFiles(outputFileContent); err != nil {
  return nil, err
  }
 
  var depsGraph []*services.GraphNode
- for dependency, dependencyDetails := range dependencyMap {
+ for dependency, children := range dtp.Dependencies {
  directDependency := &services.GraphNode{
  Id: GavPackageTypeIdentifier + dependency,
  Nodes: []*services.GraphNode{},
  }
- populateGradleDependencyTree(directDependency, dependencyDetails.(map[string]any)["children"].(map[string]any))
+ populateGradleDependencyTree(directDependency, children)
  depsGraph = append(depsGraph, directDependency)
  }
  return depsGraph, nil
 }
 
-func populateGradleDependencyTree(currNode *services.GraphNode, currNodeChildren map[string]any) {
- for gav, details := range currNodeChildren {
+func populateGradleDependencyTree(currNode *services.GraphNode, currNodeChildren DependenciesMap) {
+ for gav, children := range currNodeChildren.Dependencies {
  childNode := &services.GraphNode{
  Id: GavPackageTypeIdentifier + gav,
  Nodes: []*services.GraphNode{},
@@ -205,8 +210,7 @@ func populateGradleDependencyTree(currNode *services.GraphNode, currNodeChildren
  if currNode.NodeHasLoop() {
  return
  }
- childNodeChildren := details.(map[string]any)["children"].(map[string]any)
- populateGradleDependencyTree(childNode, childNodeChildren)
+ populateGradleDependencyTree(childNode, children)
  currNode.Nodes = append(currNode.Nodes, childNode)
  }
 }