chore: refactor release cmd so its source of truth is librarian.yaml not cargo files (#3316)

"release -all" was failing because it was trying to find releases for
packages specified in cargo.toml file but then not finding them in
librarian.yaml. Cargo.toml files should not be source of truth as it
contains entries that don't map to a library, ex:
[user-guide-samples](https://github.com/googleapis/google-cloud-rust/blob/c37cdf6e9c80acd9f1501e1d39714d31e4f07ac4/Cargo.lock#L7939).

This refactor changes so that we use librarian.yaml as the source of
truth for getting libraries to release. It moves this logic to librarian
release.go file as this should not be language specific. As part of
moving this logic I also migrated all release-all logic to librarian
release.go, since this is also is not language specific.

Example PR after running release-all:
https://github.com/googleapis/google-cloud-rust/compare/main...ldetmer:google-cloud-rust:test-release?expand=1

Fixes #3308

---------

Signed-off-by: ldetmer <[email protected]>
Co-authored-by: Min Zhu <[email protected]>

Author: ldetmer

internal/librarian/internal/rust/release.go

@@ -17,19 +17,16 @@ package rust
 
 import (
 	"errors"
-	"fmt"
-	"io/fs"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/googleapis/librarian/internal/config"
 	"github.com/googleapis/librarian/internal/semver"
 	rustrelease "github.com/googleapis/librarian/internal/sidekick/rust_release"
 	"github.com/pelletier/go-toml/v2"
 )
 
-var errLibraryNotFound = errors.New("library not found")
-
 type cargoPackage struct {
 	Name    string `toml:"name"`
 	Version string `toml:"version"`
@@ -39,85 +36,53 @@ type cargoManifest struct {
 	Package *cargoPackage `toml:"package"`
 }
 
-// ReleaseAll bumps versions for all Cargo.toml files and updates librarian.yaml.
-func ReleaseAll(cfg *config.Config) (*config.Config, error) {
-	return release(cfg, "")
-}
-
-// ReleaseLibrary bumps the version for a specific library and updates librarian.yaml.
-func ReleaseLibrary(cfg *config.Config, name string) (*config.Config, error) {
-	return release(cfg, name)
-}
+var errCouldNotDeriveSrcPath = errors.New("could not derive source path for library")
 
-func release(cfg *config.Config, name string) (*config.Config, error) {
-	shouldRelease := func(pkgName string) bool {
-		// If name is the empty string, release everything.
-		if name == "" {
-			return true
-		}
-		return name == pkgName
+// ReleaseLibrary bumps version for Cargo.toml files and updates librarian config version.
+func ReleaseLibrary(cfg *config.Config, library *config.Library) error {
+	srcPath := deriveSrcPath(library, cfg)
+	if srcPath == "" {
+		return errCouldNotDeriveSrcPath
 	}
-
-	var found bool
-	err := filepath.WalkDir(".", func(path string, d fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		if d.IsDir() || d.Name() != "Cargo.toml" {
-			return nil
-		}
-		contents, err := os.ReadFile(path)
-		if err != nil {
-			return err
-		}
-
-		var manifest cargoManifest
-		if err := toml.Unmarshal(contents, &manifest); err != nil {
-			return err
-		}
-		if manifest.Package == nil {
-			return nil
-		}
-		if !shouldRelease(manifest.Package.Name) {
-			return nil
-		}
-
-		found = true
-		newVersion, err := semver.DeriveNextOptions{
-			BumpVersionCore:       true,
-			DowngradePreGAChanges: true,
-		}.DeriveNext(semver.Minor, manifest.Package.Version)
-		if err != nil {
-			return err
-		}
-		if err := rustrelease.UpdateCargoVersion(path, newVersion); err != nil {
-			return err
-		}
-		library, err := libraryByName(cfg, manifest.Package.Name)
-		if err != nil {
-			return err
-		}
-		library.Version = newVersion
-		return nil
-	})
+	cargoFile := filepath.Join(srcPath, "Cargo.toml")
+	cargoContents, err := os.ReadFile(cargoFile)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	if name != "" && !found {
-		return nil, fmt.Errorf("library %q not found", name)
+	var manifest cargoManifest
+	if err := toml.Unmarshal(cargoContents, &manifest); err != nil {
+		return err
 	}
-	return cfg, nil
+	if manifest.Package == nil {
+		return err
+	}
+	newVersion, err := semver.DeriveNextOptions{
+		BumpVersionCore:       true,
+		DowngradePreGAChanges: true,
+	}.DeriveNext(semver.Minor, manifest.Package.Version)
+	if err != nil {
+		return err
+	}
+	if err := rustrelease.UpdateCargoVersion(cargoFile, newVersion); err != nil {
+		return err
+	}
+	library.Version = newVersion
+	return nil
 }
 
-// libraryByName returns a library with the given name from the config.
-func libraryByName(c *config.Config, name string) (*config.Library, error) {
-	if c.Libraries == nil {
-		return nil, errLibraryNotFound
+func deriveSrcPath(libCfg *config.Library, cfg *config.Config) string {
+	if libCfg.Output != "" {
+		return libCfg.Output
 	}
-	for _, library := range c.Libraries {
-		if library.Name == name {
-			return library, nil
+	libSrcDir := ""
+	if len(libCfg.Channels) > 0 && libCfg.Channels[0].Path != "" {
+		libSrcDir = libCfg.Channels[0].Path
+	} else {
+		libSrcDir = strings.ReplaceAll(libCfg.Name, "-", "/")
+		if cfg.Default == nil {
+			return ""
 		}
 	}
-	return nil, errLibraryNotFound
+	return DefaultOutput(libSrcDir, cfg.Default.Output)
+
 }

internal/librarian/internal/rust/release_test.go

@@ -15,14 +15,12 @@
 package rust
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 
-	"github.com/google/go-cmp/cmp"
 	"github.com/googleapis/librarian/internal/config"
 	"github.com/googleapis/librarian/internal/testhelpers"
 )
@@ -34,37 +32,23 @@ const (
 	storageInitial  = "1.0.0"
 	storageReleased = "1.1.0"
 
-	secretmanagerDir      = "src/secretmanager"
-	secretmanagerCargo    = "src/secretmanager/Cargo.toml"
-	secretmanagerName     = "google-cloud-secretmanager-v1"
-	secretmanagerInitial  = "1.5.3"
-	secretmanagerReleased = "1.6.0"
+	secretmanagerDir     = "src/secretmanager"
+	secretmanagerCargo   = "src/secretmanager/Cargo.toml"
+	secretmanagerName    = "google-cloud-secretmanager-v1"
+	secretmanagerInitial = "1.5.3"
 )
 
-func TestReleaseAll(t *testing.T) {
-	cfg := setupRelease(t)
-	got, err := ReleaseAll(cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	checkCargoVersion(t, storageCargo, storageReleased)
-	checkCargoVersion(t, secretmanagerCargo, secretmanagerReleased)
-	checkLibraryVersion(t, got, storageName, storageReleased)
-	checkLibraryVersion(t, got, secretmanagerName, secretmanagerReleased)
-}
-
 func TestReleaseOne(t *testing.T) {
 	cfg := setupRelease(t)
-	got, err := ReleaseLibrary(cfg, storageName)
+	err := ReleaseLibrary(cfg, cfg.Libraries[0])
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	checkCargoVersion(t, storageCargo, storageReleased)
 	checkCargoVersion(t, secretmanagerCargo, secretmanagerInitial)
-	checkLibraryVersion(t, got, storageName, storageReleased)
-	checkLibraryVersion(t, got, secretmanagerName, secretmanagerInitial)
+	checkLibraryVersion(t, cfg.Libraries[0], storageReleased)
+	checkLibraryVersion(t, cfg.Libraries[1], secretmanagerInitial)
 }
 
 func setupRelease(t *testing.T) *config.Config {
@@ -81,10 +65,12 @@ func setupRelease(t *testing.T) *config.Config {
 			{
 				Name:    storageName,
 				Version: storageInitial,
+				Output:  storageDir,
 			},
 			{
 				Name:    secretmanagerName,
 				Version: secretmanagerInitial,
+				Output:  secretmanagerDir,
 			},
 		},
 	}
@@ -120,71 +106,79 @@ func checkCargoVersion(t *testing.T, path, wantVersion string) {
 	}
 }
 
-func checkLibraryVersion(t *testing.T, cfg *config.Config, name, wantVersion string) {
+func checkLibraryVersion(t *testing.T, library *config.Library, wantVersion string) {
 	t.Helper()
-	for _, lib := range cfg.Libraries {
-		if lib.Name == name {
-			if lib.Version != wantVersion {
-				t.Errorf("library %q version mismatch: want %q, got %q", name, wantVersion, lib.Version)
-			}
-			return
-		}
+	if library.Version != wantVersion {
+		t.Errorf("library %q version mismatch: want %q, got %q", library.Name, wantVersion, library.Version)
 	}
-	t.Errorf("library %q not found in config", name)
 }
 
-func TestLibraryByName(t *testing.T) {
+func TestDeriveSrcPath(t *testing.T) {
 	for _, test := range []struct {
-		name        string
-		libraryName string
-		config      *config.Config
-		want        *config.Library
-		wantErr     error
+		name   string
+		config *config.Config
+		want   string
 	}{
 		{
-			name:        "find_a_library",
-			libraryName: "example-library",
+			name: "use library output",
 			config: &config.Config{
+				Default: &config.Default{
+					Output: "ignored",
+				},
 				Libraries: []*config.Library{
-					{Name: "example-library"},
-					{Name: "another-library"},
+					{Output: "src/lib/dir"},
 				},
 			},
-			want: &config.Library{Name: "example-library"},
+			want: "src/lib/dir",
 		},
 		{
-			name:        "no_library_in_config",
-			libraryName: "example-library",
-			config:      &config.Config{},
-			wantErr:     errLibraryNotFound,
+			name: "use channel path",
+			config: &config.Config{
+				Default: &config.Default{
+					Output: "src/",
+				},
+				Libraries: []*config.Library{{
+					Channels: []*config.Channel{
+						{Path: "channel/dir"},
+					},
+				},
+				},
+			},
+			want: "src/channel/dir",
 		},
 		{
-			name:        "does_not_find_a_library",
-			libraryName: "non-existent-library",
+			name: "use library name",
 			config: &config.Config{
-				Libraries: []*config.Library{
-					{Name: "example-library"},
-					{Name: "another-library"},
+				Default: &config.Default{
+					Output: "src/",
+				},
+				Libraries: []*config.Library{{
+					Name: "lib-name",
+				},
 				},
 			},
-			wantErr: errLibraryNotFound,
+			want: "src/lib/name",
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
-			got, err := libraryByName(test.config, test.libraryName)
-			if test.wantErr != nil {
-				if !errors.Is(err, test.wantErr) {
-					t.Errorf("got error %v, want %v", err, test.wantErr)
-				}
-				return
-			}
-			if err != nil {
-				t.Errorf("libraryByName(%q): %v", test.libraryName, err)
-				return
-			}
-			if diff := cmp.Diff(test.want, got); diff != "" {
-				t.Errorf("mismatch (-want +got):\n%s", diff)
+			got := deriveSrcPath(test.config.Libraries[0], test.config)
+			if got != test.want {
+				t.Errorf("got derived source path  %s, wanted %s", got, test.want)
 			}
 		})
 	}
 }
+
+func TestInvalidDerivedSource(t *testing.T) {
+	cfg := &config.Config{
+		Libraries: []*config.Library{
+			{
+				Name: storageName,
+			},
+		},
+	}
+	err := ReleaseLibrary(cfg, cfg.Libraries[0])
+	if err != errCouldNotDeriveSrcPath {
+		t.Errorf("wanted error %v, got %v", errCouldNotDeriveSrcPath, err)
+	}
+}