Add maven lockfile v2 support and fix bzlmod label handling (#158)

* Add maven lockfile v2 support and fix bzlmod label handling

- Add LockfileV2 struct to parse rules_jvm_external v2 lockfile format
- Update NewResolver to try v2 format first, fallback to v1
- Sort artifact IDs for deterministic putSymbol iteration
- Add get_apparent_label() to convert canonical labels to apparent names
  (e.g., @@rules_jvm_external~5.3~maven -> @maven)
- Change preferred_deps to string_keyed_label_dict for proper label handling
- Rename CleanupLabel to CleanupLabelName for clarity
- Remove unused _ijar attribute from java_index rule
- Add unit tests for maven resolver

* Use + for repo separator (default in bazel 8)

* cleanup

Author: pcj

pkg/bazel/bazel.go

@@ -19,7 +19,7 @@ var (
 	nonWordRe    = regexp.MustCompile(`\W+`)
 )
 
-func CleanupLabel(in string) string {
+func CleanupLabelName(in string) string {
 	return nonWordRe.ReplaceAllString(in, "_")
 }
 

pkg/maven/config.go

@@ -41,3 +41,38 @@ type Dep struct {
 	URL                string   `json:"url,omitempty"`
 	Exclusions         []string `json:"exclusions,omitempty"`
 }
+
+// LockfileV2 represents the maven2_install.json structure
+type LockfileV2 struct {
+	InputArtifactsHash    int64                          `json:"__INPUT_ARTIFACTS_HASH"`
+	ResolvedArtifactsHash int64                          `json:"__RESOLVED_ARTIFACTS_HASH"`
+	Version               string                         `json:"version"`
+	Artifacts             map[string]ArtifactV2          `json:"artifacts"`
+	Dependencies          map[string][]string            `json:"dependencies"`
+	Packages              map[string][]string            `json:"packages"`
+	Repositories          map[string][]string            `json:"repositories"`
+	Services              map[string]map[string][]string `json:"services"`
+	ConflictResolution    map[string]string              `json:"conflict_resolution"`
+	Skipped               []string                       `json:"skipped"`
+}
+
+// ArtifactV2 represents metadata for a single maven artifact
+type ArtifactV2 struct {
+	Version string            `json:"version"`
+	Shasums map[string]string `json:"shasums"`
+}
+
+func loadLockfileV2(filename string) (*LockfileV2, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	var lf LockfileV2
+	if err := json.NewDecoder(f).Decode(&lf); err != nil {
+		return nil, err
+	}
+
+	return &lf, nil
+}

pkg/maven/resolver.go

@@ -3,6 +3,8 @@ package maven
 import (
 	"errors"
 	"fmt"
+	"log"
+	"sort"
 
 	"github.com/bazelbuild/bazel-gazelle/label"
 	"github.com/stackb/scala-gazelle/pkg/bazel"
@@ -38,17 +40,30 @@ func NewResolver(installFile, mavenWorkspaceName, lang string, warn warnFunc, pu
 		artifacts: make(map[string]label.Label),
 	}
 
+	log.Println("loading configuration from:", installFile)
+
+	// Try v2 format first
+	v2, err := loadLockfileV2(installFile)
+	if err == nil && v2.Version == "2" {
+		return newResolverFromV2(&r, v2, mavenWorkspaceName, putSymbol)
+	}
+
+	// Fallback to v1 format
 	c, err := loadConfiguration(installFile)
 	if err != nil {
 		return nil, fmt.Errorf("loading configuration %s: %w", installFile, err)
 	}
 
+	return newResolverFromV1(&r, c, mavenWorkspaceName, putSymbol)
+}
+
+func newResolverFromV1(r *mavenResolver, c *configFile, mavenWorkspaceName string, putSymbol putSymbolFunc) (Resolver, error) {
 	for _, dep := range c.DependencyTree.Dependencies {
-		c, err := ParseCoordinate(dep.Coord)
+		coord, err := ParseCoordinate(dep.Coord)
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse coordinate %v: %w", dep.Coord, err)
 		}
-		from := label.Label{Repo: mavenWorkspaceName, Name: bazel.CleanupLabel(c.ArtifactString())}
+		from := label.Label{Repo: mavenWorkspaceName, Name: bazel.CleanupLabelName(coord.ArtifactString())}
 		labelString := from.String()
 		r.artifacts[dep.Coord] = from
 
@@ -58,7 +73,30 @@ func NewResolver(installFile, mavenWorkspaceName, lang string, warn warnFunc, pu
 		}
 	}
 
-	return &r, nil
+	return r, nil
+}
+
+func newResolverFromV2(r *mavenResolver, lf *LockfileV2, mavenWorkspaceName string, putSymbol putSymbolFunc) (Resolver, error) {
+	// Sort artifact IDs for deterministic iteration
+	ids := make([]string, 0, len(lf.Packages))
+	for id := range lf.Packages {
+		ids = append(ids, id)
+	}
+	sort.Strings(ids)
+
+	for _, id := range ids {
+		packages := lf.Packages[id]
+		from := label.Label{Repo: mavenWorkspaceName, Name: bazel.CleanupLabelName(id)}
+		labelString := from.String()
+		r.artifacts[id] = from
+
+		for _, pkg := range packages {
+			r.data.Add(pkg, labelString)
+			putSymbol(resolver.NewSymbol(sppb.ImportType_PACKAGE, pkg, mavenWorkspaceName, from))
+		}
+	}
+
+	return r, nil
 }
 
 func (r *mavenResolver) Name() string {

pkg/maven/resolver_test.go

@@ -0,0 +1,219 @@
+package maven
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/bazelbuild/bazel-gazelle/label"
+	"github.com/google/go-cmp/cmp"
+	"github.com/stackb/scala-gazelle/pkg/resolver"
+)
+
+func TestNewResolver(t *testing.T) {
+	for name, tc := range map[string]struct {
+		content    string
+		wantLabels []string
+	}{
+		"v1 format": {
+			content: `{
+				"dependency_tree": {
+					"dependencies": [
+						{
+							"coord": "xml-apis:xml-apis:1.4.01",
+							"dependencies": [],
+							"directDependencies": [],
+							"file": "xml-apis-1.4.01.jar",
+							"packages": ["javax.xml", "javax.xml.parsers"],
+							"sha256": "abc123"
+						}
+					],
+					"version": "0.1.0"
+				}
+			}`,
+			wantLabels: []string{
+				"@maven//:xml_apis_xml_apis",
+				"@maven//:xml_apis_xml_apis",
+			},
+		},
+		"v2 format": {
+			content: `{
+				"__INPUT_ARTIFACTS_HASH": 123,
+				"__RESOLVED_ARTIFACTS_HASH": 456,
+				"version": "2",
+				"artifacts": {
+					"xml-apis:xml-apis": {
+						"version": "1.4.01",
+						"shasums": {"jar": "abc123"}
+					}
+				},
+				"packages": {
+					"xml-apis:xml-apis": ["javax.xml", "javax.xml.parsers"]
+				},
+				"dependencies": {},
+				"repositories": {},
+				"services": {},
+				"conflict_resolution": {},
+				"skipped": []
+			}`,
+			wantLabels: []string{
+				"@maven//:xml_apis_xml_apis",
+				"@maven//:xml_apis_xml_apis",
+			},
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			tmpDir := t.TempDir()
+			installFile := filepath.Join(tmpDir, "maven_install.json")
+			if err := os.WriteFile(installFile, []byte(tc.content), 0644); err != nil {
+				t.Fatal(err)
+			}
+
+			var gotSymbols []*resolver.Symbol
+			putSymbol := func(s *resolver.Symbol) error {
+				gotSymbols = append(gotSymbols, s)
+				return nil
+			}
+
+			r, err := NewResolver(installFile, "maven", "scala", func(format string, args ...interface{}) {}, putSymbol)
+			if err != nil {
+				t.Fatalf("NewResolver: %v", err)
+			}
+
+			if r.Name() != "maven" {
+				t.Errorf("Name() = %q, want %q", r.Name(), "maven")
+			}
+
+			var gotLabels []string
+			for _, s := range gotSymbols {
+				gotLabels = append(gotLabels, s.Label.String())
+			}
+
+			if diff := cmp.Diff(tc.wantLabels, gotLabels); diff != "" {
+				t.Errorf("labels (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
+func TestNewResolverV2Deterministic(t *testing.T) {
+	// Create a v2 lockfile with multiple artifacts
+	content := `{
+		"__INPUT_ARTIFACTS_HASH": 123,
+		"__RESOLVED_ARTIFACTS_HASH": 456,
+		"version": "2",
+		"artifacts": {},
+		"packages": {
+			"com.example:charlie": ["com.example.charlie"],
+			"com.example:alpha": ["com.example.alpha"],
+			"com.example:bravo": ["com.example.bravo"]
+		},
+		"dependencies": {},
+		"repositories": {},
+		"services": {},
+		"conflict_resolution": {},
+		"skipped": []
+	}`
+
+	tmpDir := t.TempDir()
+	installFile := filepath.Join(tmpDir, "maven_install.json")
+	if err := os.WriteFile(installFile, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Run multiple times to verify deterministic ordering
+	var firstOrder []string
+	for i := 0; i < 10; i++ {
+		var gotSymbols []*resolver.Symbol
+		putSymbol := func(s *resolver.Symbol) error {
+			gotSymbols = append(gotSymbols, s)
+			return nil
+		}
+
+		_, err := NewResolver(installFile, "maven", "scala", func(format string, args ...interface{}) {}, putSymbol)
+		if err != nil {
+			t.Fatalf("NewResolver: %v", err)
+		}
+
+		var order []string
+		for _, s := range gotSymbols {
+			order = append(order, s.Name)
+		}
+
+		if i == 0 {
+			firstOrder = order
+			// Verify alphabetical ordering
+			want := []string{"com.example.alpha", "com.example.bravo", "com.example.charlie"}
+			if diff := cmp.Diff(want, order); diff != "" {
+				t.Errorf("expected alphabetical order (-want +got):\n%s", diff)
+			}
+		} else {
+			if diff := cmp.Diff(firstOrder, order); diff != "" {
+				t.Errorf("iteration %d: order is not deterministic (-first +current):\n%s", i, diff)
+			}
+		}
+	}
+}
+
+func TestResolverResolve(t *testing.T) {
+	content := `{
+		"__INPUT_ARTIFACTS_HASH": 123,
+		"__RESOLVED_ARTIFACTS_HASH": 456,
+		"version": "2",
+		"artifacts": {},
+		"packages": {
+			"com.example:foo": ["com.example.foo", "com.example.foo.bar"]
+		},
+		"dependencies": {},
+		"repositories": {},
+		"services": {},
+		"conflict_resolution": {},
+		"skipped": []
+	}`
+
+	tmpDir := t.TempDir()
+	installFile := filepath.Join(tmpDir, "maven_install.json")
+	if err := os.WriteFile(installFile, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	r, err := NewResolver(installFile, "maven", "scala", func(format string, args ...interface{}) {}, func(s *resolver.Symbol) error { return nil })
+	if err != nil {
+		t.Fatalf("NewResolver: %v", err)
+	}
+
+	for name, tc := range map[string]struct {
+		pkg       string
+		wantLabel label.Label
+		wantErr   bool
+	}{
+		"found package": {
+			pkg:       "com.example.foo",
+			wantLabel: label.Label{Repo: "maven", Name: "com_example_foo"},
+		},
+		"found nested package": {
+			pkg:       "com.example.foo.bar",
+			wantLabel: label.Label{Repo: "maven", Name: "com_example_foo"},
+		},
+		"not found": {
+			pkg:     "com.example.notfound",
+			wantErr: true,
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			got, err := r.Resolve(tc.pkg)
+			if tc.wantErr {
+				if err == nil {
+					t.Error("expected error, got nil")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("Resolve: %v", err)
+			}
+			if diff := cmp.Diff(tc.wantLabel, got); diff != "" {
+				t.Errorf("Resolve (-want +got):\n%s", diff)
+			}
+		})
+	}
+}

pkg/provider/java_provider.go

@@ -173,9 +173,9 @@ func (p *JavaProvider) readClassFile(classFile *jipb.ClassFile, from label.Label
 }
 
 func (p *JavaProvider) putSymbol(impType sppb.ImportType, imp string, from label.Label) *resolver.Symbol {
-	symbol := resolver.NewSymbol(impType, imp, p.Name(), from)
-	p.scope.PutSymbol(symbol)
-	return symbol
+	sym := resolver.NewSymbol(impType, imp, p.Name(), from)
+	p.scope.PutSymbol(sym)
+	return sym
 }
 
 // ParseLabelNonCanonical parses a label string and returns a non-canonical label.

pkg/provider/maven_provider.go

@@ -69,6 +69,7 @@ func (p *MavenProvider) loadFile(dir string, filename string, scope resolver.Sco
 	if !filepath.IsAbs(filename) {
 		filename = filepath.Join(dir, filename)
 	}
+
 	resolver, err := maven.NewResolver(filename, name, p.lang, func(format string, args ...interface{}) {
 		log.Printf(format, args...)
 	}, scope.PutSymbol)