2023-04-19 08:28:09 +03:00
|
|
|
package cli
|
|
|
|
|
|
|
|
import (
|
|
|
|
"io"
|
|
|
|
"os"
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
"github.com/neilotoole/sq/libsq/core/errz"
|
|
|
|
|
|
|
|
"github.com/neilotoole/sq/libsq/core/options"
|
|
|
|
|
|
|
|
"github.com/neilotoole/sq/cli/output/format"
|
|
|
|
|
2023-04-19 08:28:09 +03:00
|
|
|
"github.com/fatih/color"
|
|
|
|
"github.com/mattn/go-colorable"
|
|
|
|
"github.com/neilotoole/sq/cli/flag"
|
|
|
|
"github.com/neilotoole/sq/cli/output"
|
|
|
|
"github.com/neilotoole/sq/cli/output/csvw"
|
|
|
|
"github.com/neilotoole/sq/cli/output/htmlw"
|
|
|
|
"github.com/neilotoole/sq/cli/output/jsonw"
|
|
|
|
"github.com/neilotoole/sq/cli/output/markdownw"
|
|
|
|
"github.com/neilotoole/sq/cli/output/raww"
|
|
|
|
"github.com/neilotoole/sq/cli/output/tablew"
|
|
|
|
"github.com/neilotoole/sq/cli/output/xlsxw"
|
|
|
|
"github.com/neilotoole/sq/cli/output/xmlw"
|
|
|
|
"github.com/neilotoole/sq/cli/output/yamlw"
|
|
|
|
"github.com/spf13/cobra"
|
|
|
|
)
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
var (
|
|
|
|
OptPrintHeader = options.NewBool(
|
|
|
|
"format.header",
|
|
|
|
true,
|
|
|
|
"Controls whether a header row is printed.",
|
|
|
|
"format",
|
|
|
|
)
|
|
|
|
OptOutputFormat = NewFormatOpt(
|
|
|
|
"format",
|
|
|
|
format.Table,
|
|
|
|
"Specify the output format.",
|
|
|
|
"format",
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
2023-04-19 08:28:09 +03:00
|
|
|
// writers is a container for the various output writers.
|
|
|
|
type writers struct {
|
2023-04-22 06:36:32 +03:00
|
|
|
pr *output.Printing
|
2023-04-19 08:28:09 +03:00
|
|
|
|
|
|
|
recordw output.RecordWriter
|
|
|
|
metaw output.MetadataWriter
|
|
|
|
srcw output.SourceWriter
|
|
|
|
errw output.ErrorWriter
|
|
|
|
pingw output.PingWriter
|
|
|
|
versionw output.VersionWriter
|
|
|
|
configw output.ConfigWriter
|
|
|
|
}
|
|
|
|
|
|
|
|
// newWriters returns a writers instance configured per defaults and/or
|
|
|
|
// flags from cmd. The returned out2/errOut2 values may differ
|
|
|
|
// from the out/errOut args (e.g. decorated to support colorization).
|
2023-04-26 18:16:42 +03:00
|
|
|
func newWriters(cmd *cobra.Command, opts options.Options, out, errOut io.Writer,
|
2023-04-19 08:28:09 +03:00
|
|
|
) (w *writers, out2, errOut2 io.Writer) {
|
2023-04-22 06:36:32 +03:00
|
|
|
var pr *output.Printing
|
2023-04-26 18:16:42 +03:00
|
|
|
pr, out2, errOut2 = getPrinting(cmd, opts, out, errOut)
|
2023-04-30 17:18:56 +03:00
|
|
|
log := logFrom(cmd)
|
2023-04-19 08:28:09 +03:00
|
|
|
|
|
|
|
// Package tablew has writer impls for each of the writer interfaces,
|
|
|
|
// so we use its writers as the baseline. Later we check the format
|
|
|
|
// flags and set the various writer fields depending upon which
|
|
|
|
// writers the format implements.
|
|
|
|
w = &writers{
|
2023-04-22 06:36:32 +03:00
|
|
|
pr: pr,
|
|
|
|
recordw: tablew.NewRecordWriter(out2, pr),
|
|
|
|
metaw: tablew.NewMetadataWriter(out2, pr),
|
|
|
|
srcw: tablew.NewSourceWriter(out2, pr),
|
|
|
|
pingw: tablew.NewPingWriter(out2, pr),
|
|
|
|
errw: tablew.NewErrorWriter(errOut2, pr),
|
|
|
|
versionw: tablew.NewVersionWriter(out2, pr),
|
|
|
|
configw: tablew.NewConfigWriter(out2, pr),
|
2023-04-19 08:28:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Invoke getFormat to see if the format was specified
|
|
|
|
// via config or flag.
|
2023-04-26 18:16:42 +03:00
|
|
|
fm := getFormat(cmd, opts)
|
2023-04-19 08:28:09 +03:00
|
|
|
|
2023-04-22 06:36:32 +03:00
|
|
|
//nolint:exhaustive
|
2023-04-26 18:16:42 +03:00
|
|
|
switch fm {
|
2023-04-19 08:28:09 +03:00
|
|
|
default:
|
|
|
|
// No format specified, use JSON
|
2023-04-22 06:36:32 +03:00
|
|
|
w.recordw = jsonw.NewStdRecordWriter(out2, pr)
|
|
|
|
w.metaw = jsonw.NewMetadataWriter(out2, pr)
|
|
|
|
w.srcw = jsonw.NewSourceWriter(out2, pr)
|
|
|
|
w.errw = jsonw.NewErrorWriter(log, errOut2, pr)
|
|
|
|
w.versionw = jsonw.NewVersionWriter(out2, pr)
|
|
|
|
w.pingw = jsonw.NewPingWriter(out2, pr)
|
|
|
|
w.configw = jsonw.NewConfigWriter(out2, pr)
|
2023-04-19 08:28:09 +03:00
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.Table:
|
2023-04-19 08:28:09 +03:00
|
|
|
// Table is the base format, already set above, no need to do anything.
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.TSV:
|
2023-04-22 06:36:32 +03:00
|
|
|
w.recordw = csvw.NewRecordWriter(out2, pr.ShowHeader, csvw.Tab)
|
2023-04-19 08:28:09 +03:00
|
|
|
w.pingw = csvw.NewPingWriter(out2, csvw.Tab)
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.CSV:
|
2023-04-22 06:36:32 +03:00
|
|
|
w.recordw = csvw.NewRecordWriter(out2, pr.ShowHeader, csvw.Comma)
|
2023-04-19 08:28:09 +03:00
|
|
|
w.pingw = csvw.NewPingWriter(out2, csvw.Comma)
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.XML:
|
2023-04-22 06:36:32 +03:00
|
|
|
w.recordw = xmlw.NewRecordWriter(out2, pr)
|
2023-04-19 08:28:09 +03:00
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.XLSX:
|
2023-04-22 06:36:32 +03:00
|
|
|
w.recordw = xlsxw.NewRecordWriter(out2, pr.ShowHeader)
|
2023-04-19 08:28:09 +03:00
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.Raw:
|
2023-04-19 08:28:09 +03:00
|
|
|
w.recordw = raww.NewRecordWriter(out2)
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.HTML:
|
2023-04-19 08:28:09 +03:00
|
|
|
w.recordw = htmlw.NewRecordWriter(out2)
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.Markdown:
|
2023-04-19 08:28:09 +03:00
|
|
|
w.recordw = markdownw.NewRecordWriter(out2)
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.JSONA:
|
2023-04-22 06:36:32 +03:00
|
|
|
w.recordw = jsonw.NewArrayRecordWriter(out2, pr)
|
2023-04-19 08:28:09 +03:00
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.JSONL:
|
2023-04-22 06:36:32 +03:00
|
|
|
w.recordw = jsonw.NewObjectRecordWriter(out2, pr)
|
2023-04-19 08:28:09 +03:00
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
case format.YAML:
|
2023-04-22 06:36:32 +03:00
|
|
|
w.configw = yamlw.NewConfigWriter(out2, pr)
|
|
|
|
w.metaw = yamlw.NewMetadataWriter(out2, pr)
|
2023-04-19 08:28:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return w, out2, errOut2
|
|
|
|
}
|
|
|
|
|
2023-04-22 06:36:32 +03:00
|
|
|
// getPrinting returns a Printing instance and
|
2023-04-19 08:28:09 +03:00
|
|
|
// colorable or non-colorable writers. It is permissible
|
2023-04-26 18:16:42 +03:00
|
|
|
// for the cmd arg to be nil. The caller should use the returned
|
|
|
|
// io.Writer instances instead of the supplied writers, as they
|
|
|
|
// may be decorated for dealing with color, etc.
|
|
|
|
func getPrinting(cmd *cobra.Command, opts options.Options,
|
2023-04-19 08:28:09 +03:00
|
|
|
out, errOut io.Writer,
|
2023-04-22 06:36:32 +03:00
|
|
|
) (pr *output.Printing, out2, errOut2 io.Writer) {
|
|
|
|
pr = output.NewPrinting()
|
2023-04-19 08:28:09 +03:00
|
|
|
|
|
|
|
if cmdFlagChanged(cmd, flag.Pretty) {
|
2023-04-22 06:36:32 +03:00
|
|
|
pr.Pretty, _ = cmd.Flags().GetBool(flag.Pretty)
|
2023-04-19 08:28:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if cmdFlagChanged(cmd, flag.Verbose) {
|
2023-04-22 06:36:32 +03:00
|
|
|
pr.Verbose, _ = cmd.Flags().GetBool(flag.Verbose)
|
2023-04-19 08:28:09 +03:00
|
|
|
}
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
switch {
|
|
|
|
case cmdFlagChanged(cmd, flag.Header):
|
2023-04-22 06:36:32 +03:00
|
|
|
pr.ShowHeader, _ = cmd.Flags().GetBool(flag.Header)
|
2023-04-26 18:16:42 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.NoHeader):
|
|
|
|
b, _ := cmd.Flags().GetBool(flag.NoHeader)
|
|
|
|
pr.ShowHeader = !b
|
|
|
|
case opts != nil:
|
|
|
|
pr.ShowHeader = OptPrintHeader.Get(opts)
|
2023-04-19 08:28:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: Should get this default value from config
|
|
|
|
colorize := true
|
|
|
|
|
|
|
|
if cmdFlagChanged(cmd, flag.Output) {
|
|
|
|
// We're outputting to a file, thus no color.
|
|
|
|
colorize = false
|
|
|
|
} else if cmdFlagChanged(cmd, flag.Monochrome) {
|
|
|
|
if mono, _ := cmd.Flags().GetBool(flag.Monochrome); mono {
|
|
|
|
colorize = false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !colorize {
|
|
|
|
color.NoColor = true // TODO: shouldn't rely on package-level var
|
2023-04-22 06:36:32 +03:00
|
|
|
pr.EnableColor(false)
|
2023-04-19 08:28:09 +03:00
|
|
|
out2 = out
|
|
|
|
errOut2 = errOut
|
2023-04-22 06:36:32 +03:00
|
|
|
return pr, out2, errOut2
|
2023-04-19 08:28:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// We do want to colorize
|
|
|
|
if !isColorTerminal(out) {
|
|
|
|
// But out can't be colorized.
|
|
|
|
color.NoColor = true
|
2023-04-22 06:36:32 +03:00
|
|
|
pr.EnableColor(false)
|
2023-04-19 08:28:09 +03:00
|
|
|
out2, errOut2 = out, errOut
|
2023-04-22 06:36:32 +03:00
|
|
|
return pr, out2, errOut2
|
2023-04-19 08:28:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// out can be colorized.
|
|
|
|
color.NoColor = false
|
2023-04-22 06:36:32 +03:00
|
|
|
pr.EnableColor(true)
|
2023-04-19 08:28:09 +03:00
|
|
|
out2 = colorable.NewColorable(out.(*os.File))
|
|
|
|
|
|
|
|
// Check if we can colorize errOut
|
|
|
|
if isColorTerminal(errOut) {
|
|
|
|
errOut2 = colorable.NewColorable(errOut.(*os.File))
|
|
|
|
} else {
|
|
|
|
// errOut2 can't be colorized, but since we're colorizing
|
|
|
|
// out, we'll apply the non-colorable filter to errOut.
|
|
|
|
errOut2 = colorable.NewNonColorable(errOut)
|
|
|
|
}
|
|
|
|
|
2023-04-22 06:36:32 +03:00
|
|
|
return pr, out2, errOut2
|
2023-04-19 08:28:09 +03:00
|
|
|
}
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
func getFormat(cmd *cobra.Command, defaults options.Options) format.Format {
|
|
|
|
var fm format.Format
|
2023-04-19 08:28:09 +03:00
|
|
|
|
|
|
|
switch {
|
|
|
|
// cascade through the format flags in low-to-high order of precedence.
|
|
|
|
case cmdFlagChanged(cmd, flag.TSV):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.TSV
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.CSV):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.CSV
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.XLSX):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.XLSX
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.XML):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.XML
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.Raw):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.Raw
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.HTML):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.HTML
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.Markdown):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.Markdown
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.Table):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.Table
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.JSONL):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.JSONL
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.JSONA):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.JSONA
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.JSON):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.JSON
|
2023-04-19 08:28:09 +03:00
|
|
|
case cmdFlagChanged(cmd, flag.YAML):
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = format.YAML
|
2023-04-19 08:28:09 +03:00
|
|
|
default:
|
|
|
|
// no format flag, use the config value
|
2023-04-26 18:16:42 +03:00
|
|
|
fm = OptOutputFormat.Get(defaults)
|
|
|
|
}
|
|
|
|
return fm
|
|
|
|
}
|
|
|
|
|
|
|
|
var _ options.Opt = FormatOpt{}
|
|
|
|
|
2023-04-30 17:18:56 +03:00
|
|
|
// NewFormatOpt returns a new FormatOpt instance.
|
2023-04-26 18:16:42 +03:00
|
|
|
func NewFormatOpt(key string, defaultVal format.Format, comment string, tags ...string) FormatOpt {
|
|
|
|
return FormatOpt{key: key, defaultVal: defaultVal, comment: comment, tags: tags}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FormatOpt is an options.Opt for format.Format.
|
|
|
|
type FormatOpt struct {
|
|
|
|
key string
|
|
|
|
comment string
|
|
|
|
defaultVal format.Format
|
|
|
|
tags []string
|
|
|
|
}
|
|
|
|
|
|
|
|
// Tags implements options.Opt.
|
2023-04-30 17:18:56 +03:00
|
|
|
func (op FormatOpt) Tags() []string {
|
|
|
|
return op.tags
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Key implements options.Opt.
|
2023-04-30 17:18:56 +03:00
|
|
|
func (op FormatOpt) Key() string {
|
|
|
|
return op.key
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// String implements options.Opt.
|
2023-04-30 17:18:56 +03:00
|
|
|
func (op FormatOpt) String() string {
|
|
|
|
return op.key
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// IsSet implements options.Opt.
|
2023-04-30 17:18:56 +03:00
|
|
|
func (op FormatOpt) IsSet(o options.Options) bool {
|
|
|
|
if o == nil {
|
2023-04-26 18:16:42 +03:00
|
|
|
return false
|
2023-04-19 08:28:09 +03:00
|
|
|
}
|
2023-04-26 18:16:42 +03:00
|
|
|
|
2023-04-30 17:18:56 +03:00
|
|
|
return o.IsSet(op)
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Process implements options.Processor. It converts matching
|
2023-04-30 17:18:56 +03:00
|
|
|
// string values in o into format.Format. If no match found,
|
2023-04-26 18:16:42 +03:00
|
|
|
// the input arg is returned unchanged. Otherwise, a clone is
|
|
|
|
// returned.
|
2023-04-30 17:18:56 +03:00
|
|
|
func (op FormatOpt) Process(o options.Options) (options.Options, error) {
|
|
|
|
if o == nil {
|
2023-04-26 18:16:42 +03:00
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
|
2023-04-30 17:18:56 +03:00
|
|
|
v, ok := o[op.key]
|
2023-04-26 18:16:42 +03:00
|
|
|
if !ok || v == nil {
|
2023-04-30 17:18:56 +03:00
|
|
|
return o, nil
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// v should be a string
|
2023-05-01 06:59:34 +03:00
|
|
|
switch v := v.(type) {
|
|
|
|
case string:
|
|
|
|
// continue below
|
|
|
|
case format.Format:
|
|
|
|
return o, nil
|
|
|
|
default:
|
|
|
|
return nil, errz.Errorf("option {%s} should be {%T} or {%T} but got {%T}: %v",
|
|
|
|
op.key, format.Format(""), "", v, v)
|
|
|
|
}
|
|
|
|
|
2023-04-26 18:16:42 +03:00
|
|
|
var s string
|
|
|
|
s, ok = v.(string)
|
|
|
|
if !ok {
|
|
|
|
return nil, errz.Errorf("option {%s} should be {%T} but got {%T}: %v",
|
2023-04-30 17:18:56 +03:00
|
|
|
op.key, s, v, v)
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
var f format.Format
|
|
|
|
if err := f.UnmarshalText([]byte(s)); err != nil {
|
2023-05-01 06:59:34 +03:00
|
|
|
return nil, errz.Wrapf(err, "option {%s} is not a valid {%T}", op.key, f)
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
2023-04-30 17:18:56 +03:00
|
|
|
o = o.Clone()
|
|
|
|
o[op.key] = f
|
|
|
|
return o, nil
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
2023-04-30 17:18:56 +03:00
|
|
|
// GetAny implements options.Opt.
|
|
|
|
func (op FormatOpt) GetAny(o options.Options) any {
|
|
|
|
return op.Get(o)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get returns op's value in o. If o is nil, or no value
|
|
|
|
// is set, op's default value is returned.
|
|
|
|
func (op FormatOpt) Get(o options.Options) format.Format {
|
|
|
|
if o == nil {
|
|
|
|
return op.defaultVal
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
2023-04-30 17:18:56 +03:00
|
|
|
v, ok := o[op.key]
|
2023-04-26 18:16:42 +03:00
|
|
|
if !ok {
|
2023-04-30 17:18:56 +03:00
|
|
|
return op.defaultVal
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
var f format.Format
|
|
|
|
f, ok = v.(format.Format)
|
|
|
|
if !ok {
|
2023-04-30 17:18:56 +03:00
|
|
|
return op.defaultVal
|
2023-04-26 18:16:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return f
|
2023-04-19 08:28:09 +03:00
|
|
|
}
|