From db743a4b3d4a801ea8af26f6eb46799c80e1b879 Mon Sep 17 00:00:00 2001 From: Eric Rakestraw Date: Sat, 21 Nov 2026 04:07:57 +0000 Subject: [PATCH] Render focused inspection values safely --- docs/roadmap/implementation.md | 4 +- facade_inspection_view_test.go | 62 ++++++++++++++++++++++++++++++ inspection_view.go | 5 +++ internal/engine/inspection_view.go | 17 ++++++++ 4 files changed, 87 insertions(+), 1 deletion(-) diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index a23cde3..9f005a9 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -1,6 +1,6 @@ # Implementation plan: typed result values and focused inspection -Status: implementation in progress; Stages 1–3 complete. +Status: implementation in progress; Stages 1–4 complete. ## Scope and working instructions @@ -179,6 +179,8 @@ exist in either effective or historical data. ## Stage 4 — Render focused effective output with original sensitivity +**Complete.** + Add `func (i Inspection) WriteEffective(output io.Writer) error` and a scoped engine rendering operation using the saved final tree. diff --git a/facade_inspection_view_test.go b/facade_inspection_view_test.go index 4cfd897..e7ce21a 100644 --- a/facade_inspection_view_test.go +++ b/facade_inspection_view_test.go @@ -2,7 +2,9 @@ package configkit_test import ( "bytes" + "errors" "reflect" + "strings" "testing" configkit "go.maximumdirect.net/configkit" @@ -61,6 +63,66 @@ func TestInspectionViewScopeAndQueries(t *testing.T) { } } +type viewFailWriter struct{} + +func (viewFailWriter) Write([]byte) (int, error) { return 0, errors.New("write failed") } + +func TestInspectionViewWriteEffective(t *testing.T) { + options := configkit.Options[map[string]any]{Definition: configkit.Definition[map[string]any]{ + Sensitive: func(path configkit.Path) bool { return path.String() == "/private" || path.String() == "/nested/token" }, + Resolve: func(current *map[string]any, resolution *configkit.Resolution) error { + delete(*current, "removed") + resolution.RecordNormalization(configkit.Keys("removed"), "remove") + return nil + }, + }} + result, err := configkit.Load(configkit.Bytes("view.yml", []byte("private: {child: canary-private}\nnested: {token: canary-token, name: public}\nitems: [zero, one]\n'0': numeric\n'null': null\nremoved: earlier\n")), options) + if err != nil { + t.Fatal(err) + } + for _, tc := range []struct { + path configkit.Path + contains string + absent string + fails bool + }{ + {configkit.Path{}, "public", "canary-token", false}, + {configkit.Keys("nested"), "public", "canary-token", false}, + {configkit.Keys("private", "child"), "REDACTED", "canary-private", false}, + {configkit.Keys("items"), "one", "", false}, + {configkit.Keys("items").Index(1), "one", "", false}, + {configkit.Path{}.Index(0), "numeric", "", false}, + {configkit.Keys("null"), "null", "", false}, + {configkit.Keys("removed"), "", "", true}, + {configkit.Keys("missing"), "", "", true}, + } { + view, ok := result.InspectSubtree(tc.path) + if !ok { + t.Fatal("view unavailable") + } + var out bytes.Buffer + err := view.WriteEffective(&out) + if (err != nil) != tc.fails || (tc.fails && out.Len() != 0) || (tc.contains != "" && !strings.Contains(out.String(), tc.contains)) || (tc.absent != "" && strings.Contains(out.String(), tc.absent)) { + t.Errorf("%s: %q, %v", tc.path.String(), out.String(), err) + } + } + view, _ := result.InspectSubtree(configkit.Keys("nested")) + result.Config["nested"] = "changed" + var out bytes.Buffer + if err := view.WriteEffective(&out); err != nil || !strings.Contains(out.String(), "public") { + t.Fatalf("frozen output = %q, %v", out.String(), err) + } + if err := view.WriteEffective(viewFailWriter{}); err == nil { + t.Fatal("writer error lost") + } + if err := view.WriteEffective(nil); err == nil { + t.Fatal("nil writer accepted") + } + if err := (configkit.Inspection{}).WriteEffective(&bytes.Buffer{}); err == nil { + t.Fatal("zero view accepted") + } +} + func TestInspectionViewUnavailable(t *testing.T) { var result *configkit.Result[map[string]any] if _, ok := result.InspectSubtree(configkit.Path{}); ok { diff --git a/inspection_view.go b/inspection_view.go index 430cac7..139a514 100644 --- a/inspection_view.go +++ b/inspection_view.go @@ -34,6 +34,11 @@ func (i Inspection) HistoricalPaths() []Path { return paths } +// WriteEffective renders the saved value at the reporting scope with its +// original sensitivity. Unavailable values and nil writers return an error; +// writer errors can leave partial output. +func (i Inspection) WriteEffective(output io.Writer) error { return i.view.WriteEffective(output) } + // Sources returns the full detached source catalog. func (i Inspection) Sources() []SourceInfo { values := i.view.Inspection().Sources() diff --git a/internal/engine/inspection_view.go b/internal/engine/inspection_view.go index 1b53324..d739a6d 100644 --- a/internal/engine/inspection_view.go +++ b/internal/engine/inspection_view.go @@ -1,5 +1,11 @@ package engine +import ( + "io" + + yamladapter "go.maximumdirect.net/configkit/internal/yaml" +) + // InspectionView borrows an inspection and selects a canonical reporting scope. type InspectionView struct { inspection *Inspection @@ -19,6 +25,17 @@ func NewInspectionView(inspection *Inspection, scope Path) (InspectionView, bool func (v InspectionView) Inspection() *Inspection { return v.inspection } +func (v InspectionView) WriteEffective(output io.Writer) error { + if v.inspection == nil || v.inspection.final == nil || output == nil { + return errEffectiveUnavailable + } + node, ok := documentAtPathWithLookup(v.inspection.final, v.scope, v.inspection.documentLookup()) + if !ok { + return errEffectiveUnavailable + } + return yamladapter.Write(output, redactedDocument(node, v.inspection.secrets, v.scope)) +} + func (v InspectionView) HistoricalPaths() []Path { if v.inspection == nil { return nil