Restructure publish config to use publishers slice

Follow the archives pattern: top-level publish_settings for shared
defaults and a publishers slice where each entry can match specific
releases via paths and has its own type (built-in or plugin).

- Add internal/publish/publishformats package with Format enum
- Rewrite publish_config.go with Publisher struct and PublishType
- Add Publishers field to Config struct
- Update core.go to compile publisher -> release mappings
- Rewrite publishcmd to iterate over publishers
- Update test scripts and hugoreleaser.yaml

Built-in publisher types:
- github_release: Undrafts the GitHub release
- homebrew_cask: Updates Homebrew cask file
- _plugin: External plugin (future)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: bep

cmd/corecmd/core.go

@@ -413,6 +413,18 @@ func (c *Core) Init() error {
 		}
 	}
 
+	// Precompile publisher -> release mappings.
+	for i := range c.Config.Publishers {
+		pub := &c.Config.Publishers[i]
+		for j := range c.Config.Releases {
+			release := &c.Config.Releases[j]
+			// If no release paths specified, match all releases.
+			if pub.ReleasePathsCompiled == nil || pub.ReleasePathsCompiled.Match(release.Path) {
+				pub.ReleasesCompiled = append(pub.ReleasesCompiled, release)
+			}
+		}
+	}
+
 	// Registry for archive plugins.
 	c.PluginsRegistryArchive = make(map[string]*execrpc.Client[apimodel.Config, archiveplugin.Request, any, apimodel.Receipt])
 

cmd/publishcmd/publish.go

