fix: artifact fields not available to flags (#1118)

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{
+	ctx.Artifacts.Add(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,
-		},
-	})
 	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
 		}

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).
+	var artifact = &artifact.Artifact{Goarch: "amd64"}
-		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" }}`)
+	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)
 	}
 }