fix: only release libraries if something has changed since last release (#3339)

Add logic to generic release command that if --all flag is specified
only release libraries if a change has been made since the previous
release.

Fix #3327

Author: ldetmer

internal/librarian/internal/rust/release.go

@@ -16,7 +16,6 @@
 package rust
 
 import (
-	"errors"
 	"os"
 	"path/filepath"
 	"strings"
@@ -36,14 +35,8 @@ type cargoManifest struct {
 	Package *cargoPackage `toml:"package"`
 }
 
-var errCouldNotDeriveSrcPath = errors.New("could not derive source path for library")
-
 // 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
-	}
+func ReleaseLibrary(library *config.Library, srcPath string) error {
 	cargoFile := filepath.Join(srcPath, "Cargo.toml")
 	cargoContents, err := os.ReadFile(cargoFile)
 	if err != nil {
@@ -70,7 +63,8 @@ func ReleaseLibrary(cfg *config.Config, library *config.Library) error {
 	return nil
 }
 
-func deriveSrcPath(libCfg *config.Library, cfg *config.Config) string {
+// DeriveSrcPath determines what src path library code lives in.
+func DeriveSrcPath(libCfg *config.Library, cfg *config.Config) string {
 	if libCfg.Output != "" {
 		return libCfg.Output
 	}

internal/librarian/internal/rust/release_test.go

@@ -40,7 +40,7 @@ const (
 
 func TestReleaseOne(t *testing.T) {
 	cfg := setupRelease(t)
-	err := ReleaseLibrary(cfg, cfg.Libraries[0])
+	err := ReleaseLibrary(cfg.Libraries[0], storageDir)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -161,24 +161,17 @@ func TestDeriveSrcPath(t *testing.T) {
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
-			got := deriveSrcPath(test.config.Libraries[0], test.config)
+			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)
+func TestNoCargoFile(t *testing.T) {
+	got := ReleaseLibrary(&config.Library{}, "")
+	if got == nil {
+		t.Errorf("Expected error reading cargo file but got %v", got)
 	}
 }

internal/librarian/release.go

@@ -20,16 +20,21 @@ import (
 	"fmt"
 
 	"github.com/googleapis/librarian/internal/config"
+	"github.com/googleapis/librarian/internal/librarian/githelpers"
 	"github.com/googleapis/librarian/internal/librarian/internal/rust"
 	"github.com/googleapis/librarian/internal/yaml"
 	"github.com/urfave/cli/v3"
 )
 
-var errLibraryNotFound = errors.New("library not found")
+var (
+	errCouldNotDeriveSrcPath = errors.New("could not derive source path for library")
+	errLibraryNotFound       = errors.New("library not found")
+	errReleaseConfigEmpty    = errors.New("librarian Release.Config field empty")
+)
 
 var (
-	rustReleaseLibrary       = rust.ReleaseLibrary
 	librarianGenerateLibrary = generateLibrary
+	rustReleaseLibrary       = rust.ReleaseLibrary
 )
 
 func releaseCommand() *cli.Command {
@@ -69,19 +74,27 @@ func runRelease(ctx context.Context, cmd *cli.Command) error {
 	if all && libraryName != "" {
 		return errBothLibraryAndAllFlag
 	}
-
 	cfg, err := yaml.Read[config.Config](librarianConfigPath)
 	if err != nil {
 		return err
 	}
+	gitExe := cfg.Release.GetExecutablePath("git")
+	if err := githelpers.AssertGitStatusClean(ctx, gitExe); err != nil {
+		return err
+	}
+
 	if all {
 		err = releaseAll(ctx, cfg)
 	} else {
 		libConfg, err := libraryByName(cfg, libraryName)
 		if err != nil {
 			return err
 		}
-		err = releaseLibrary(ctx, cfg, libConfg)
+		srcPath, err := getSrcPathForLanguage(cfg, libConfg)
+		if err != nil {
+			return err
+		}
+		err = releaseLibrary(ctx, cfg, libConfg, srcPath)
 		if err != nil {
 			return err
 		}
@@ -94,19 +107,43 @@ func runRelease(ctx context.Context, cmd *cli.Command) error {
 
 func releaseAll(ctx context.Context, cfg *config.Config) error {
 	for _, library := range cfg.Libraries {
-		if err := releaseLibrary(ctx, cfg, library); err != nil {
+		srcPath, err := getSrcPathForLanguage(cfg, library)
+		if err != nil {
 			return err
 		}
+		release, err := shouldReleaseLibrary(ctx, cfg, srcPath)
+		if err != nil {
+			return err
+		}
+		if release {
+			if err := releaseLibrary(ctx, cfg, library, srcPath); err != nil {
+				return err
+			}
+		}
 	}
 	return nil
 }
 
-func releaseLibrary(ctx context.Context, cfg *config.Config, libConfig *config.Library) error {
+func getSrcPathForLanguage(cfg *config.Config, libConfig *config.Library) (string, error) {
+	srcPath := ""
+	switch cfg.Language {
+	case "testhelper":
+		srcPath = testDeriveSrcPath(libConfig)
+	case "rust":
+		srcPath = rust.DeriveSrcPath(libConfig, cfg)
+	}
+	if srcPath == "" {
+		return "", errCouldNotDeriveSrcPath
+	}
+	return srcPath, nil
+}
+
+func releaseLibrary(ctx context.Context, cfg *config.Config, libConfig *config.Library, srcPath string) error {
 	switch cfg.Language {
 	case "testhelper":
 		return testReleaseLibrary(libConfig)
 	case "rust":
-		if err := rustReleaseLibrary(cfg, libConfig); err != nil {
+		if err := rustReleaseLibrary(libConfig, srcPath); err != nil {
 			return err
 		}
 		if _, err := librarianGenerateLibrary(ctx, cfg, libConfig.Name); err != nil {
@@ -130,3 +167,22 @@ func libraryByName(c *config.Config, name string) (*config.Library, error) {
 	}
 	return nil, errLibraryNotFound
 }
+
+// shouldReleaseLibrary looks up last release tag and returns true if any commits have been made
+// in the provided path since then.
+func shouldReleaseLibrary(ctx context.Context, cfg *config.Config, path string) (bool, error) {
+	if cfg.Release == nil {
+		return false, errReleaseConfigEmpty
+	}
+	gitExe := cfg.Release.GetExecutablePath("git")
+	lastTag, err := githelpers.GetLastTag(ctx, gitExe, cfg.Release.Remote, cfg.Release.Branch)
+	if err != nil {
+		return false, err
+	}
+	numberOfChanges, err := githelpers.ChangesInDirectorySinceTag(ctx, gitExe, lastTag, path)
+	if err != nil {
+		return false, err
+	}
+
+	return numberOfChanges > 0, nil
+}