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

allow ignoring specific builds

Browse Source
This commit is contained in:
Carlos Alexandro Becker 2017-04-26 20:08:25 -03:00
parent 95b9876327
commit 57292d64aa
No known key found for this signature in database
GPG Key ID: E61E2F7DC14AB940
7 changed files with 157 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
config/config.go
View File

@ -38,11 +38,17 @@ type Hooks struct {
Post string
}
// IgnoredBuild represents a build ignored by the user
type IgnoredBuild struct {
Goos, Goarch, Goarm string
}
// Build contains the build configuration section
type Build struct {
Goos []string
Goarch []string
Goarm []string
Ignore []IgnoredBuild
Main string
Ldflags string
Flags string

2
pipeline/build/build.go
View File

@ -29,7 +29,7 @@ func (Pipe) Run(ctx *context.Context) error {
}
sem := make(chan bool, 4)
var g errgroup.Group
for _, target := range allBuildTargets(ctx) {
for _, target := range buildTargets(ctx) {
name, err := nameFor(ctx, target)
if err != nil {
return err

4
pipeline/build/name_test.go
View File

@ -1,6 +1,7 @@
package build
import (
"log"
"testing"
"github.com/goreleaser/goreleaser/config"
@ -50,7 +51,7 @@ func TestInvalidNameTemplate(t *testing.T) {
var config = config.Project{
Archive: config.Archive{
NameTemplate: "{{.Binaryyy}}_{{.Os}}_{{.Arch}}_{{.Version}}",
NameTemplate: "{{.Binary}_{{.Os}}_{{.Arch}}_{{.Version}}",
},
Build: config.Build{
Binary: "test",
@ -64,6 +65,7 @@ func TestInvalidNameTemplate(t *testing.T) {
}
_, err := nameFor(ctx, buildTarget{"darwin", "amd64", ""})
log.Println(err.Error())
assert.Error(err)
}

39
pipeline/build/target.go
View File

@ -19,13 +19,24 @@ func (t buildTarget) String() string {
return fmt.Sprintf("%v%v%v", t.goos, t.goarch, t.goarm)
}
func buildTargets(ctx *context.Context) (targets []buildTarget) {
for _, target := range allBuildTargets(ctx) {
if !valid(target) {
log.Println("Skipped invalid build target:", target)
continue
}
if ignored(ctx, target) {
log.Println("Skipped ignored build target:", target)
continue
}
targets = append(targets, target)
}
return
}
func allBuildTargets(ctx *context.Context) (targets []buildTarget) {
for _, goos := range ctx.Config.Build.Goos {
for _, goarch := range ctx.Config.Build.Goarch {
if !valid(goos, goarch) {
log.Printf("Skipped build for %v/%v\n", goos, goarch)
continue
}
if goarch == "arm" {
for _, goarm := range ctx.Config.Build.Goarm {
targets = append(targets, buildTarget{goos, goarch, goarm})
@ -37,3 +48,23 @@ func allBuildTargets(ctx *context.Context) (targets []buildTarget) {
}
return
}
func ignored(ctx *context.Context, target buildTarget) bool {
for _, ig := range ctx.Config.Build.Ignore {
var ignored = buildTarget{ig.Goos, ig.Goarch, ig.Goarm}
if ignored == target {
return true
}
}
return false
}
func valid(target buildTarget) bool {
var s = target.goos + target.goarch
for _, a := range valids {
if a == s {
return true
}
}
return false
}

112
pipeline/build/target_test.go Normal file
View File

@ -0,0 +1,112 @@
package build
import (
"fmt"
"testing"
"github.com/goreleaser/goreleaser/config"
"github.com/goreleaser/goreleaser/context"
"github.com/stretchr/testify/assert"
)
func TestAllBuildTargets(t *testing.T) {
var assert = assert.New(t)
var ctx = &context.Context{
Config: config.Project{
Build: config.Build{
Goos: []string{
"linux",
"darwin",
"freebsd",
},
Goarch: []string{
"386",
"amd64",
"arm",
"arm64",
},
Goarm: []string{
"6",
"7",
},
Ignore: []config.IgnoredBuild{
{
Goos: "darwin",
Goarch: "386",
}, {
Goos: "linux",
Goarch: "arm",
Goarm: "7",
},
},
},
},
}
assert.Equal([]buildTarget{
buildTarget{"linux", "386", ""},
buildTarget{"linux", "amd64", ""},
buildTarget{"linux", "arm", "6"},
buildTarget{"linux", "arm64", ""},
buildTarget{"darwin", "amd64", ""},
buildTarget{"freebsd", "386", ""},
buildTarget{"freebsd", "amd64", ""},
buildTarget{"freebsd", "arm", "6"},
buildTarget{"freebsd", "arm", "7"},
}, buildTargets(ctx))
}
func TestValidGoosGoarchCombos(t *testing.T) {
var platforms = []struct {
os, arch string
}{
{"android", "arm"},
{"darwin", "386"},
{"darwin", "amd64"},
{"dragonfly", "amd64"},
{"freebsd", "386"},
{"freebsd", "amd64"},
{"freebsd", "arm"},
{"linux", "386"},
{"linux", "amd64"},
{"linux", "arm"},
{"linux", "arm64"},
{"linux", "mips"},
{"linux", "mipsle"},
{"linux", "mips64"},
{"linux", "mips64le"},
{"netbsd", "386"},
{"netbsd", "amd64"},
{"netbsd", "arm"},
{"openbsd", "386"},
{"openbsd", "amd64"},
{"plan9", "386"},
{"plan9", "amd64"},
{"solaris", "amd64"},
{"windows", "386"},
{"windows", "amd64"},
}
for _, p := range platforms {
t.Run(fmt.Sprintf("%v %v is valid", p.os, p.arch), func(t *testing.T) {
assert.True(t, valid(buildTarget{p.os, p.arch, ""}))
})
}
}
func TestInvalidGoosGoarchCombos(t *testing.T) {
var platforms = []struct {
os, arch string
}{
{"darwin", "arm"},
{"darwin", "arm64"},
{"windows", "arm"},
{"windows", "arm64"},
{"linux", "ppc64"},
{"linux", "ppc64le"},
{"openbsd", "arm"},
}
for _, p := range platforms {
t.Run(fmt.Sprintf("%v %v is invalid", p.os, p.arch), func(t *testing.T) {
assert.False(t, valid(buildTarget{p.os, p.arch, ""}))
})
}
}

10
pipeline/build/valid_os.go
View File

@ -33,13 +33,3 @@ var valids = []string{
"windows386",
"windowsamd64",
}
func valid(goos, goarch string) bool {
var s = goos + goarch
for _, a := range valids {
if a == s {
return true
}
}
return false
}

64
pipeline/build/valid_os_test.go
View File

@ -1,64 +0,0 @@
package build
import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
)
func TestValid(t *testing.T) {
var platforms = []struct {
os, arch string
}{
{"android", "arm"},
{"darwin", "386"},
{"darwin", "amd64"},
{"dragonfly", "amd64"},
{"freebsd", "386"},
{"freebsd", "amd64"},
{"freebsd", "arm"},
{"linux", "386"},
{"linux", "amd64"},
{"linux", "arm"},
{"linux", "arm64"},
{"linux", "mips"},
{"linux", "mipsle"},
{"linux", "mips64"},
{"linux", "mips64le"},
{"netbsd", "386"},
{"netbsd", "amd64"},
{"netbsd", "arm"},
{"openbsd", "386"},
{"openbsd", "amd64"},
{"plan9", "386"},
{"plan9", "amd64"},
{"solaris", "amd64"},
{"windows", "386"},
{"windows", "amd64"},
}
for _, p := range platforms {
t.Run(fmt.Sprintf("%v %v is valid", p.os, p.arch), func(t *testing.T) {
assert.True(t, valid(p.os, p.arch))
})
}
}
func TestInvalid(t *testing.T) {
var platforms = []struct {
os, arch string
}{
{"darwin", "arm"},
{"darwin", "arm64"},
{"windows", "arm"},
{"windows", "arm64"},
{"linux", "ppc64"},
{"linux", "ppc64le"},
{"openbsd", "arm"},
}
for _, p := range platforms {
t.Run(fmt.Sprintf("%v %v is invalid", p.os, p.arch), func(t *testing.T) {
assert.False(t, valid(p.os, p.arch))
})
}
}