@@ -25,9 +25,12 @@ import (
 	"text/template"
 
 	"github.com/bep/logg"
+	"github.com/gohugoio/hugoreleaser-plugins-api/model"
 	"github.com/gohugoio/hugoreleaser/cmd/corecmd"
+	"github.com/gohugoio/hugoreleaser/internal/common/matchers"
 	"github.com/gohugoio/hugoreleaser/internal/common/templ"
 	"github.com/gohugoio/hugoreleaser/internal/config"
+	"github.com/gohugoio/hugoreleaser/internal/publish/publishformats"
 	"github.com/gohugoio/hugoreleaser/internal/releases"
 	"github.com/gohugoio/hugoreleaser/staticfiles"
 	"github.com/peterbourgon/ff/v3/ffcli"
@@ -46,7 +49,7 @@ func New(core *corecmd.Core) *ffcli.Command {
 	return &ffcli.Command{
 		Name:       commandName,
 		ShortUsage: corecmd.CommandName + " publish [flags]",
-		ShortHelp:  "Publish a draft release and update package managers.",
+		ShortHelp:  "Publish releases and update package managers.",
 		FlagSet:    fs,
 		Exec:       publisher.Exec,
 	}
@@ -77,21 +80,43 @@ func (p *Publisher) Exec(ctx context.Context, args []string) error {
 		return err
 	}
 
-	// Get release settings from config.
-	if len(p.core.Config.Releases) == 0 {
-		return fmt.Errorf("%s: no releases defined in config", commandName)
+	if len(p.core.Config.Publishers) == 0 {
+		p.infoLog.Log(logg.String("No publishers configured"))
+		return nil
 	}
 
-	// Use first release for settings (consistent with release command behavior).
-	release := p.core.Config.Releases[0]
-	settings := release.ReleaseSettings
-
 	logFields := logg.Fields{
 		{Name: "tag", Value: p.core.Tag},
-		{Name: "repository", Value: fmt.Sprintf("%s/%s", settings.RepositoryOwner, settings.Repository)},
 	}
 	logCtx := p.infoLog.WithFields(logFields)
 
+	// Process each publisher.
+	for i := range p.core.Config.Publishers {
+		pub := &p.core.Config.Publishers[i]
+
+		if len(pub.ReleasesCompiled) == 0 {
+			continue
+		}
+
+		// Process each release that matches this publisher.
+		for _, release := range pub.ReleasesCompiled {
+			if err := p.handlePublisher(ctx, logCtx, pub, release); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (p *Publisher) handlePublisher(
+	ctx context.Context,
+	logCtx logg.LevelLogger,
+	pub *config.Publisher,
+	release *config.Release,
+) error {
+	settings := release.ReleaseSettings
+
 	// Create client.
 	var client releases.PublishClient
 	if p.core.Try {
@@ -108,7 +133,31 @@ func (p *Publisher) Exec(ctx context.Context, args []string) error {
 		}
 	}
 
-	// Step 1: Check and publish the GitHub release.
+	switch pub.Type.FormatParsed {
+	case publishformats.GitHubRelease:
+		return p.publishGitHubRelease(ctx, logCtx, client, release)
+	case publishformats.HomebrewCask:
+		return p.updateHomebrewCask(ctx, logCtx, client, pub, release)
+	case publishformats.Plugin:
+		return fmt.Errorf("%s: plugin publishers not yet implemented", commandName)
+	default:
+		return fmt.Errorf("%s: unknown publisher format: %s", commandName, pub.Type.Format)
+	}
+}
+
+func (p *Publisher) publishGitHubRelease(
+	ctx context.Context,
+	logCtx logg.LevelLogger,
+	client releases.PublishClient,
+	release *config.Release,
+) error {
+	settings := release.ReleaseSettings
+
+	logCtx = logCtx.WithFields(logg.Fields{
+		{Name: "action", Value: "github_release"},
+		{Name: "repository", Value: fmt.Sprintf("%s/%s", settings.RepositoryOwner, settings.Repository)},
+	})
+
 	logCtx.Log(logg.String("Checking release status"))
 
 	releaseID, isDraft, err := client.GetReleaseByTag(ctx, settings.RepositoryOwner, settings.Repository, p.core.Tag)
@@ -126,17 +175,20 @@ func (p *Publisher) Exec(ctx context.Context, args []string) error {
 		logCtx.Log(logg.String("Release is already published"))
 	}
 
-	// Step 2: Update Homebrew cask if enabled.
-	caskSettings := p.core.Config.PublishSettings.HomebrewCask
-	if caskSettings.Enabled {
-		if err := p.updateHomebrewCask(ctx, logCtx, client, release, caskSettings); err != nil {
-			return fmt.Errorf("%s: failed to update Homebrew cask: %v", commandName, err)
-		}
-	}
-
 	return nil
 }
 
+// HomebrewCaskSettings holds the custom settings for homebrew_cask publisher.
+type HomebrewCaskSettings struct {
+	BundleIdentifier string `mapstructure:"bundle_identifier"`
+	TapRepository    string `mapstructure:"tap_repository"`
+	Name             string `mapstructure:"name"`
+	CaskPath         string `mapstructure:"cask_path"`
+	TemplateFilename string `mapstructure:"template_filename"`
+	Description      string `mapstructure:"description"`
+	Homepage         string `mapstructure:"homepage"`
+}
+
 // HomebrewCaskContext holds data for the Homebrew cask template.
 type HomebrewCaskContext struct {
 	Name             string
@@ -154,17 +206,34 @@ func (p *Publisher) updateHomebrewCask(
 	ctx context.Context,
 	logCtx logg.LevelLogger,
 	client releases.PublishClient,
-	release config.Release,
-	caskSettings config.HomebrewCaskSettings,
+	pub *config.Publisher,
+	release *config.Release,
 ) error {
-	logCtx = logCtx.WithField("action", "homebrew-cask")
+	logCtx = logCtx.WithField("action", "homebrew_cask")
 	logCtx.Log(logg.String("Updating Homebrew cask"))
 
 	releaseSettings := release.ReleaseSettings
 	version := strings.TrimPrefix(p.core.Tag, "v")
 
-	// Find the first .pkg archive matching the path pattern.
-	pkgInfo, err := p.findPkgArchive(release, caskSettings)
+	// Read settings from custom_settings.
+	settings, err := model.FromMap[any, HomebrewCaskSettings](pub.CustomSettings)
+	if err != nil {
+		return fmt.Errorf("failed to parse homebrew_cask settings: %w", err)
+	}
+
+	// Apply defaults.
+	if settings.TapRepository == "" {
+		settings.TapRepository = "homebrew-tap"
+	}
+	if settings.Name == "" {
+		settings.Name = p.core.Config.Project
+	}
+	if settings.CaskPath == "" {
+		settings.CaskPath = fmt.Sprintf("Casks/%s.rb", settings.Name)
+	}
+
+	// Find the first .pkg archive matching the archive paths pattern.
+	pkgInfo, err := p.findPkgArchive(release, pub.ArchivePathsCompiled)
 	if err != nil {
 		return err
 	}
@@ -182,23 +251,23 @@ func (p *Publisher) updateHomebrewCask(
 
 	// Build cask context.
 	caskCtx := HomebrewCaskContext{
-		Name:             caskSettings.Name,
+		Name:             settings.Name,
 		DisplayName:      p.core.Config.Project,
 		Version:          version,
 		SHA256:           pkgInfo.SHA256,
 		URL:              downloadURL,
-		Description:      caskSettings.Description,
-		Homepage:         caskSettings.Homepage,
+		Description:      settings.Description,
+		Homepage:         settings.Homepage,
 		PkgFilename:      pkgInfo.Name,
-		BundleIdentifier: caskSettings.BundleIdentifier,
+		BundleIdentifier: settings.BundleIdentifier,
 	}
 
 	// Render cask template.
 	var caskContent bytes.Buffer
 	var tmpl *template.Template
 
-	if caskSettings.TemplateFilename != "" {
-		templatePath := caskSettings.TemplateFilename
+	if settings.TemplateFilename != "" {
+		templatePath := settings.TemplateFilename
 		if !filepath.IsAbs(templatePath) {
 			templatePath = filepath.Join(p.core.ProjectDir, templatePath)
 		}
@@ -219,11 +288,11 @@ func (p *Publisher) updateHomebrewCask(
 	}
 
 	// Update file in tap repository.
-	commitMessage := fmt.Sprintf("Update %s to %s", caskSettings.Name, p.core.Tag)
+	commitMessage := fmt.Sprintf("Update %s to %s", settings.Name, p.core.Tag)
 
 	logCtx.WithFields(logg.Fields{
-		{Name: "tap", Value: fmt.Sprintf("%s/%s", releaseSettings.RepositoryOwner, caskSettings.TapRepository)},
-		{Name: "path", Value: caskSettings.CaskPath},
+		{Name: "tap", Value: fmt.Sprintf("%s/%s", releaseSettings.RepositoryOwner, settings.TapRepository)},
+		{Name: "path", Value: settings.CaskPath},
 	}).Log(logg.String("Committing cask update"))
 
 	if p.core.Try {
@@ -234,8 +303,8 @@ func (p *Publisher) updateHomebrewCask(
 	sha, err := client.UpdateFileInRepo(
 		ctx,
 		releaseSettings.RepositoryOwner,
-		caskSettings.TapRepository,
-		caskSettings.CaskPath,
+		settings.TapRepository,
+		settings.CaskPath,
 		commitMessage,
 		caskContent.Bytes(),
 	)
@@ -253,18 +322,16 @@ type pkgArchiveInfo struct {
 	SHA256 string
 }
 
-// findPkgArchive finds the first .pkg archive for darwin matching the path pattern.
-func (p *Publisher) findPkgArchive(release config.Release, caskSettings config.HomebrewCaskSettings) (pkgArchiveInfo, error) {
-	pathMatcher := caskSettings.PathCompiled
-
+// findPkgArchive finds the first .pkg archive for darwin matching the archive paths pattern.
+func (p *Publisher) findPkgArchive(release *config.Release, archivePathsMatcher matchers.Matcher) (pkgArchiveInfo, error) {
 	for _, archPath := range release.ArchsCompiled {
 		// Only consider darwin archives.
 		if archPath.Arch.Os == nil || archPath.Arch.Os.Goos != "darwin" {
 			continue
 		}
 
 		// Check if the path matches the pattern.
-		if pathMatcher != nil && !pathMatcher.Match(archPath.Path) {
+		if archivePathsMatcher != nil && !archivePathsMatcher.Match(archPath.Path) {
 			continue
 		}
 
@@ -277,5 +344,5 @@ func (p *Publisher) findPkgArchive(release config.Release, caskSettings config.H
 		}
 	}
 
-	return pkgArchiveInfo{}, fmt.Errorf("no .pkg archive found for darwin matching path pattern %q", caskSettings.Path)
+	return pkgArchiveInfo{}, fmt.Errorf("no .pkg archive found for darwin")
 }

cmd/releasecmd/release.go

@@ -79,7 +79,6 @@ func (b *Releaser) Init() error {
 	}
 
 	b.infoLog = b.core.InfoLog.WithField("cmd", commandName)
-
 	releaseMatches := b.core.Config.FindReleases(b.core.PathsReleasesCompiled)
 	if len(releaseMatches) == 0 {
 		return fmt.Errorf("%s: no releases found matching -paths %v", commandName, b.core.Paths)

go.mod

@@ -12,7 +12,7 @@ require (
 	github.com/gohugoio/hugoreleaser/plugins v0.1.1-0.20220822083757-38d81884db04
 	github.com/google/go-github/v45 v45.2.0
 	github.com/mattn/go-isatty v0.0.20
-	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/mitchellh/mapstructure v1.5.0
 	github.com/pelletier/go-toml/v2 v2.2.4
 	github.com/peterbourgon/ff/v3 v3.4.0
 	github.com/rogpeppe/go-internal v1.14.1