feat(pnpm/v5): merge package contexts by name and version

Author: iseki0

module/pnpm/v5/v5.go

@@ -83,20 +83,38 @@ func (p *Pkg) adjustByPath(path string) {
 	if p.Name != "" && p.Version != "" {
 		return
 	}
-	var underscore = strings.LastIndex(path, "_")
-	if underscore > -1 {
-		path = path[:underscore]
-	}
-	var i = strings.LastIndex(path, "/")
-	if i == -1 {
+	name, version, ok := parseNameVersionFromPackagePath(path)
+	if !ok {
 		return
 	}
 	if p.Name == "" {
-		p.Name = strings.Trim(path[:i], "/")
+		p.Name = name
 	}
 	if p.Version == "" {
-		p.Version = strings.Trim(path[i:], "/")
+		p.Version = version
+	}
+}
+
+func parseNameVersionFromPackagePath(path string) (name, version string, ok bool) {
+	trimmed := strings.Trim(path, "/")
+	if trimmed == "" {
+		return "", "", false
+	}
+	slash := strings.LastIndex(trimmed, "/")
+	if slash <= 0 || slash == len(trimmed)-1 {
+		return "", "", false
+	}
+
+	name = trimmed[:slash]
+	versionWithSuffix := trimmed[slash+1:]
+	underscore := strings.Index(versionWithSuffix, "_")
+	if underscore >= 0 {
+		versionWithSuffix = versionWithSuffix[:underscore]
+	}
+	if name == "" || versionWithSuffix == "" {
+		return "", "", false
 	}
+	return name, versionWithSuffix, true
 }
 
 func (l *Lockfile) buildIndexes() {
@@ -111,34 +129,51 @@ func (l *Lockfile) buildIndexes() {
 		pkg.adjustByPath(path)
 	}
 	l.pkgIndexes = make(map[[2]string]*Pkg, len(l.Packages))
-	indexPaths := make(map[[2]string]string, len(l.Packages))
 	for _, path := range paths {
 		pkg := l.Packages[path]
 		var name, version = pkg.Name, pkg.Version
 		if name == "" {
 			continue
 		}
 		key := [2]string{name, version}
-		prevPath, exists := indexPaths[key]
-		if !exists || preferPkgPath(prevPath, path, name, version) {
-			indexPaths[key] = path
-			l.pkgIndexes[key] = pkg
+		if merged, ok := l.pkgIndexes[key]; ok {
+			mergePkg(merged, pkg)
+		} else {
+			l.pkgIndexes[key] = clonePkg(pkg)
 		}
 	}
 }
 
-func preferPkgPath(currentPath, candidatePath, name, version string) bool {
-	currentCanonical := isCanonicalPath(currentPath, name, version)
-	candidateCanonical := isCanonicalPath(candidatePath, name, version)
-	if currentCanonical != candidateCanonical {
-		return candidateCanonical
+func clonePkg(pkg *Pkg) *Pkg {
+	out := &Pkg{
+		Name:    pkg.Name,
+		Version: pkg.Version,
+		Dev:     pkg.Dev,
 	}
-	return candidatePath < currentPath
+	if len(pkg.Dependencies) == 0 {
+		return out
+	}
+	out.Dependencies = make(map[string]string, len(pkg.Dependencies))
+	for n, v := range pkg.Dependencies {
+		out.Dependencies[n] = v
+	}
+	return out
 }
 
-func isCanonicalPath(path, name, version string) bool {
-	canonical := "/" + name + "/" + version
-	return path == canonical || strings.TrimPrefix(path, "/") == strings.TrimPrefix(canonical, "/")
+func mergePkg(merged, pkg *Pkg) {
+	// If any context is non-dev, keep the merged node as non-dev.
+	merged.Dev = merged.Dev && pkg.Dev
+	if len(pkg.Dependencies) == 0 {
+		return
+	}
+	if merged.Dependencies == nil {
+		merged.Dependencies = make(map[string]string, len(pkg.Dependencies))
+	}
+	for n, v := range pkg.Dependencies {
+		if _, exists := merged.Dependencies[n]; !exists {
+			merged.Dependencies[n] = v
+		}
+	}
 }
 
 func (l *Lockfile) findPkg(name, version string) (p *Pkg) {

module/pnpm/v5/v5_test.go

@@ -92,3 +92,75 @@ func TestBuildDepTree_AllTestdata(t *testing.T) {
 		})
 	}
 }
+
+func TestParseNameVersionFromPackagePath(t *testing.T) {
+	testCases := []struct {
+		path    string
+		name    string
+		version string
+		ok      bool
+	}{
+		{
+			path:    "/@babel/helper-compilation-targets/7.21.4_@babel+core@7.12.10",
+			name:    "@babel/helper-compilation-targets",
+			version: "7.21.4",
+			ok:      true,
+		},
+		{
+			path:    "/foo/1.2.3_a@1.0.0_b@2.0.0",
+			name:    "foo",
+			version: "1.2.3",
+			ok:      true,
+		},
+		{
+			path:    "/@types/babel__core/7.20.1",
+			name:    "@types/babel__core",
+			version: "7.20.1",
+			ok:      true,
+		},
+		{
+			path: "/bad",
+			ok:   false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.path, func(t *testing.T) {
+			name, version, ok := parseNameVersionFromPackagePath(tc.path)
+			assert.Equal(t, tc.ok, ok)
+			assert.Equal(t, tc.name, name)
+			assert.Equal(t, tc.version, version)
+		})
+	}
+}
+
+func TestBuildIndexes_MergeMultipleContexts(t *testing.T) {
+	l := &Lockfile{
+		Packages: map[string]*Pkg{
+			"/foo/1.2.3_peer-a@1.0.0": {
+				Dependencies: map[string]string{
+					"a": "1.0.0",
+				},
+				Dev: true,
+			},
+			"/foo/1.2.3_peer-b@2.0.0": {
+				Dependencies: map[string]string{
+					"b": "2.0.0",
+				},
+				Dev: false,
+			},
+		},
+	}
+
+	l.buildIndexes()
+
+	pkg := l.pkgIndexes[[2]string{"foo", "1.2.3"}]
+	assert.NotNil(t, pkg)
+	assert.Equal(t, "foo", pkg.Name)
+	assert.Equal(t, "1.2.3", pkg.Version)
+	assert.Equal(t, map[string]string{
+		"a": "1.0.0",
+		"b": "2.0.0",
+	}, pkg.Dependencies)
+	assert.False(t, pkg.Dev)
+}