From 10802158766e4567580c6b9398a08e7a079dbb48 Mon Sep 17 00:00:00 2001 From: Grachev Mikhail Date: Wed, 14 Aug 2019 16:07:00 +0300 Subject: [PATCH] fix: artifact fields not available to flags (#1118) --- internal/builders/golang/build.go | 40 ++++++++++++++------------ internal/builders/golang/build_test.go | 37 ++++++++++++++++++------ 2 files changed, 50 insertions(+), 27 deletions(-) diff --git a/internal/builders/golang/build.go b/internal/builders/golang/build.go index cb9df06e0..e522b3374 100644 --- a/internal/builders/golang/build.go +++ b/internal/builders/golang/build.go @@ -68,26 +68,40 @@ func (*Builder) Build(ctx *context.Context, build config.Build, options api.Opti var env = append(ctx.Env.Strings(), build.Env...) env = append(env, target.Env()...) - flags, err := processFlags(ctx, env, build.Flags, "") + artifact := &artifact.Artifact{ + Type: artifact.Binary, + Path: options.Path, + Name: options.Name, + Goos: target.os, + Goarch: target.arch, + Goarm: target.arm, + Extra: map[string]interface{}{ + "Binary": build.Binary, + "Ext": options.Ext, + "ID": build.ID, + }, + } + + flags, err := processFlags(ctx, artifact, env, build.Flags, "") if err != nil { return err } cmd = append(cmd, flags...) - asmflags, err := processFlags(ctx, env, build.Asmflags, "-asmflags=") + asmflags, err := processFlags(ctx, artifact, env, build.Asmflags, "-asmflags=") if err != nil { return err } cmd = append(cmd, asmflags...) - gcflags, err := processFlags(ctx, env, build.Gcflags, "-gcflags=") + gcflags, err := processFlags(ctx, artifact, env, build.Gcflags, "-gcflags=") if err != nil { return err } cmd = append(cmd, gcflags...) // flag prefix is skipped because ldflags need to output a single string - ldflags, err := processFlags(ctx, env, build.Ldflags, "") + ldflags, err := processFlags(ctx, artifact, env, build.Ldflags, "") if err != nil { return err } @@ -100,26 +114,14 @@ func (*Builder) Build(ctx *context.Context, build config.Build, options api.Opti if err := run(ctx, cmd, env); err != nil { return errors.Wrapf(err, "failed to build for %s", options.Target) } - ctx.Artifacts.Add(&artifact.Artifact{ - Type: artifact.Binary, - Path: options.Path, - Name: options.Name, - Goos: target.os, - Goarch: target.arch, - Goarm: target.arm, - Extra: map[string]interface{}{ - "Binary": build.Binary, - "Ext": options.Ext, - "ID": build.ID, - }, - }) + ctx.Artifacts.Add(artifact) return nil } -func processFlags(ctx *context.Context, env, flags []string, flagPrefix string) ([]string, error) { +func processFlags(ctx *context.Context, a *artifact.Artifact, env, flags []string, flagPrefix string) ([]string, error) { processed := make([]string, 0, len(flags)) for _, rawFlag := range flags { - flag, err := tmpl.New(ctx).WithEnvS(env).Apply(rawFlag) + flag, err := tmpl.New(ctx).WithEnvS(env).WithArtifact(a, map[string]string{}).Apply(rawFlag) if err != nil { return nil, err } diff --git a/internal/builders/golang/build_test.go b/internal/builders/golang/build_test.go index 572d412fe..45cf80345 100644 --- a/internal/builders/golang/build_test.go +++ b/internal/builders/golang/build_test.go @@ -404,8 +404,9 @@ func TestLdFlagsFullTemplate(t *testing.T) { Version: "1.2.3", Env: map[string]string{"FOO": "123"}, } - flags, err := tmpl.New(ctx). - Apply(`-s -w -X main.version={{.Version}} -X main.tag={{.Tag}} -X main.date={{.Date}} -X main.commit={{.Commit}} -X "main.foo={{.Env.FOO}}" -X main.time={{ time "20060102" }}`) + var artifact = &artifact.Artifact{Goarch: "amd64"} + flags, err := tmpl.New(ctx).WithArtifact(artifact, map[string]string{}). + Apply(`-s -w -X main.version={{.Version}} -X main.tag={{.Tag}} -X main.date={{.Date}} -X main.commit={{.Commit}} -X "main.foo={{.Env.FOO}}" -X main.time={{ time "20060102" }} -X main.arch={{.Arch}}`) assert.NoError(t, err) assert.Contains(t, flags, "-s -w") assert.Contains(t, flags, "-X main.version=1.2.3") @@ -414,6 +415,7 @@ func TestLdFlagsFullTemplate(t *testing.T) { assert.Contains(t, flags, fmt.Sprintf("-X main.date=%d", time.Now().Year())) assert.Contains(t, flags, fmt.Sprintf("-X main.time=%d", time.Now().Year())) assert.Contains(t, flags, `-X "main.foo=123"`) + assert.Contains(t, flags, `-X main.arch=amd64`) } func TestInvalidTemplate(t *testing.T) { @@ -437,19 +439,39 @@ func TestProcessFlags(t *testing.T) { } ctx.Git.CurrentTag = "5.6.7" + var artifact = &artifact.Artifact{ + Name: "name", + Goos: "darwin", + Goarch: "amd64", + Goarm: "7", + Extra: map[string]interface{}{ + "Binary": "binary", + }, + } + var source = []string{ - "{{.Version}}", "flag", + "{{.Version}}", + "{{.Os}}", + "{{.Arch}}", + "{{.Arm}}", + "{{.Binary}}", + "{{.ArtifactName}}", } var expected = []string{ - "-testflag=1.2.3", "-testflag=flag", + "-testflag=1.2.3", + "-testflag=darwin", + "-testflag=amd64", + "-testflag=7", + "-testflag=binary", + "-testflag=name", } - flags, err := processFlags(ctx, []string{}, source, "-testflag=") + flags, err := processFlags(ctx, artifact, []string{}, source, "-testflag=") assert.NoError(t, err) - assert.Len(t, flags, 2) + assert.Len(t, flags, 7) assert.Equal(t, expected, flags) } @@ -462,7 +484,7 @@ func TestProcessFlagsInvalid(t *testing.T) { var expected = `template: tmpl:1: unexpected "}" in operand` - flags, err := processFlags(ctx, []string{}, source, "-testflag=") + flags, err := processFlags(ctx, &artifact.Artifact{}, []string{}, source, "-testflag=") assert.EqualError(t, err, expected) assert.Nil(t, flags) } @@ -478,7 +500,6 @@ func TestJoinLdFlags(t *testing.T) { for _, test := range tests { joinedLdFlags := joinLdFlags(test.input) - assert.Equal(t, joinedLdFlags, test.output) } }