go/goreleaser
go/goreleaser
1
0
Fork 0
mirror of https://github.com/goreleaser/goreleaser.git synced 2025-02-03 13:11:48 +02:00
Code Issues Releases Activity

wip ctx

Browse Source
This commit is contained in:
Carlos Alexandro Becker 2017-01-14 12:34:22 -02:00
parent ae6c0d3063
commit ddec194c7e
No known key found for this signature in database
GPG Key ID: E61E2F7DC14AB940
18 changed files with 260 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -1,4 +1,3 @@
dist
releasr
dist/
vendor
releaser

136
config/config.go
View File

@ -1,23 +1,15 @@
package config
import (
"errors"
"io/ioutil"
"os"
"path"
"path/filepath"
"github.com/goreleaser/releaser/config/git"
yaml "gopkg.in/yaml.v1"
)
var filePatterns = []string{"LICENCE*", "LICENSE*", "README*", "CHANGELOG*"}
// Homebrew contains the brew section
type Homebrew struct {
Repo string
Folder string
Token string `yaml:"-"`
Caveats string
}
@ -29,22 +21,13 @@ type BuildConfig struct {
Ldflags string
}
// GitInfo includes tags and diffs used in some point
type GitInfo struct {
CurrentTag string
PreviousTag string
Diff string
}
// ProjectConfig includes all project configuration
type ProjectConfig struct {
Repo string
BinaryName string `yaml:"binary_name"`
Files []string
Brew Homebrew
Token string `yaml:"-"`
Build BuildConfig
Git GitInfo `yaml:"-"`
Archive ArchiveConfig
}
@ -54,123 +37,6 @@ func Load(file string) (config ProjectConfig, err error) {
if err != nil {
return config, err
}
if err := yaml.Unmarshal(data, &config); err != nil {
return config, err
}
config.fillBasicData()
if err := config.fillFiles(); err != nil {
return config, err
}
if err := config.fillGitData(); err != nil {
return config, err
}
return config, config.validate()
}
func (config *ProjectConfig) validate() (err error) {
if config.BinaryName == "" {
return errors.New("missing binary_name")
}
if config.Repo == "" {
return errors.New("missing repo")
}
return
}
func (config *ProjectConfig) fillFiles() (err error) {
if len(config.Files) != 0 {
return
}
config.Files = []string{}
for _, pattern := range filePatterns {
matches, err := globPath(pattern)
if err != nil {
return err
}
config.Files = append(config.Files, matches...)
}
return
}
func (config *ProjectConfig) fillBasicData() {
if config.Token == "" {
config.Token = os.Getenv("GITHUB_TOKEN")
}
if config.Brew.Repo != "" {
config.Brew.Token = config.Token
}
if config.Build.Main == "" {
config.Build.Main = "main.go"
}
if len(config.Build.Oses) == 0 {
config.Build.Oses = []string{"linux", "darwin"}
}
if len(config.Build.Arches) == 0 {
config.Build.Arches = []string{"amd64", "386"}
}
if config.Build.Ldflags == "" {
config.Build.Ldflags = "-s -w"
}
if config.Archive.NameTemplate == "" {
config.Archive.NameTemplate = "{{.BinaryName}}_{{.Os}}_{{.Arch}}"
}
if config.Archive.Format == "" {
config.Archive.Format = "tar.gz"
}
if len(config.Archive.Replacements) == 0 {
config.Archive.Replacements = map[string]string{
"darwin": "Darwin",
"linux": "Linux",
"freebsd": "FreeBSD",
"openbsd": "OpenBSD",
"netbsd": "NetBSD",
"windows": "Windows",
"386": "i386",
"amd64": "x86_64",
}
}
}
func (config *ProjectConfig) fillGitData() (err error) {
tag, err := git.CurrentTag()
if err != nil {
return
}
previous, err := git.PreviousTag(tag)
if err != nil {
return
}
log, err := git.Log(previous, tag)
if err != nil {
return
}
config.Git.CurrentTag = tag
config.Git.PreviousTag = previous
config.Git.Diff = log
return
}
func globPath(p string) (m []string, err error) {
var cwd string
var dirs []string
if cwd, err = os.Getwd(); err != nil {
return
}
fp := path.Join(cwd, p)
if dirs, err = filepath.Glob(fp); err != nil {
return
}
// Normalise to avoid nested dirs in tarball
for _, dir := range dirs {
_, f := filepath.Split(dir)
m = append(m, f)
}
err = yaml.Unmarshal(data, &config)
return
}

