feat(hooks): initial

Author: christophwitzko

cmd/semantic-release/main.go

@@ -11,6 +11,7 @@ import (
 	"github.com/Masterminds/semver/v3"
 	"github.com/go-semantic-release/semantic-release/v2/pkg/config"
 	"github.com/go-semantic-release/semantic-release/v2/pkg/generator"
+	"github.com/go-semantic-release/semantic-release/v2/pkg/hooks"
 	"github.com/go-semantic-release/semantic-release/v2/pkg/plugin/manager"
 	"github.com/go-semantic-release/semantic-release/v2/pkg/provider"
 	"github.com/go-semantic-release/semantic-release/v2/pkg/semrel"
@@ -114,17 +115,38 @@ func cliHandler(cmd *cobra.Command, args []string) {
 	currentSha := ci.GetCurrentSHA()
 	logger.Println("found current sha: " + currentSha)
 
+	hooksExecutor, err := pluginManager.GetChainedHooksExecutor()
+	exitIfError(err)
+
+	hooksNames := hooksExecutor.GetNameVersionPairs()
+	if len(hooksNames) > 0 {
+		logger.Printf("hooks plugins: %s\n", strings.Join(hooksNames, ", "))
+	}
+
+	exitIfError(hooksExecutor.Init(conf.HooksOpts))
+
 	if !conf.NoCI {
 		logger.Println("running CI condition...")
-		config := map[string]string{
+		conditionConfig := map[string]string{
 			"token":         conf.Token,
 			"defaultBranch": repoInfo.DefaultBranch,
 			"private":       fmt.Sprintf("%t", repoInfo.Private),
 		}
 		for k, v := range conf.CIConditionOpts {
-			config[k] = v
+			conditionConfig[k] = v
+		}
+		err = ci.RunCondition(conditionConfig)
+		if err != nil {
+			herr := hooksExecutor.NoRelease(&hooks.NoReleaseConfig{
+				Reason:  hooks.NoReleaseReason_CONDITION,
+				Message: err.Error(),
+			})
+			if herr != nil {
+				logger.Printf("there was an error executing the hooks plugins: %s", herr.Error())
+			}
+			exitIfError(err, 66)
 		}
-		exitIfError(ci.RunCondition(config), 66)
+
 	}
 
 	logger.Println("getting latest release...")
@@ -158,6 +180,13 @@ func cliHandler(cmd *cobra.Command, args []string) {
 	logger.Println("calculating new version...")
 	newVer := semrel.GetNewVersion(conf, commits, release)
 	if newVer == "" {
+		herr := hooksExecutor.NoRelease(&hooks.NoReleaseConfig{
+			Reason:  hooks.NoReleaseReason_NO_CHANGE,
+			Message: "",
+		})
+		if herr != nil {
+			logger.Printf("there was an error executing the hooks plugins: %s", herr.Error())
+		}
 		if conf.AllowNoChanges {
 			logger.Println("no change")
 			os.Exit(0)
@@ -215,5 +244,20 @@ func cliHandler(cmd *cobra.Command, args []string) {
 		}
 	}
 
+	herr := hooksExecutor.Success(&hooks.SuccessHookConfig{
+		Commits:     commits,
+		PrevRelease: release,
+		NewRelease: &semrel.Release{
+			SHA:     currentSha,
+			Version: newVer,
+		},
+		Changelog: changelogRes,
+		RepoInfo:  repoInfo,
+	})
+
+	if herr != nil {
+		logger.Printf("there was an error executing the hooks plugins: %s", herr.Error())
+	}
+
 	logger.Println("done.")
 }

pkg/config/config.go

@@ -22,6 +22,8 @@ type Config struct {
 	Changelog                       string
 	FilesUpdaterPlugins             []string
 	FilesUpdaterOpts                map[string]string
+	HooksPlugins                    []string
+	HooksOpts                       map[string]string
 	UpdateFiles                     []string
 	Match                           string
 	VersionFile                     bool
@@ -89,6 +91,9 @@ func NewConfig(cmd *cobra.Command) (*Config, error) {
 	fuOpts := mergeOpts(
 		viper.GetStringMapString("plugins.files-updater.options"),
 		mustGetStringArray(cmd, "files-updater-opt"))
+	hoOpts := mergeOpts(
+		viper.GetStringMapString("plugins.hooks.options"),
+		mustGetStringArray(cmd, "hooks-opt"))
 
 	conf := &Config{
 		Token:                           mustGetString(cmd, "token"),
@@ -103,6 +108,8 @@ func NewConfig(cmd *cobra.Command) (*Config, error) {
 		Changelog:                       mustGetString(cmd, "changelog"),
 		FilesUpdaterPlugins:             viper.GetStringSlice("plugins.files-updater.names"),
 		FilesUpdaterOpts:                fuOpts,
+		HooksPlugins:                    viper.GetStringSlice("plugins.hooks.names"),
+		HooksOpts:                       hoOpts,
 		UpdateFiles:                     mustGetStringArray(cmd, "update"),
 		Match:                           mustGetString(cmd, "match"),
 		VersionFile:                     mustGetBool(cmd, "version-file"),
@@ -114,7 +121,6 @@ func NewConfig(cmd *cobra.Command) (*Config, error) {
 		AllowNoChanges:                  mustGetBool(cmd, "allow-no-changes"),
 		MaintainedVersion:               viper.GetString("maintainedVersion"),
 	}
-
 	return conf, nil
 }
 func must(err error) {
@@ -153,6 +159,8 @@ func InitConfig(cmd *cobra.Command) error {
 	cmd.Flags().String("changelog", "", "creates a changelog file")
 	cmd.Flags().StringSlice("files-updater", []string{"npm"}, "files-updater plugin names")
 	cmd.Flags().StringArray("files-updater-opt", []string{}, "options that are passed to the files-updater plugins")
+	cmd.Flags().StringSlice("hooks", []string{}, "hooks plugin names")
+	cmd.Flags().StringArray("hooks-opt", []string{}, "options that are passed to the hooks plugins")
 	cmd.Flags().StringArrayP("update", "u", []string{}, "updates the version of a certain files")
 	cmd.Flags().String("match", "", "only consider tags matching the given glob(7) pattern, excluding the \"refs/tags/\" prefix.")
 	cmd.Flags().String("maintained-version", "", "set the maintained version as base for new releases")
@@ -177,6 +185,7 @@ func InitConfig(cmd *cobra.Command) error {
 	must(viper.BindPFlag("plugins.ci-condition.name", cmd.Flags().Lookup("ci-condition")))
 	must(viper.BindPFlag("plugins.changelog-generator.name", cmd.Flags().Lookup("changelog-generator")))
 	must(viper.BindPFlag("plugins.files-updater.names", cmd.Flags().Lookup("files-updater")))
+	must(viper.BindPFlag("plugins.hooks.names", cmd.Flags().Lookup("hooks")))
 
 	if err := viper.ReadInConfig(); err != nil {
 		if _, ok := err.(viper.ConfigFileNotFoundError); !ok {

pkg/hooks/hooks.go

@@ -0,0 +1,53 @@
+package hooks
+
+import "fmt"
+
+type Hooks interface {
+	Init(map[string]string) error
+	Name() string
+	Version() string
+	Success(*SuccessHookConfig) error
+	NoRelease(*NoReleaseConfig) error
+}
+
+type ChainedHooksExecutor struct {
+	HooksChain []Hooks
+}
+
+func (c *ChainedHooksExecutor) Success(config *SuccessHookConfig) error {
+	for _, h := range c.HooksChain {
+		err := h.Success(config)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *ChainedHooksExecutor) NoRelease(config *NoReleaseConfig) error {
+	for _, h := range c.HooksChain {
+		err := h.NoRelease(config)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *ChainedHooksExecutor) Init(conf map[string]string) error {
+	for _, h := range c.HooksChain {
+		err := h.Init(conf)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *ChainedHooksExecutor) GetNameVersionPairs() []string {
+	ret := make([]string, len(c.HooksChain))
+	for i, h := range c.HooksChain {
+		ret[i] = fmt.Sprintf("%s@%s", h.Name(), h.Version())
+	}
+	return ret
+}