filter

type BoolFilter ¶

type BoolFilter struct {
	Field string
	Value *bool // nil = all, true = enabled only, false = disabled only
}

BoolFilter filters by boolean field.

func NewBoolFilter(field string, value *bool) *BoolFilter

func (f *BoolFilter) Apply(data interface{}) (interface{}, error)

type Chain ¶

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

Chain combines multiple filters (AND logic).

func NewChain(filters ...Filter) *Chain

func (c *Chain) Apply(data interface{}) (interface{}, error)

type ColumnValueFilter ¶

type ColumnValueFilter struct {
	Column string
	Value  string
}

ColumnValueFilter filters rows by column value.

func NewColumnFilter(column, value string) *ColumnValueFilter

func (f *ColumnValueFilter) Apply(data interface{}) (interface{}, error)

type Filter ¶

type Filter interface {
	Apply(data interface{}) (interface{}, error)
}

Filter interface for composability.

type GlobFilter ¶

type GlobFilter struct {
	Field   string
	Pattern string
}

GlobFilter matches patterns (e.g., "plat-*-dev").

func NewGlobFilter(field, pattern string) (*GlobFilter, error)

func (f *GlobFilter) Apply(data interface{}) (interface{}, error)

type LabelFilter ¶ added in v1.223.0

type LabelFilter struct {
	Field  string
	Labels map[string]string
}

LabelFilter filters rows whose Field (map[string]string) matches every key=value pair in Labels (AND).

func NewLabelFilter(field string, filterLabels map[string]string) *LabelFilter

func (f *LabelFilter) Apply(data interface{}) (interface{}, error)

type PredicateFilter ¶ added in v1.225.0

type PredicateFilter struct {
	// Name identifies the filter in debugging output.
	Name string
	// Predicate reports whether a row is kept. A nil predicate keeps every row.
	Predicate func(map[string]any) bool
}

PredicateFilter keeps rows satisfying an arbitrary predicate. Used for selections computed outside the row data itself (e.g. dependency-closure membership), where no single field comparison can express the filter.

func NewPredicateFilter(name string, predicate func(map[string]any) bool) *PredicateFilter

func (f *PredicateFilter) Apply(data interface{}) (interface{}, error)

type TagFilter ¶ added in v1.223.0

type TagFilter struct {
	Field string
	Tags  []string
}

TagFilter filters rows whose Field ([]string) matches any of Tags (OR).

func NewTagFilter(field string, filterTags []string) *TagFilter

func (f *TagFilter) Apply(data interface{}) (interface{}, error)

type YQPredicateFilter ¶ added in v1.219.0

type YQPredicateFilter struct {
	Expr        string
	AtmosConfig *schema.AtmosConfiguration
}

YQPredicateFilter keeps rows where the YQ expression evaluates to a truthy value. The expression is evaluated once per row against the row's own map (so users write paths like `.vars.region`, not `.<stack>.vars.region`).

Truthy semantics mirror YAML/JSON intuition rather than yq's internal boolean operators: `true` is truthy; `false`, `nil`, and empty strings/maps/slices are falsy; non-empty scalars/maps/slices are truthy.

Errors evaluating the expression against a single row are propagated up so the user sees an invalid-expression diagnostic instead of a silent empty result — yq syntax errors surface on the first row.

func NewYQPredicateFilter(expr string, atmosConfig *schema.AtmosConfiguration) (*YQPredicateFilter, error)

func (f *YQPredicateFilter) Apply(data interface{}) (interface{}, error)

type YQProjector ¶ added in v1.219.0

type YQProjector struct {
	Expr        string
	AtmosConfig *schema.AtmosConfiguration
}

YQProjector replaces each row with the YQ expression result. Used to wire `--query` on commands like `atmos list instances`.

When the expression returns a map, that map becomes the new row (its keys are addressable as column templates). When it returns a scalar, the row is rewritten to a single "value" column. When the expression returns nil for a row, that row is dropped.

func NewYQProjector(expr string, atmosConfig *schema.AtmosConfiguration) (*YQProjector, error)

func (p *YQProjector) Apply(data interface{}) (interface{}, error)