gui module: the plan tab's model, with tests

1 files changed, 221 insertions, 0 deletions

diff --git a/gui/internal/model/plan.go b/gui/internal/model/plan.go
new file mode 100644
index 0000000..607fa29
--- /dev/null
+++ b/gui/internal/model/plan.go
@@ -0,0 +1,221 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// Package model is krino-gui's state and operations: what each tab shows,
+// and what a click does. It holds no GTK, so it can be tested the way the
+// engine's own packages are (GUI design §1.2).
+package model
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"krino/internal/engine"
+	"krino/internal/plan"
+)
+
+// Row is one line of the Plan tab: a file krino would act on, or one it
+// could not decide about.
+type Row struct {
+	Rel      string // the file, relative to the directory's root
+	Steps    []plan.Step
+	Rule     string // the rule that matched first, for the Rule column
+	Warnings []string
+	// Selected is the checkbox. A row that cannot be applied - every step
+	// skipped, or nothing but warnings - is never selected and has no box.
+	Selected bool
+	Actable  bool
+	// Outcome is what applying did to this file: "", "done", "failed: ...",
+	// "declined".
+	Outcome string
+}
+
+// PlanTab is the state of one directory's plan.
+type PlanTab struct {
+	Dir      *engine.Dir
+	Rows     []Row
+	Counts   Counts
+	Warnings []string // directory-level
+	Applied  bool     // this plan has been applied and is now history
+
+	sess *engine.Session
+	dp   *engine.DirPlan
+}
+
+// Counts is the plan's summary line.
+type Counts struct {
+	Scanned, Acting, Excluded, Skipped, Unmatched, Warned int
+}
+
+// Plan locks dir and plans it, returning the tab to show. The lock is held
+// until Apply or Close: what the user sees stays the truth while they
+// choose (GUI design §3).
+func Plan(ctx context.Context, sess *engine.Session, d *engine.Dir) (*PlanTab, error) {
+	dp, err := sess.Plan(ctx, d)
+	if err != nil {
+		return nil, err
+	}
+	t := &PlanTab{Dir: d, sess: sess, dp: dp}
+	t.fill()
+	return t, nil
+}
+
+// fill turns the engine's plan into rows and counts.
+func (t *PlanTab) fill() {
+	r := t.dp.Result
+	t.Warnings = append([]string(nil), r.Warnings...)
+	warnings := map[string][]string{}
+	for _, fms := range [][]engine.FileMatch{r.Matched, r.Unmatched} {
+		for _, fm := range fms {
+			if len(fm.Warnings) > 0 {
+				warnings[fm.File.Rel] = fm.Warnings
+			}
+		}
+	}
+	excluded := 0
+	for _, fm := range r.Matched {
+		if fm.Excluded != "" {
+			excluded++
+		}
+	}
+	t.Rows = nil
+	for _, c := range t.dp.Chains {
+		row := Row{Rel: c.File.Rel, Steps: c.Steps, Warnings: warnings[c.File.Rel]}
+		for _, s := range c.Steps {
+			if s.Skip == "" {
+				row.Actable = true
+			}
+			if row.Rule == "" {
+				row.Rule = s.Rule
+			}
+		}
+		row.Selected = row.Actable
+		if len(c.Steps) > 0 {
+			t.Rows = append(t.Rows, row)
+		}
+		delete(warnings, c.File.Rel)
+	}
+	// Files no rule acted on that still raised a warning: krino could not
+	// decide about them, and they are shown but never selectable.
+	var rest []string
+	for rel := range warnings {
+		rest = append(rest, rel)
+	}
+	sort.Strings(rest)
+	for _, rel := range rest {
+		t.Rows = append(t.Rows, Row{Rel: rel, Warnings: warnings[rel]})
+	}
+	t.Counts = Counts{
+		Scanned:   len(r.Matched) + len(r.Unmatched) + len(r.Skipped),
+		Excluded:  excluded,
+		Skipped:   len(r.Skipped),
+		Unmatched: len(r.Unmatched),
+	}
+	for _, row := range t.Rows {
+		if row.Actable {
+			t.Counts.Acting++
+		}
+		if len(row.Warnings) > 0 {
+			t.Counts.Warned++
+		}
+	}
+}
+
+// SelectAll selects every row that can be applied; SelectNone clears them.
+func (t *PlanTab) SelectAll()  { t.setAll(true) }
+func (t *PlanTab) SelectNone() { t.setAll(false) }
+
+func (t *PlanTab) setAll(on bool) {
+	for i := range t.Rows {
+		t.Rows[i].Selected = on && t.Rows[i].Actable
+	}
+}
+
+// Toggle flips row i's checkbox; a row that cannot be applied stays off.
+func (t *PlanTab) Toggle(i int) {
+	if i < 0 || i >= len(t.Rows) || !t.Rows[i].Actable {
+		return
+	}
+	t.Rows[i].Selected = !t.Rows[i].Selected
+}
+
+// SelectedCount is how many files Apply would act on.
+func (t *PlanTab) SelectedCount() int {
+	n := 0
+	for _, r := range t.Rows {
+		if r.Selected {
+			n++
+		}
+	}
+	return n
+}
+
+// Replace swaps a row's planned steps for the one step the user chose
+// instead - "Trash instead", "Delete permanently instead" - as the terminal
+// review's t and d keys do, and selects it.
+func (t *PlanTab) Replace(i int, kind plan.Kind) error {
+	if i < 0 || i >= len(t.Rows) {
+		return fmt.Errorf("model: no row %d", i)
+	}
+	if kind != plan.Trash && kind != plan.DeletePermanent {
+		return fmt.Errorf("model: %s is not a replacement action", kind)
+	}
+	rel := t.Rows[i].Rel
+	for j, c := range t.dp.Chains {
+		if c.File.Rel != rel {
+			continue
+		}
+		t.dp.Chains[j].Steps = []plan.Step{{
+			Kind:   kind,
+			Rule:   "(review)",
+			Src:    c.File.Path,
+			Reason: "chosen in review",
+		}}
+		t.Rows[i].Steps = t.dp.Chains[j].Steps
+		t.Rows[i].Rule = "(review)"
+		t.Rows[i].Actable = true
+		t.Rows[i].Selected = true
+		return nil
+	}
+	return fmt.Errorf("model: %s is not in this plan", rel)
+}
+
+// Apply acts on the selected files and logs the rest as declined, exactly
+// as choosing per file in the terminal does. Each row then carries its
+// outcome.
+func (t *PlanTab) Apply(ctx context.Context) (*engine.ApplyResult, error) {
+	approved := map[string]bool{}
+	for _, r := range t.Rows {
+		if r.Selected {
+			approved[r.Rel] = true
+		}
+	}
+	res, err := t.sess.Apply(ctx, t.dp, approved)
+	t.Applied = true
+	if res != nil {
+		t.record(res)
+	}
+	return res, err
+}
+
+// record writes each file's outcome onto its row.
+func (t *PlanTab) record(res *engine.ApplyResult) {
+	byRel := map[string]string{}
+	for _, fr := range res.Files {
+		outcome := "done"
+		for _, sr := range fr.Steps {
+			switch sr.Status {
+			case "failed":
+				outcome = "failed: " + sr.Detail
+			case "declined":
+				outcome = "declined"
+			}
+		}
+		byRel[fr.File.Rel] = outcome
+	}
+	for i, r := range t.Rows {
+		if o, ok := byRel[r.Rel]; ok {
+			t.Rows[i].Outcome = o
+		}
+	}
+}