reorganized code as a pipeline

config/config.go

@@ -5,6 +5,7 @@ import (
 	"io/ioutil"
 	"os"
 
+	"github.com/goreleaser/releaser/config/git"
 	yaml "gopkg.in/yaml.v1"
 )
 
@@ -22,6 +23,12 @@ type BuildConfig struct {
 	Main   string
 }
 
+type GitInfo struct {
+	CurrentTag  string
+	PreviousTag string
+	Diff        string
+}
+
 type ProjectConfig struct {
 	Repo       string
 	BinaryName string `yaml:"binary_name"`
@@ -29,6 +36,7 @@ type ProjectConfig struct {
 	Brew       HomebrewDeploy
 	Token      string
 	Build      BuildConfig
+	Git        GitInfo `yaml:"_"`
 }
 
 func Load(file string) (config ProjectConfig, err error) {
@@ -38,6 +46,10 @@ func Load(file string) (config ProjectConfig, err error) {
 	}
 	err = yaml.Unmarshal(data, &config)
 	config = fix(config)
+	config, err = fillGitData(config)
+	if err != nil {
+		return config, err
+	}
 	if config.BinaryName == "" {
 		return config, errors.New("missing binary_name")
 	}
@@ -72,6 +84,26 @@ func fix(config ProjectConfig) ProjectConfig {
 	return config
 }
 
+func fillGitData(config ProjectConfig) (ProjectConfig, error) {
+	tag, err := git.CurrentTag()
+	if err != nil {
+		return config, err
+	}
+	previous, err := git.PreviousTag(tag)
+	if err != nil {
+		return config, err
+	}
+	log, err := git.Log(previous, tag)
+	if err != nil {
+		return config, err
+	}
+
+	config.Git.CurrentTag = tag
+	config.Git.PreviousTag = previous
+	config.Git.Diff = log
+	return config, nil
+}
+
 func contains(s string, ss []string) bool {
 	for _, sx := range ss {
 		if sx == s {

main.go

@@ -1,15 +1,14 @@
 package main
 
 import (
-	"fmt"
 	"log"
 
-	"github.com/goreleaser/releaser/brew"
-	"github.com/goreleaser/releaser/build"
-	"github.com/goreleaser/releaser/compress"
 	"github.com/goreleaser/releaser/config"
-	"github.com/goreleaser/releaser/git"
-	"github.com/goreleaser/releaser/release"
+	"github.com/goreleaser/releaser/pipeline"
+	"github.com/goreleaser/releaser/pipeline/brew"
+	"github.com/goreleaser/releaser/pipeline/build"
+	"github.com/goreleaser/releaser/pipeline/compress"
+	"github.com/goreleaser/releaser/pipeline/release"
 )
 
 var version = "master"
@@ -19,34 +18,15 @@ func main() {
 	if err != nil {
 		log.Fatalln("Failed to load goreleaser.yml:", err.Error())
 	}
-	tag, err := git.CurrentTag()
-	if err != nil {
-		log.Fatalln("Failed to get current tag name", err.Error())
+	var pipeline = []pipeline.Pipe{
+		build.Pipe{},
+		compress.Pipe{},
+		release.Pipe{},
+		brew.Pipe{},
 	}
-	fmt.Println("Building", tag, "...")
-	err = build.Build(tag, config)
-	if err != nil {
-		log.Fatalln("Failed to diff current and previous tags", err.Error())
-	}
-	err = compress.ArchiveAll(version, config)
-	if err != nil {
-		log.Fatalln("Failed to create archives", err.Error())
-	}
-	previousTag, err := git.PreviousTag(tag)
-	if err != nil {
-		log.Fatalln("Failed to get previous tag name", err.Error())
-	}
-	diff, err := git.Log(previousTag, tag)
-	if err != nil {
-		log.Fatalln("Failed to diff current and previous tags", err.Error())
-	}
-	err = release.Release(tag, diff, config)
-	if err != nil {
-		log.Fatalln("Failed to create GitHub release", err.Error())
-	}
-	if config.Brew.Repo != "" {
-		if err := brew.Brew(tag, config); err != nil {
-			log.Fatalln("Failed to create homebrew formula", err.Error())
+	for _, pipe := range pipeline {
+		if err := pipe.Work(config); err != nil {
+			log.Fatalln(pipe.Name(), "failed:", err.Error())
 		}
 	}
 }

pipeline/brew/brew.go

@@ -11,6 +11,7 @@ import (
 	"github.com/google/go-github/github"
 	"github.com/goreleaser/releaser/config"
 	"golang.org/x/oauth2"
+	"log"
 )
 
 const formulae = `class {{ .Name }} < Formula
@@ -34,8 +35,17 @@ type templateData struct {
 	Name, Desc, Homepage, Repo, Tag, BinaryName, Caveats string
 }
 
-func Brew(version string, config config.ProjectConfig) error {
-	fmt.Println("Updating brew formulae...")
+type Pipe struct{}
+
+func (Pipe) Name() string {
+	return "Homebrew"
+}
+
+func (Pipe) Work(config config.ProjectConfig) error {
+	if config.Brew.Repo == "" {
+		return nil
+	}
+	log.Println("Updating brew formulae...")
 	ts := oauth2.StaticTokenSource(
 		&oauth2.Token{AccessToken: config.Token},
 	)
@@ -43,7 +53,7 @@ func Brew(version string, config config.ProjectConfig) error {
 	client := github.NewClient(tc)
 	parts := strings.Split(config.Brew.Repo, "/")
 
-	data, err := dataFor(version, config, client)
+	data, err := dataFor(config, client)
 	if err != nil {
 		return err
 	}
@@ -72,7 +82,7 @@ func Brew(version string, config config.ProjectConfig) error {
 				Email: github.String("bot@goreleaser"),
 			},
 			Content: out.Bytes(),
-			Message: github.String(config.BinaryName + " version " + version),
+			Message: github.String(config.BinaryName + " version " + config.Git.CurrentTag),
 			SHA:     sha,
 		},
 	)
@@ -89,7 +99,7 @@ func buildFormulae(data templateData) (bytes.Buffer, error) {
 	return out, err
 }
 
-func dataFor(version string, config config.ProjectConfig, client *github.Client) (result templateData, err error) {
+func dataFor(config config.ProjectConfig, client *github.Client) (result templateData, err error) {
 	var homepage string
 	var description string
 	parts := strings.Split(config.Repo, "/")
@@ -112,7 +122,7 @@ func dataFor(version string, config config.ProjectConfig, client *github.Client)
 		Desc:       description,
 		Homepage:   homepage,
 		Repo:       config.Repo,
-		Tag:        version,
+		Tag:        config.Git.CurrentTag,
 		BinaryName: config.BinaryName,
 		Caveats:    config.Brew.Caveats,
 	}, err

pipeline/build/build.go

@@ -3,7 +3,7 @@ package build
 import (
 	"bytes"
 	"errors"
-	"fmt"
+	"log"
 	"os"
 	"os/exec"
 
@@ -12,26 +12,32 @@ import (
 	"golang.org/x/sync/errgroup"
 )
 
-func Build(version string, config config.ProjectConfig) error {
+type Pipe struct{}
+
+func (Pipe) Name() string {
+	return "Build"
+}
+
+func (Pipe) Work(config config.ProjectConfig) error {
 	var g errgroup.Group
 	for _, bos := range config.Build.Oses {
 		for _, arch := range config.Build.Arches {
 			bos := bos
 			arch := arch
 			g.Go(func() error {
-				return build(bos, arch, version, config)
+				return build(bos, arch, config)
 			})
 		}
 	}
 	return g.Wait()
 }
 
-func build(bos, arch, version string, config config.ProjectConfig) error {
-	fmt.Println("Building", bos+"/"+arch, "...")
+func build(bos, arch string, config config.ProjectConfig) error {
+	log.Println("Building", bos+"/"+arch, "...")
 	cmd := exec.Command(
 		"go",
 		"build",
-		"-ldflags=-s -w -X main.version="+version,
+		"-ldflags=-s -w -X main.version="+config.Git.CurrentTag,
 		"-o", target(bos, arch, config.BinaryName),
 		config.Build.Main,
 	)

pipeline/compress/zip.go

@@ -5,13 +5,22 @@ import (
 	"compress/gzip"
 	"fmt"
 	"io"
+	"log"
 	"os"
 
 	"github.com/goreleaser/releaser/config"
 	"github.com/goreleaser/releaser/uname"
 )
 
-func ArchiveAll(version string, config config.ProjectConfig) error {
+type Pipe struct{}
+
+func (Pipe) Name() string {
+	return "Compress"
+}
+
+func (Pipe) Work(config config.ProjectConfig) error {
+	log.Println("Creating archives...")
+	// TODO use a errgroup here?
 	for _, system := range config.Build.Oses {
 		for _, arch := range config.Build.Arches {
 			if err := create(system, arch, config); err != nil {

pipeline/pipe.go

@@ -0,0 +1,8 @@
+package pipeline
+
+import "github.com/goreleaser/releaser/config"
+
+type Pipe interface {
+	Name() string
+	Work(config config.ProjectConfig) error
+}

pipeline/release/release.go

@@ -2,7 +2,7 @@ package release
 
 import (
 	"context"
-	"fmt"
+	"log"
 	"os"
 	"os/exec"
 	"strings"
@@ -14,8 +14,14 @@ import (
 	"golang.org/x/sync/errgroup"
 )
 
-func Release(version, diff string, config config.ProjectConfig) error {
-	fmt.Println("Creating release", version, "on repo", config.Repo, "...")
+type Pipe struct{}
+
+func (Pipe) Name() string {
+	return "GithubRelease"
+}
+
+func (Pipe) Work(config config.ProjectConfig) error {
+	log.Println("Creating release", config.Git.CurrentTag, "on repo", config.Repo, "...")
 	ts := oauth2.StaticTokenSource(
 		&oauth2.Token{AccessToken: config.Token},
 	)
@@ -24,12 +30,11 @@ func Release(version, diff string, config config.ProjectConfig) error {
 
 	owner := strings.Split(config.Repo, "/")[0]
 	repo := strings.Split(config.Repo, "/")[1]
-	releaseData := &github.RepositoryRelease{
-		Name:            github.String(version),
-		TagName:         github.String(version),
-		Body:            github.String(description(diff)),
-	}
-	r, _, err := client.Repositories.CreateRelease(owner, repo, releaseData)
+	r, _, err := client.Repositories.CreateRelease(owner, repo, &github.RepositoryRelease{
+		Name:            github.String(config.Git.CurrentTag),
+		TagName:         github.String(config.Git.CurrentTag),
+		Body:            github.String(description(config.Git.Diff)),
+	})
 	if err != nil {
 		return err
 	}
@@ -63,7 +68,7 @@ func upload(client *github.Client, releaseID int, owner, repo, system, arch, bin
 		return err
 	}
 	defer file.Close()
-	fmt.Println("Uploading", file.Name(), "...")
+	log.Println("Uploading", file.Name(), "...")
 	_, _, err = client.Repositories.UploadReleaseAsset(owner, repo, releaseID, &github.UploadOptions{
 		Name: name,
 	}, file)