result

type CSVFormatter ¶

type CSVFormatter struct{}

CSVFormatter renders a slice of rows as RFC 4180 comma-separated values.

The shape of value drives header inference:

• If value implements HasHeaders, its Headers() result is the column order.
• Otherwise, if value is a slice/array of structs, the struct fields (in declaration order, with `csv:"name"` overrides and `csv:"-"` skips) are the columns.
• Otherwise, if value is a slice/array of maps, the union of map keys (sorted alphabetically) is the columns.
• Otherwise, [Format] returns an error.

Cell values are rendered via fmt.Sprint, which honors fmt.Stringer for custom types and produces reasonable defaults for numbers, bools, time.Time, and nil. Quoting is handled by encoding/csv per RFC 4180. Empty input renders no bytes (no header row).

func (CSVFormatter) Format(value any, w io.Writer) error

type FieldFilter ¶

type FieldFilter struct {
	// contains filtered or unexported fields
}

FieldFilter narrows a slice of structs/maps to those whose named field matches a target value. The expression form is `field=value`, mirroring `gh`'s `--filter` flag and `kubectl`'s field selectors. Multiple expressions AND together — every expression must match for a row to pass.

Comparison is done after rendering both sides through fmt.Sprint, so primitives, fmt.Stringer implementations, and time.Time values all compare correctly. Numeric strings ("42") and numeric values (42) compare equal — the expression dialect is string-typed.

Construct via NewFieldFilter; surface parse errors directly to the user.

func NewFieldFilter(exprs ...string) (*FieldFilter, error)

func (f *FieldFilter) Apply(value any) (any, error)

type Filter ¶

type Filter interface {

	// Apply returns a (possibly modified) value, or an error if the filter expression is invalid
	// for the input shape.
	Apply(value any) (any, error)
}

Filter is the selection stage of the result pipeline. Implementations narrow, transform, or pass-through the value before it reaches the formatter.

func FilterByExprs(fieldExprs []string, jqExpr string) (Filter, error)

type Formatter ¶

type Formatter interface {

	// Format renders value to w in the implementation's format (JSON, YAML, CSV, template, etc.).
	Format(value any, w io.Writer) error
}

Formatter is the rendering stage of the result pipeline. Implementations encode the (filtered) value as bytes on the writer.

The writer parameter is typed as io.Writer rather than sink.Sink because formatters operate on a byte stream — they don't need TTY-awareness, Close lifecycle, or any other Sink-specific concerns. Pipeline.Emit passes its sink.Sink (which is an io.Writer) to Format directly; stdlib encoders (encoding/json, gopkg.in/yaml.v3, etc.) plug in without adapter shims.

func FormatterByName(name, templateText string) (Formatter, error)

type HasHeaders ¶

type HasHeaders interface {

	// Headers returns the column order to use when rendering the receiver as CSV.
	Headers() []string
}

HasHeaders is the opt-in interface that overrides automatic header inference. Implementations are typically named-slice types whose row shape doesn't lend itself to reflection (e.g., heterogeneous row content keyed by symbolic names).

type JQFilter ¶

type JQFilter struct {
	// contains filtered or unexported fields
}

JQFilter applies a jq expression to the value via github.com/itchyny/gojq.

The input is normalized to gojq's native shape (map[string]any / []any / primitives) by round-tripping through encoding/json. This costs a serialization pass per Apply but lets callers hand any JSON-serializable Go value to the filter without first converting it.

The expression is parsed and compiled at construction; parse errors surface there. Execution errors from gojq propagate through Apply. Single-result expressions return the unwrapped value; multi-result expressions (jq's `,` operator, `..` recursive descent, etc.) collect into a slice.

func NewJQFilter(expression string) (*JQFilter, error)

func (f *JQFilter) Apply(value any) (any, error)

type JSONFormatter ¶

type JSONFormatter struct{}

JSONFormatter renders the value as indented JSON. Two-space indentation; no HTML escaping concerns (the stream is for tooling consumption, not browser embedding).

func (JSONFormatter) Format(value any, w io.Writer) error

type NoOpFilter ¶

type NoOpFilter struct{}

NoOpFilter is the pass-through Filter; Apply returns its argument unchanged.

func (NoOpFilter) Apply(value any) (any, error)

type Pipeline ¶

type Pipeline struct {
	// contains filtered or unexported fields
}

Pipeline composes a Filter and a Formatter against a sink.Sink. Callers Emit values; the Pipeline applies the filter, hands the result to the formatter, and the formatter writes through the sink.

All fields are unexported and set at construction by NewPipeline; the value is immutable from the caller's perspective. To suppress all output, construct with sink.Discard as the sink.

func NewPipeline(filter Filter, formatter Formatter, s sink.Sink) *Pipeline

func (p *Pipeline) Emit(value any) error

type TemplateFormatter ¶

type TemplateFormatter struct {
	// contains filtered or unexported fields
}

TemplateFormatter renders the value through a text/template.Template. The template text is supplied at construction; the value passed to [Format] is the template's `.` (dot) data binding.

Construct via NewTemplateFormatter. The template is parsed once at construction; parse errors surface there rather than per-Emit. Callers passing user-supplied template text should surface parse errors directly to the user (no silent fallback).

func NewTemplateFormatter(text string) (*TemplateFormatter, error)

func NewTemplateFormatterFromTemplate(tmpl *template.Template) *TemplateFormatter

func (t *TemplateFormatter) Format(value any, w io.Writer) error

type YAMLFormatter ¶

type YAMLFormatter struct{}

YAMLFormatter renders the value as indented YAML. Two-space indentation; latest stable yaml.v3 from go-yaml.

func (YAMLFormatter) Format(value any, w io.Writer) (err error)