-
Notifications
You must be signed in to change notification settings - Fork 3
/
outputopts.go
98 lines (85 loc) · 2.12 KB
/
outputopts.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: MPL-2.0
package commands
import (
"bytes"
"encoding/json"
"flag"
"fmt"
"io"
"os"
"strings"
"github.com/hashicorp/actions-go-build/internal/log"
"github.com/hashicorp/actions-go-build/pkg/crt"
)
type output struct {
logOpts
jsonStdErr bool
json bool
}
func (p *output) ReadEnv() error {
// Write result to stderr by default if not quiet and either verbose or term.
p.jsonStdErr = !p.logOpts.quietFlag && (p.logOpts.verboseFlag || log.IsVerbose())
return nil
}
func (p *output) Flags(fs *flag.FlagSet) {
p.logOpts.Flags(fs)
p.ownFlags(fs)
}
func (p *output) ownFlags(fs *flag.FlagSet) {
fs.BoolVar(&p.json, "json", p.json, "print the result json to stdout")
}
type Result interface {
Error() error
IsFromCache() bool
}
func (p *output) result(what string, r Result) error {
// For all failure cases just return an error, which
// will always be shown to the user.
if dumped, err := p.maybeDumpJSON(r); err != nil {
return err
} else if dumped {
return r.Error()
}
var cached string
if r.IsFromCache() {
cached = fmt.Sprintf(" (cached)")
}
if err := r.Error(); err != nil {
return fmt.Errorf("%s failed%s: %w", what, cached, err)
}
// For the success case, log immediately.
p.loud("%s succeeded%s; use the -json flag to see the full result.", what, cached)
return nil
}
func (p *output) maybeDumpJSON(v any) (bool, error) {
if p.json {
return true, dumpJSON(os.Stdout, v)
}
if p.jsonStdErr {
return true, dumpJSON(os.Stderr, v)
}
return false, nil
}
func (p *output) productInfo(product crt.Product) error {
if dumped, err := p.maybeDumpJSON(product); dumped || err != nil {
return err
}
buf := &bytes.Buffer{}
if err := dumpJSON(buf, product); err != nil {
return err
}
s := buf.String()
s = strings.ReplaceAll(s, `",`, "")
s = strings.ReplaceAll(s, `"`, "")
s = strings.ReplaceAll(s, `},`, "")
s = strings.ReplaceAll(s, `}`, "")
s = strings.ReplaceAll(s, `{`, "")
_, err := fmt.Fprint(os.Stdout, s)
return err
}
func dumpJSON(w io.Writer, v any) error {
e := json.NewEncoder(w)
e.SetIndent("", " ")
return e.Encode(v)
}