feat(internal/librarian): add release command (#3024)

The librarian release command is added, which supports releasing a
single library or all libraries in a workspace.

    librarian release <library>: bump version for one library
    librarian release --all: bump versions for all libraries

A testhelper language implementation is added to support testing the
release command without depending on external tools like cargo. The
testhelper sets all versions to "1.2.3" for predictable test assertions.

The --execute flag is added but not yet implemented. By default, the
release command operates in dry-run mode, and modifies the release
artifacts to show planned changes, without pushing any git tags.

For #2966

Author: julieqiu

internal/language/internal/rust/release.go

@@ -16,7 +16,6 @@
 package rust
 
 import (
-	"context"
 	"fmt"
 	"io/fs"
 	"os"
@@ -36,14 +35,32 @@ type cargoManifest struct {
 	Package *cargoPackage `toml:"package"`
 }
 
-// BumpVersions bumps versions for all Cargo.toml files and updates
-// librarian.yaml. If name is non-empty, only bumps the version for that
-// library.
-func BumpVersions(ctx context.Context, cfg *config.Config, name string) (*config.Config, error) {
+// 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)
+}
+
+func release(cfg *config.Config, name string) (*config.Config, error) {
 	if cfg.Versions == nil {
 		cfg.Versions = make(map[string]string)
 	}
 
+	shouldRelease := func(pkgName string) bool {
+		// If name is the empty string, release everything.
+		if name == "" {
+			return true
+		}
+		if name == pkgName {
+			return true
+		}
+		return false
+	}
+
 	var found bool
 	err := filepath.WalkDir(".", func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
@@ -64,7 +81,7 @@ func BumpVersions(ctx context.Context, cfg *config.Config, name string) (*config
 		if manifest.Package == nil {
 			return nil
 		}
-		if name != "" && manifest.Package.Name != name {
+		if !shouldRelease(manifest.Package.Name) {
 			return nil
 		}
 
@@ -82,7 +99,6 @@ func BumpVersions(ctx context.Context, cfg *config.Config, name string) (*config
 	if err != nil {
 		return nil, err
 	}
-
 	if name != "" && !found {
 		return nil, fmt.Errorf("library %q not found", name)
 	}

internal/language/internal/rust/release_test.go

@@ -18,53 +18,78 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
 	cmdtest "github.com/googleapis/librarian/internal/command"
 	"github.com/googleapis/librarian/internal/config"
 )
 
-func TestBumpVersions(t *testing.T) {
-	cmdtest.RequireCommand(t, "cargo")
-	cmdtest.RequireCommand(t, "taplo")
-	tmpDir := t.TempDir()
-	t.Chdir(tmpDir)
+const (
+	storageDir      = "src/storage"
+	storageCargo    = "src/storage/Cargo.toml"
+	storageName     = "google-cloud-storage"
+	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"
+)
 
-	createCrate(t, "src/storage", "google-cloud-storage", "1.0.0")
-	createCrate(t, "src/secretmanager", "google-cloud-secretmanager-v1", "1.5.3")
+func TestReleaseAll(t *testing.T) {
+	cfg := setupRelease(t)
+	got, err := ReleaseAll(cfg)
+	if err != nil {
+		t.Fatal(err)
+	}
 
-	cfg := &config.Config{
-		Version:  "v1",
-		Language: "rust",
-		Versions: map[string]string{
-			"google-cloud-storage":          "1.0.0",
-			"google-cloud-secretmanager-v1": "1.5.3",
-		},
+	checkCargoVersion(t, storageCargo, storageReleased)
+	checkCargoVersion(t, secretmanagerCargo, secretmanagerReleased)
+	want := map[string]string{
+		storageName:       storageReleased,
+		secretmanagerName: secretmanagerReleased,
 	}
-	configPath := "librarian.yaml"
-	if err := cfg.Write(configPath); err != nil {
-		t.Fatal(err)
+	if diff := cmp.Diff(want, got.Versions); diff != "" {
+		t.Errorf("mismatch (-want +got):\n%s", diff)
 	}
+}
 
-	updatedCfg, err := BumpVersions(t.Context(), cfg, "")
+func TestReleaseOne(t *testing.T) {
+	cfg := setupRelease(t)
+	got, err := ReleaseLibrary(cfg, storageName)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if err := updatedCfg.Write(configPath); err != nil {
-		t.Fatal(err)
+	checkCargoVersion(t, storageCargo, storageReleased)
+	checkCargoVersion(t, secretmanagerCargo, secretmanagerInitial)
+	want := map[string]string{
+		storageName:       storageReleased,
+		secretmanagerName: secretmanagerInitial,
+	}
+	if diff := cmp.Diff(want, got.Versions); diff != "" {
+		t.Errorf("mismatch (-want +got):\n%s", diff)
 	}
+}
 
-	checkCargoVersion(t, "src/storage/Cargo.toml", "1.1.0")
-	checkCargoVersion(t, "src/secretmanager/Cargo.toml", "1.6.0")
+func setupRelease(t *testing.T) *config.Config {
+	t.Helper()
+	cmdtest.RequireCommand(t, "cargo")
+	cmdtest.RequireCommand(t, "taplo")
+	tmpDir := t.TempDir()
+	t.Chdir(tmpDir)
 
-	wantVersions := map[string]string{
-		"google-cloud-storage":          "1.1.0",
-		"google-cloud-secretmanager-v1": "1.6.0",
-	}
-	if diff := cmp.Diff(wantVersions, updatedCfg.Versions); diff != "" {
-		t.Errorf("versions mismatch (-want +got):\n%s", diff)
+	createCrate(t, storageDir, storageName, storageInitial)
+	createCrate(t, secretmanagerDir, secretmanagerName, secretmanagerInitial)
+	return &config.Config{
+		Versions: map[string]string{
+			storageName:       storageInitial,
+			secretmanagerName: secretmanagerInitial,
+		},
 	}
 }
 
@@ -91,22 +116,9 @@ func checkCargoVersion(t *testing.T, path, wantVersion string) {
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	want := fmt.Sprintf(`version                = "%s"`, wantVersion)
-	if !contains(string(contents), want) {
-		t.Errorf("%s does not contain %q\nGot:\n%s", path, want, string(contents))
-	}
-}
-
-func contains(s, substr string) bool {
-	return len(s) >= len(substr) && (s == substr || len(s) > len(substr) && containsInner(s, substr))
-}
-
-func containsInner(s, substr string) bool {
-	for i := 0; i <= len(s)-len(substr); i++ {
-		if s[i:i+len(substr)] == substr {
-			return true
-		}
+	wantLine := fmt.Sprintf(`version                = "%s"`, wantVersion)
+	got := string(contents)
+	if !strings.Contains(got, wantLine) {
+		t.Errorf("%s version mismatch:\nwant line: %q\ngot:\n%s", path, wantLine, got)
 	}
-	return false
 }

internal/language/release.go

@@ -0,0 +1,48 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package language
+
+import (
+	"fmt"
+
+	"github.com/googleapis/librarian/internal/config"
+	"github.com/googleapis/librarian/internal/language/internal/rust"
+)
+
+// ReleaseAll bumps versions for all libraries and updates librarian.yaml and
+// other release artifacts for the language.
+func ReleaseAll(cfg *config.Config) (*config.Config, error) {
+	switch cfg.Language {
+	case "testhelper":
+		return testReleaseAll(cfg)
+	case "rust":
+		return rust.ReleaseAll(cfg)
+	default:
+		return nil, fmt.Errorf("language not supported for release --all: %q", cfg.Language)
+	}
+}
+
+// ReleaseLibrary bumps versions for one library and updates librarian.yaml and
+// other release artifacts for the language.
+func ReleaseLibrary(cfg *config.Config, name string) (*config.Config, error) {
+	switch cfg.Language {
+	case "testhelper":
+		return testReleaseLibrary(cfg, name)
+	case "rust":
+		return rust.ReleaseLibrary(cfg, name)
+	default:
+		return nil, fmt.Errorf("language not supported for release --all: %q", cfg.Language)
+	}
+}

internal/language/release_test.go

@@ -0,0 +1,64 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package language
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/googleapis/librarian/internal/config"
+)
+
+func TestReleaseAll(t *testing.T) {
+	cfg := &config.Config{
+		Language: "testhelper",
+		Versions: map[string]string{
+			"lib1": "0.1.0",
+			"lib2": "0.2.0",
+		},
+	}
+	cfg, err := ReleaseAll(cfg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]string{
+		"lib1": TestReleaseVersion,
+		"lib2": TestReleaseVersion,
+	}
+	if diff := cmp.Diff(want, cfg.Versions); diff != "" {
+		t.Errorf("mismatch (-want +got):\n%s", diff)
+	}
+}
+
+func TestReleaseLibrary(t *testing.T) {
+	cfg := &config.Config{
+		Language: "testhelper",
+		Versions: map[string]string{
+			"lib1": "0.1.0",
+			"lib2": "0.2.0",
+		},
+	}
+	cfg, err := ReleaseLibrary(cfg, "lib1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]string{
+		"lib1": TestReleaseVersion,
+		"lib2": "0.2.0",
+	}
+	if diff := cmp.Diff(want, cfg.Versions); diff != "" {
+		t.Errorf("mismatch (-want +got):\n%s", diff)
+	}
+}

internal/language/testhelper.go

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package language provides language implementations for testing the librarian
-// CLI logic, without calling any language-specific implementation or tooling.
 package language
 
 import (
@@ -24,11 +22,32 @@ import (
 	"github.com/googleapis/librarian/internal/config"
 )
 
+// TestReleaseVersion is the version that libraries are always released at
+// when using the testhelper language implementation.
+const TestReleaseVersion = "1.2.3"
+
+func testReleaseAll(cfg *config.Config) (*config.Config, error) {
+	if cfg.Versions == nil {
+		cfg.Versions = make(map[string]string)
+	}
+	for k := range cfg.Versions {
+		cfg.Versions[k] = TestReleaseVersion
+	}
+	return cfg, nil
+}
+
+func testReleaseLibrary(cfg *config.Config, name string) (*config.Config, error) {
+	if cfg.Versions == nil {
+		cfg.Versions = make(map[string]string)
+	}
+	cfg.Versions[name] = TestReleaseVersion
+	return cfg, nil
+}
+
 func testGenerate(library *config.Library) error {
 	if err := os.MkdirAll(library.Output, 0755); err != nil {
 		return err
 	}
-
 	content := fmt.Sprintf("# %s\n\nGenerated library\n", library.Name)
 	readmePath := filepath.Join(library.Output, "README.md")
 	return os.WriteFile(readmePath, []byte(content), 0644)

internal/librarian/librarian.go

@@ -35,6 +35,7 @@ func Run(ctx context.Context, args ...string) error {
 		Commands: []*cli.Command{
 			versionCommand(),
 			generateCommand(),
+			releaseCommand(),
 		},
 	}
 	return cmd.Run(ctx, args)