Use effective pom to analyze pom.xml

cli/azd/internal/appdetect/appdetect.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/azure/azure-dev/cli/azd/pkg/exec"
 	"github.com/azure/azure-dev/cli/azd/pkg/tools/dotnet"
+	"github.com/azure/azure-dev/cli/azd/pkg/tools/maven"
 	"github.com/bmatcuk/doublestar/v4"
 )
 
@@ -179,7 +180,8 @@ type projectDetector interface {
 var allDetectors = []projectDetector{
 	// Order here determines precedence when two projects are in the same directory.
 	// This is unlikely to occur in practice, but reordering could help to break the tie in these cases.
-	&javaDetector{},
+	&javaDetector{
+		mvnCli: maven.NewCli(exec.NewCommandRunner(nil))},
 	&dotNetAppHostDetector{
 		// TODO(ellismg): Remove ambient authority.
 		dotnetCli: dotnet.NewCli(exec.NewCommandRunner(nil)),

cli/azd/internal/appdetect/java.go

@@ -2,18 +2,16 @@ package appdetect
 
 import (
 	"context"
-	"encoding/xml"
 	"fmt"
 	"io/fs"
-	"maps"
-	"os"
 	"path/filepath"
-	"slices"
 	"strings"
+
+	"github.com/azure/azure-dev/cli/azd/pkg/tools/maven"
 )
 
 type javaDetector struct {
-	rootProjects []mavenProject
+	mvnCli *maven.Cli
 }
 
 func (jd *javaDetector) Language() Language {
@@ -23,28 +21,18 @@ func (jd *javaDetector) Language() Language {
 func (jd *javaDetector) DetectProject(ctx context.Context, path string, entries []fs.DirEntry) (*Project, error) {
 	for _, entry := range entries {
 		if strings.ToLower(entry.Name()) == "pom.xml" {
-			pomFile := filepath.Join(path, entry.Name())
-			project, err := readMavenProject(pomFile)
+			pomFilePath := filepath.Join(path, entry.Name())
+			project, err := toMavenProject(ctx, jd.mvnCli, pomFilePath)
 			if err != nil {
 				return nil, fmt.Errorf("error reading pom.xml: %w", err)
 			}
 
-			if len(project.Modules) > 0 {
+			if len(project.pom.Modules) > 0 {
 				// This is a multi-module project, we will capture the analysis, but return nil
 				// to continue recursing
-				jd.rootProjects = append(jd.rootProjects, *project)
 				return nil, nil
 			}
 
-			var currentRoot *mavenProject
-			for _, rootProject := range jd.rootProjects {
-				// we can say that the project is in the root project if the path is under the project
-				if inRoot := strings.HasPrefix(pomFile, rootProject.path); inRoot {
-					currentRoot = &rootProject
-				}
-			}
-
-			_ = currentRoot // use currentRoot here in the analysis
 			result, err := detectDependencies(project, &Project{
 				Language:      Java,
 				Path:          path,
@@ -60,84 +48,3 @@ func (jd *javaDetector) DetectProject(ctx context.Context, path string, entries
 
 	return nil, nil
 }
-
-// mavenProject represents the top-level structure of a Maven POM file.
-type mavenProject struct {
-	XmlName              xml.Name             `xml:"project"`
-	Parent               parent               `xml:"parent"`
-	Modules              []string             `xml:"modules>module"` // Capture the modules
-	Dependencies         []dependency         `xml:"dependencies>dependency"`
-	DependencyManagement dependencyManagement `xml:"dependencyManagement"`
-	Build                build                `xml:"build"`
-	path                 string
-}
-
-// Parent represents the parent POM if this project is a module.
-type parent struct {
-	GroupId    string `xml:"groupId"`
-	ArtifactId string `xml:"artifactId"`
-	Version    string `xml:"version"`
-}
-
-// Dependency represents a single Maven dependency.
-type dependency struct {
-	GroupId    string `xml:"groupId"`
-	ArtifactId string `xml:"artifactId"`
-	Version    string `xml:"version"`
-	Scope      string `xml:"scope,omitempty"`
-}
-
-// DependencyManagement includes a list of dependencies that are managed.
-type dependencyManagement struct {
-	Dependencies []dependency `xml:"dependencies>dependency"`
-}
-
-// Build represents the build configuration which can contain plugins.
-type build struct {
-	Plugins []plugin `xml:"plugins>plugin"`
-}
-
-// Plugin represents a build plugin.
-type plugin struct {
-	GroupId    string `xml:"groupId"`
-	ArtifactId string `xml:"artifactId"`
-	Version    string `xml:"version"`
-}
-
-func readMavenProject(filePath string) (*mavenProject, error) {
-	bytes, err := os.ReadFile(filePath)
-	if err != nil {
-		return nil, err
-	}
-
-	var project mavenProject
-	if err := xml.Unmarshal(bytes, &project); err != nil {
-		return nil, fmt.Errorf("parsing xml: %w", err)
-	}
-
-	project.path = filepath.Dir(filePath)
-
-	return &project, nil
-}
-
-func detectDependencies(mavenProject *mavenProject, project *Project) (*Project, error) {
-	databaseDepMap := map[DatabaseDep]struct{}{}
-	for _, dep := range mavenProject.Dependencies {
-		if dep.GroupId == "com.mysql" && dep.ArtifactId == "mysql-connector-j" {
-			databaseDepMap[DbMySql] = struct{}{}
-		}
-
-		if dep.GroupId == "org.postgresql" && dep.ArtifactId == "postgresql" {
-			databaseDepMap[DbPostgres] = struct{}{}
-		}
-	}
-
-	if len(databaseDepMap) > 0 {
-		project.DatabaseDeps = slices.SortedFunc(maps.Keys(databaseDepMap),
-			func(a, b DatabaseDep) int {
-				return strings.Compare(string(a), string(b))
-			})
-	}
-
-	return project, nil
-}

cli/azd/internal/appdetect/maven_project.go

@@ -0,0 +1,44 @@
+package appdetect
+
+import (
+	"context"
+	"maps"
+	"slices"
+	"strings"
+
+	"github.com/azure/azure-dev/cli/azd/pkg/tools/maven"
+)
+
+type mavenProject struct {
+	pom pom
+}
+
+func toMavenProject(ctx context.Context, mvnCli *maven.Cli, pomFilePath string) (mavenProject, error) {
+	pom, err := toPom(ctx, mvnCli, pomFilePath)
+	if err != nil {
+		return mavenProject{}, err
+	}
+	return mavenProject{pom: pom}, nil
+}
+
+func detectDependencies(mavenProject mavenProject, project *Project) (*Project, error) {
+	databaseDepMap := map[DatabaseDep]struct{}{}
+	for _, dep := range mavenProject.pom.Dependencies {
+		if dep.GroupId == "com.mysql" && dep.ArtifactId == "mysql-connector-j" {
+			databaseDepMap[DbMySql] = struct{}{}
+		}
+
+		if dep.GroupId == "org.postgresql" && dep.ArtifactId == "postgresql" {
+			databaseDepMap[DbPostgres] = struct{}{}
+		}
+	}
+
+	if len(databaseDepMap) > 0 {
+		project.DatabaseDeps = slices.SortedFunc(maps.Keys(databaseDepMap),
+			func(a, b DatabaseDep) int {
+				return strings.Compare(string(a), string(b))
+			})
+	}
+
+	return project, nil
+}

cli/azd/internal/appdetect/pom.go

@@ -0,0 +1,93 @@
+package appdetect
+
+import (
+	"context"
+	"encoding/xml"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/azure/azure-dev/cli/azd/pkg/tools/maven"
+)
+
+func toPom(ctx context.Context, mvnCli *maven.Cli, pomFilePath string) (pom, error) {
+	result, err := toEffectivePom(ctx, mvnCli, pomFilePath)
+	if err == nil {
+		result.path = filepath.Dir(pomFilePath)
+		return result, nil
+	}
+
+	result, err = unmarshalPomFile(pomFilePath)
+	if err == nil {
+		result.path = filepath.Dir(pomFilePath)
+		return result, nil
+	}
+	return pom{}, err
+}
+
+func toEffectivePom(ctx context.Context, mvnCli *maven.Cli, pomFilePath string) (pom, error) {
+	effectivePom, err := mvnCli.EffectivePom(ctx, pomFilePath)
+	if err != nil {
+		return pom{}, err
+	}
+	var resultPom pom
+	err = xml.Unmarshal([]byte(effectivePom), &resultPom)
+	return resultPom, err
+}
+
+func unmarshalPomFile(pomFilePath string) (pom, error) {
+	bytes, err := os.ReadFile(pomFilePath)
+	if err != nil {
+		return pom{}, err
+	}
+
+	var result pom
+	if err := xml.Unmarshal(bytes, &result); err != nil {
+		return pom{}, fmt.Errorf("parsing xml: %w", err)
+	}
+
+	return result, nil
+}
+
+// pom represents the top-level structure of a Maven POM file.
+type pom struct {
+	XmlName              xml.Name             `xml:"project"`
+	Parent               parent               `xml:"parent"`
+	Modules              []string             `xml:"modules>module"` // Capture the modules
+	Dependencies         []dependency         `xml:"dependencies>dependency"`
+	DependencyManagement dependencyManagement `xml:"dependencyManagement"`
+	Build                build                `xml:"build"`
+	path                 string
+}
+
+// Parent represents the parent POM if this project is a module.
+type parent struct {
+	GroupId    string `xml:"groupId"`
+	ArtifactId string `xml:"artifactId"`
+	Version    string `xml:"version"`
+}
+
+// Dependency represents a single Maven dependency.
+type dependency struct {
+	GroupId    string `xml:"groupId"`
+	ArtifactId string `xml:"artifactId"`
+	Version    string `xml:"version"`
+	Scope      string `xml:"scope,omitempty"`
+}
+
+// DependencyManagement includes a list of dependencies that are managed.
+type dependencyManagement struct {
+	Dependencies []dependency `xml:"dependencies>dependency"`
+}
+
+// Build represents the build configuration which can contain plugins.
+type build struct {
+	Plugins []plugin `xml:"plugins>plugin"`
+}
+
+// Plugin represents a build plugin.
+type plugin struct {
+	GroupId    string `xml:"groupId"`
+	ArtifactId string `xml:"artifactId"`
+	Version    string `xml:"version"`
+}