// Package filter parses the query language shared by the TUI and web UI. // // A query is a whitespace separated list of terms, all of which must match: // // foo substring of link, target, via or command (case-insensitive) // /re/ regular expression over the same fields (no spaces; use \s) // -term negates any term // kind:K indirect, profile, direct, dangling, runtime (comma separated) // owner:U owner name or uid; "me" is the current user // under:/path link starts with /path // older:30d modified more than 30 days ago (s, m, h, d, w, y) // newer:2h modified less than 2 hours ago // size>500M closure size bigger than 500 MiB (K, M, G, T; also <) // is:protected protected roots; is:current for current generations // is:hidden nix cache roots (~/.cache/nix/...), shown only when asked for package filter import ( "fmt" "os/user" "regexp" "sort" "strconv" "strings" "time" "github.com/illustris/i-am-gcroot/internal/roots" ) type pred func(r *roots.Root, now time.Time) bool type Query struct { Raw string preds []pred // ShowHidden is set when the query mentions is:hidden, which would // otherwise never match because hidden roots are dropped first. ShowHidden bool } func Parse(q string) (*Query, error) { out := &Query{Raw: q} for _, tok := range strings.Fields(q) { neg := false if strings.HasPrefix(tok, "-") && len(tok) > 1 { neg, tok = true, tok[1:] } p, err := parseTerm(tok) if err != nil { return nil, err } if tok == "is:hidden" { out.ShowHidden = true } if neg { inner := p p = func(r *roots.Root, now time.Time) bool { return !inner(r, now) } } out.preds = append(out.preds, p) } return out, nil } func haystack(r *roots.Root) string { return r.Link + "\x00" + r.Target + "\x00" + r.Via + "\x00" + r.Command } func parseTerm(tok string) (pred, error) { if isRegex(tok) { re, err := regexp.Compile("(?i)" + tok[1:len(tok)-1]) if err != nil { return nil, fmt.Errorf("bad regex %s: %w", tok, err) } return func(r *roots.Root, _ time.Time) bool { return re.MatchString(haystack(r)) }, nil } if strings.HasPrefix(tok, "size>") || strings.HasPrefix(tok, "size<") { n, err := ParseSize(tok[5:]) if err != nil { return nil, err } if tok[4] == '>' { return func(r *roots.Root, _ time.Time) bool { return r.ClosureSize > n }, nil } return func(r *roots.Root, _ time.Time) bool { return r.ClosureSize >= 0 && r.ClosureSize < n }, nil } key, val, ok := strings.Cut(tok, ":") if ok && val != "" { switch key { case "kind", "k": kinds := map[roots.Kind]bool{} for _, k := range strings.Split(val, ",") { kk, err := ParseKind(k) if err != nil { return nil, err } kinds[kk] = true } return func(r *roots.Root, _ time.Time) bool { return kinds[r.Kind] }, nil case "owner", "user": if val == "me" { if u, err := user.Current(); err == nil { val = u.Username } } return func(r *roots.Root, _ time.Time) bool { return r.Owner == val || strconv.Itoa(r.UID) == val }, nil case "under", "in": return func(r *roots.Root, _ time.Time) bool { return strings.HasPrefix(r.Link, val) }, nil case "older", "newer": d, err := ParseDuration(val) if err != nil { return nil, err } if key == "older" { return func(r *roots.Root, now time.Time) bool { return !r.ModTime.IsZero() && now.Sub(r.ModTime) > d }, nil } return func(r *roots.Root, now time.Time) bool { return now.Sub(r.ModTime) < d }, nil case "is": switch val { case "protected": return func(r *roots.Root, _ time.Time) bool { return r.Protected }, nil case "current": return func(r *roots.Root, _ time.Time) bool { return r.Current }, nil case "dangling": return func(r *roots.Root, _ time.Time) bool { return r.Kind == roots.KindDangling }, nil case "hidden": return func(r *roots.Root, _ time.Time) bool { return r.Hidden }, nil } return nil, fmt.Errorf("unknown is:%s (protected, current, dangling, hidden)", val) } } lower := strings.ToLower(tok) return func(r *roots.Root, _ time.Time) bool { return strings.Contains(strings.ToLower(haystack(r)), lower) }, nil } // isRegex distinguishes /re/ from a plain path like /tmp/foo, which is // matched as a substring. func isRegex(tok string) bool { return len(tok) > 2 && tok[0] == '/' && tok[len(tok)-1] == '/' && strings.Count(tok, "/") == 2 } func ParseKind(s string) (roots.Kind, error) { for _, k := range roots.AllKinds { if strings.HasPrefix(string(k), s) && s != "" { return k, nil } } return "", fmt.Errorf("unknown kind %q", s) } func ParseDuration(s string) (time.Duration, error) { if len(s) < 2 { return 0, fmt.Errorf("bad duration %q", s) } n, err := strconv.ParseFloat(s[:len(s)-1], 64) if err != nil { return 0, fmt.Errorf("bad duration %q", s) } unit := map[byte]time.Duration{ 's': time.Second, 'm': time.Minute, 'h': time.Hour, 'd': 24 * time.Hour, 'w': 7 * 24 * time.Hour, 'y': 365 * 24 * time.Hour, }[s[len(s)-1]] if unit == 0 { return 0, fmt.Errorf("bad duration unit in %q (s, m, h, d, w, y)", s) } return time.Duration(n * float64(unit)), nil } func ParseSize(s string) (int64, error) { s = strings.TrimSuffix(strings.TrimSuffix(strings.ToUpper(s), "B"), "I") mult := int64(1) if s != "" { switch s[len(s)-1] { case 'K': mult = 1 << 10 case 'M': mult = 1 << 20 case 'G': mult = 1 << 30 case 'T': mult = 1 << 40 } if mult > 1 { s = s[:len(s)-1] } } n, err := strconv.ParseFloat(s, 64) if err != nil { return 0, fmt.Errorf("bad size %q", s) } return int64(n * float64(mult)), nil } func (q *Query) Match(r *roots.Root, now time.Time) bool { for _, p := range q.preds { if !p(r, now) { return false } } return true } type SortKey int const ( SortLink SortKey = iota SortAge SortSize SortTarget SortKind ) var SortNames = []string{"link", "age", "size", "target", "kind"} func (k SortKey) String() string { return SortNames[k] } func ParseSort(s string) SortKey { for i, n := range SortNames { if n == s { return SortKey(i) } } return SortLink } // Apply filters by query and kind set (nil means all kinds) and sorts the // result. Hidden roots are dropped unless showHidden or the query asks for // them. func Apply(rs []roots.Root, q *Query, kinds map[roots.Kind]bool, showHidden bool, key SortKey, desc bool) []roots.Root { showHidden = showHidden || (q != nil && q.ShowHidden) now := time.Now() out := make([]roots.Root, 0, len(rs)) for i := range rs { r := &rs[i] if kinds != nil && !kinds[r.Kind] { continue } if r.Hidden && !showHidden { continue } if q != nil && !q.Match(r, now) { continue } out = append(out, *r) } less := func(a, b *roots.Root) bool { switch key { case SortAge: // "ascending" age means newest first return a.ModTime.After(b.ModTime) case SortSize: return a.ClosureSize < b.ClosureSize case SortTarget: return a.TargetName() < b.TargetName() case SortKind: if a.Kind != b.Kind { return a.Kind < b.Kind } } return a.Link < b.Link } sort.SliceStable(out, func(i, j int) bool { if desc { return less(&out[j], &out[i]) } return less(&out[i], &out[j]) }) return out } func HumanSize(n int64) string { switch { case n == -1: return "..." case n < 0: return "-" case n < 1<<10: return fmt.Sprintf("%dB", n) case n < 1<<20: return fmt.Sprintf("%.1fK", float64(n)/(1<<10)) case n < 1<<30: return fmt.Sprintf("%.1fM", float64(n)/(1<<20)) case n < 1<<40: return fmt.Sprintf("%.1fG", float64(n)/(1<<30)) } return fmt.Sprintf("%.1fT", float64(n)/(1<<40)) } func HumanAge(t time.Time, now time.Time) string { if t.IsZero() { return "-" } d := now.Sub(t) switch { case d < time.Minute: return fmt.Sprintf("%ds", int(d.Seconds())) case d < time.Hour: return fmt.Sprintf("%dm", int(d.Minutes())) case d < 48*time.Hour: return fmt.Sprintf("%dh", int(d.Hours())) case d < 365*24*time.Hour: return fmt.Sprintf("%dd", int(d.Hours()/24)) } return fmt.Sprintf("%.1fy", d.Hours()/24/365) }