29
context/context.go Normal file
View File

@ -0,0 +1,29 @@
package context
import "github.com/goreleaser/releaser/config"
// GitInfo includes tags and diffs used in some point
type GitInfo struct {
CurrentTag string
PreviousTag string
Diff string
}
type Repo struct {
Owner, Name string
}
type Context struct {
Config *config.ProjectConfig
Token string
Git *GitInfo
Repo *Repo
BrewRepo *Repo
Archives []string
}
func New(config config.ProjectConfig) *Context {
return &Context{
Config: config,
}
}

13
main.go
View File

@ -5,19 +5,28 @@ import (
"os"
"github.com/goreleaser/releaser/config"
"github.com/goreleaser/releaser/context"
"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/defaults"
"github.com/goreleaser/releaser/pipeline/git"
"github.com/goreleaser/releaser/pipeline/release"
"github.com/goreleaser/releaser/pipeline/repos"
"github.com/goreleaser/releaser/pipeline/valid"
"github.com/urfave/cli"
)
var version = "master"
var pipes = []pipeline.Pipe{
defaults.Pipe{},
valid.Pipe{},
git.Pipe{},
build.Pipe{},
compress.Pipe{},
repos.Pipe{},
release.Pipe{},
brew.Pipe{},
}
@ -40,9 +49,9 @@ func main() {
if err != nil {
return cli.NewExitError(err.Error(), 1)
}
log.Println("Releasing", config.Git.CurrentTag, "...")
context := context.New(config)
for _, pipe := range pipes {
if err := pipe.Run(config); err != nil {
if err := pipe.Run(context); err != nil {
return cli.NewExitError(pipe.Name()+" failed: "+err.Error(), 1)
}
}

5
pipeline/brew/brew.go
View File

@ -10,6 +10,7 @@ import (
"github.com/google/go-github/github"
"github.com/goreleaser/releaser/config"
"github.com/goreleaser/releaser/context"
"github.com/goreleaser/releaser/sha256sum"
"github.com/goreleaser/releaser/split"
"golang.org/x/oauth2"
@ -48,8 +49,8 @@ func (Pipe) Name() string {
}
// Run the pipe
func (Pipe) Run(config config.ProjectConfig) error {
if config.Brew.Repo == "" {
func (Pipe) Run(context context.Context) error {
if context.Config.Brew.Repo == "" {
return nil
}
ts := oauth2.StaticTokenSource(

27
pipeline/build/build.go
View File

@ -7,7 +7,7 @@ import (
"os"
"os/exec"
"github.com/goreleaser/releaser/config"
"github.com/goreleaser/releaser/context"
"golang.org/x/sync/errgroup"
)
@ -20,34 +20,35 @@ func (Pipe) Name() string {
}
// Run the pipe
func (Pipe) Run(config config.ProjectConfig) error {
func (Pipe) Run(context *context.Context) error {
var g errgroup.Group
for _, system := range config.Build.Oses {
for _, arch := range config.Build.Arches {
for _, system := range context.Config.Build.Oses {
for _, arch := range context.Config.Build.Arches {
system := system
arch := arch
name, err := context.Config.ArchiveName(system, arch)
if err != nil {
return err
}
context.Archives = append(context.Archives, name)
g.Go(func() error {
return build(system, arch, config)
return build(name, system, arch, context)
})
}
}
return g.Wait()
}
func build(system, arch string, config config.ProjectConfig) error {
name, err := config.ArchiveName(system, arch)
if err != nil {
return err
}
ldflags := config.Build.Ldflags + " -X main.version=" + config.Git.CurrentTag
output := "dist/" + name + "/" + config.BinaryName
func build(name, system, arch string, context *context.Context) error {
ldflags := context.Config.Build.Ldflags + " -X main.version=" + context.Git.CurrentTag
output := "dist/" + name + "/" + context.Config.BinaryName
log.Println("Building", output, "...")
cmd := exec.Command(
"go",
"build",
"-ldflags="+ldflags,
"-o", output,
config.Build.Main,
context.Config.Build.Main,
)
cmd.Env = append(
cmd.Env,

26
pipeline/compress/compress.go
View File

@ -5,6 +5,7 @@ import (
"os"
"github.com/goreleaser/releaser/config"
"github.com/goreleaser/releaser/context"
"github.com/goreleaser/releaser/pipeline/compress/tar"
"github.com/goreleaser/releaser/pipeline/compress/zip"
"golang.org/x/sync/errgroup"
@ -19,16 +20,13 @@ func (Pipe) Name() string {
}
// Run the pipe
func (Pipe) Run(config config.ProjectConfig) error {
func (Pipe) Run(context *context.Context) error {
var g errgroup.Group
for _, system := range config.Build.Oses {
for _, arch := range config.Build.Arches {
system := system
arch := arch
g.Go(func() error {
return create(system, arch, config)
})
}
for _, archive := range context.Archives {
archive := archive
g.Go(func() error {
return create(archive, context)
})
}
return g.Wait()
}
@ -38,18 +36,14 @@ type Archive interface {
Add(name, path string) error
}
func create(system, arch string, config config.ProjectConfig) error {
name, err := config.ArchiveName(system, arch)
if err != nil {
return err
}
file, err := os.Create("dist/" + name + "." + config.Archive.Format)
func create(archive string, context *context.Context) error {
file, err := os.Create("dist/" + archive + "." + context.Config.Archive.Format)
log.Println("Creating", file.Name(), "...")
if err != nil {
return err
}
defer func() { _ = file.Close() }()
var archive = archiveFor(file, config.Archive.Format)
var archive = archiveFor(file, context.Config.Archive.Format)
defer func() { _ = archive.Close() }()
for _, f := range config.Files {
if err := archive.Add(f, f); err != nil {

89
pipeline/defaults/defaults.go Normal file
View File

@ -0,0 +1,89 @@
package defaults
import (
"os"
"path"
"path/filepath"
"github.com/goreleaser/releaser/context"
)
var filePatterns = []string{"LICENCE*", "LICENSE*", "README*", "CHANGELOG*"}
// Pipe for brew deployment
type Pipe struct{}
// Name of the pipe
func (Pipe) Name() string {
return "Defaults"
}
// Run the pipe
func (Pipe) Run(context *context.Context) (err error) {
if context.Config.Build.Main == "" {
context.Config.Build.Main = "main.go"
}
if len(context.Config.Build.Oses) == 0 {
context.Config.Build.Oses = []string{"linux", "darwin"}
}
if len(context.Config.Build.Arches) == 0 {
context.Config.Build.Arches = []string{"amd64", "386"}
}
if context.Config.Build.Ldflags == "" {
context.Config.Build.Ldflags = "-s -w"
}
if context.Config.Archive.NameTemplate == "" {
context.Config.Archive.NameTemplate = "{{.BinaryName}}_{{.Os}}_{{.Arch}}"
}
if context.Config.Archive.Format == "" {
context.Config.Archive.Format = "tar.gz"
}
if len(context.Config.Archive.Replacements) == 0 {
context.Config.Archive.Replacements = map[string]string{
"darwin": "Darwin",
"linux": "Linux",
"freebsd": "FreeBSD",
"openbsd": "OpenBSD",
"netbsd": "NetBSD",
"windows": "Windows",
"386": "i386",
"amd64": "x86_64",
}
}
if len(context.Config.Files) != 0 {
return
}
context.Config.Files = []string{}
for _, pattern := range filePatterns {
matches, err := globPath(pattern)
if err != nil {
return err
}
context.Config.Files = append(context.Config.Files, matches...)
}
return
}
func globPath(p string) (m []string, err error) {
var cwd string
var dirs []string
if cwd, err = os.Getwd(); err != nil {
return
}
fp := path.Join(cwd, p)
if dirs, err = filepath.Glob(fp); err != nil {
return
}
// Normalise to avoid nested dirs in tarball
for _, dir := range dirs {
_, f := filepath.Split(dir)
m = append(m, f)
}
return
}

32
pipeline/git/git.go Normal file
View File

@ -0,0 +1,32 @@
package git
import "github.com/goreleaser/releaser/context"
// Pipe for brew deployment
type Pipe struct{}
// Name of the pipe
func (Pipe) Name() string {
return "Git"
}
// Run the pipe
func (Pipe) Run(context *context.Context) (err error) {
tag, err := currentTag()
if err != nil {
return
}
previous, err := previousTag(tag)
if err != nil {
return
}
log, err := log(previous, tag)
if err != nil {
return
}
context.Git.CurrentTag = tag
context.Git.PreviousTag = previous
context.Git.Diff = log
return
}

3
config/git/log.go → pipeline/git/log.go
View File

@ -2,8 +2,7 @@ package git
import "os/exec"
// Log between two tags
func Log(previous, current string) (str string, err error) {
func log(previous, current string) (str string, err error) {
cmd := exec.Command(
"git",
"log",

4
config/git/log_test.go → pipeline/git/log_test.go
View File

@ -8,14 +8,14 @@ import (
func TestLog(t *testing.T) {
assert := assert.New(t)
log, err := Log("v0.1.9", "v0.2.0")
log, err := log("v0.1.9", "v0.2.0")
assert.NoError(err)
assert.NotEmpty(log)
}
func TestLogInvalidRef(t *testing.T) {
assert := assert.New(t)
log, err := Log("wtfff", "nope")
log, err := log("wtfff", "nope")
assert.Error(err)
assert.Empty(log)
}

6
config/git/tag.go → pipeline/git/tag.go
View File

@ -6,13 +6,11 @@ import (
"strings"
)
// CurrentTag tag being built
func CurrentTag() (tag string, err error) {
func currentTag() (tag string, err error) {
return getTag("")
}
// PreviousTag previous tag of the base tag
func PreviousTag(base string) (tag string, err error) {
func previousTag(base string) (tag string, err error) {
return getTag(base + "^")
}

6
config/git/tag_test.go → pipeline/git/tag_test.go
View File

@ -8,21 +8,21 @@ import (
func TestCurrentTag(t *testing.T) {
assert := assert.New(t)
tag, err := CurrentTag()
tag, err := currentTag()
assert.NoError(err)
assert.NotEmpty(tag)
}
func TestPreviousTag(t *testing.T) {
assert := assert.New(t)
tag, err := PreviousTag("v0.2.0")
tag, err := previousTag("v0.2.0")
assert.NoError(err)
assert.NotEmpty(tag)
}
func TestInvalidRef(t *testing.T) {
assert := assert.New(t)
tag, err := PreviousTag("this-should-not-exist")
tag, err := previousTag("this-should-not-exist")
assert.Error(err)
assert.Empty(tag)
}

4
pipeline/pipe.go
View File

@ -1,6 +1,6 @@
package pipeline
import "github.com/goreleaser/releaser/config"
"github.com/goreleaser/releaser/config"
// Pipe interface
type Pipe interface {
@ -8,5 +8,5 @@ type Pipe interface {
Name() string
// Run the pipe
Run(config config.ProjectConfig) error
Run(config context.Context) error
}

32
pipeline/repos/repos.go Normal file
View File

@ -0,0 +1,32 @@
package repos
import (
"context"
"strings"
"github.com/goreleaser/releaser/context"
)
// Pipe for brew deployment
type Pipe struct{}
// Name of the pipe
func (Pipe) Name() string {
return "Repos"
}
// Run the pipe
func (Pipe) Run(context *context.Context) (err error) {
owner, name := split(context.Config.Repo)
context.Repo.Owner = owner
context.Repo.Name = name
owner, name = split(context.Config.Brew.Repo)
context.BrewRepo.Owner = owner
context.BrewRepo.Name = name
return
}
func split(pair string) (string, string) {
parts := strings.Split(pair, "/")
return parts[0], parts[1]
}

4
split/split_test.go → pipeline/repos/repos_test.go
View File

@ -1,4 +1,4 @@
package split
package repos
import (
"testing"
@ -8,7 +8,7 @@ import (
func TestSplit(t *testing.T) {
assert := assert.New(t)
a, b := OnSlash("a/b")
a, b := split("a/b")
assert.Equal("a", a)
assert.Equal("b", b)
}

26
pipeline/valid/valid.go Normal file
View File

@ -0,0 +1,26 @@
package valid
import (
"errors"
"github.com/goreleaser/releaser/context"
)
// Pipe for brew deployment
type Pipe struct{}
// Name of the pipe
func (Pipe) Name() string {
return "Valid"
}
// Run the pipe
func (Pipe) Run(context *context.Context) (err error) {
if context.Config.BinaryName == "" {
return errors.New("missing binary_name")
}
if context.Config.Repo == "" {
return errors.New("missing repo")
}
return
}

9
split/split.go
View File

@ -1,9 +0,0 @@
package split
import "strings"
// OnSlash split a string on / and return the first 2 parts
func OnSlash(pair string) (string, string) {
parts := strings.Split(pair, "/")
return parts[0], parts[1]
}