feat: `SnapFunc` function and general cleanup/improvement

__snapshots__/test_accept.snap

···
 ---
-version: 0.1.0
 test_name: TestAccept
+file_path: 
+func_name: 
 ---
 new content to accept

__snapshots__/test_map.snap

···
+---
+test_name: TestMap
+file_path: /home/patrick/projects/freeze/freeze.go
+func_name: 
+---
+map[string]interface{}{
+ "foo": "bar",
+}

__snapshots__/test_map.snap.new

···
----
-version: 0.1.0
-test_name: TestMap
----
-map[string]interface{}{
- "foo": "bar",
-}

__snapshots__/test_snap_custom_type.snap

···
+---
+test_name: TestSnapCustomType
+file_path: /home/patrick/projects/freeze/freeze.go
+func_name: 
+---
+freeze_test.CustomStruct{
+ Name: "Alice",
+ Age: 30,
+}

__snapshots__/test_snap_custom_type.snap.new

···
----
-version: 0.1.0
-test_name: TestSnapCustomType
----
-freeze_test.CustomStruct{
- Name: "Alice",
- Age: 30,
-}

__snapshots__/test_snap_func.snap

···
+---
+test_name: TestSnapFunc
+file_path: /home/patrick/projects/freeze/freeze_test.go
+func_name: testHelperFunction
+---
+"helper result"

__snapshots__/test_snap_func_another_helper.snap

···
+---
+test_name: TestSnapFuncAnotherHelper
+file_path: /home/patrick/projects/freeze/freeze_test.go
+func_name: calculateSomething
+---
+10

__snapshots__/test_snap_multiple.snap.new __snapshots__/test_snap_multiple.snap

···
 ---
-version: 0.1.0
 test_name: TestSnapMultiple
+file_path: /home/patrick/projects/freeze/freeze.go
+func_name: 
 ---
 "value1"
 "value2"

__snapshots__/test_snap_string.snap

···
+---
+test_name: TestSnapString
+file_path: /home/patrick/projects/freeze/freeze.go
+func_name: 
+---
+hello world

__snapshots__/test_snap_string.snap.new

···
----
-version: 0.1.0
-test_name: TestSnapString
----
-hello world

api.go

···
 	return api.NewSnapshotBox(snap)
 }
 
-func DiffSnapshotBox(old, new *Snapshot) string {
-	return api.DiffSnapshotBox(old, new)
-}
-
-func Red(s string) string {
-	return api.Red(s)
-}
-
-func Green(s string) string {
-	return api.Green(s)
-}
-
-func Yellow(s string) string {
-	return api.Yellow(s)
-}
-
-func Blue(s string) string {
-	return api.Blue(s)
-}
-
-func Gray(s string) string {
-	return api.Gray(s)
-}
-
-func Bold(s string) string {
-	return api.Bold(s)
-}
-
-func TerminalWidth() int {
-	return api.TerminalWidth()
-}
-
-func ClearScreen() {
-	api.ClearScreen()
+func NewSnapshotBoxFunc(snap *Snapshot) string {
+	return api.NewSnapshotBoxFunc(snap)
 }
 
-func ClearLine() {
-	api.ClearLine()
+func DiffSnapshotBox(old, new *Snapshot) string {
+	return api.DiffSnapshotBox(old, new)
 }

freeze.go

···
 
 import (
 	"fmt"
+	"runtime"
 
 	"github.com/kortschak/utter"
 	"github.com/ptdewey/freeze/internal/diff"
···
 	"github.com/ptdewey/freeze/internal/pretty"
 	"github.com/ptdewey/freeze/internal/review"
 )
-
-const version = "0.1.0"
 
 // TODO: probably make this (and other things) configurable
 func init() {
···
 	snapWithTitle(t, title, content)
 }
 
+func SnapFunc(t testingT, values ...any) {
+	t.Helper()
+	content := formatValues(values...)
+	snapWithTitle(t, t.Name(), content, t.Name())
+}
+
+func SnapFuncWithName(t testingT, funcName string, values ...any) {
+	t.Helper()
+	content := formatValues(values...)
+	snapWithTitle(t, t.Name(), content, funcName)
+}
+
 func snap(t testingT, content string) {
 	t.Helper()
 	testName := t.Name()
 	snapWithTitle(t, testName, content)
 }
 
-func snapWithTitle(t testingT, title string, content string) {
+func snapWithTitle(t testingT, title string, content string, funcName ...string) {
 	t.Helper()
 
+	_, filePath, _, _ := runtime.Caller(2)
+
 	snapshot := &files.Snapshot{
-		Version: version,
-		Name:    title,
-		Content: content,
+		Name:     title,
+		FilePath: filePath,
+		Content:  content,
+	}
+
+	if len(funcName) > 0 && funcName[0] != "" {
+		snapshot.FuncName = funcName[0]
 	}
 
 	accepted, err := files.ReadAccepted(title)
···
 		return
 	}
 
-	fmt.Println(pretty.NewSnapshotBox(snapshot))
+	if len(funcName) > 0 && funcName[0] != "" {
+		fmt.Println(pretty.NewSnapshotBoxFunc(snapshot))
+	} else {
+		fmt.Println(pretty.NewSnapshotBox(snapshot))
+	}
 	t.Error("new snapshot created - run 'freeze review' to accept")
 }
 
···
 }
 
 func formatValue(v any) string {
-	// if v == nil {
-	// 	return "<nil>"
-	// }
-
 	return utter.Sdump(v)
 }
 
+// DOCS:
 func Review() error {
 	return review.Review()
 }

freeze_test.go

···
 	"testing"
 
 	"github.com/ptdewey/freeze"
+	"github.com/ptdewey/freeze/internal/api"
 )
 
 func TestSnapString(t *testing.T) {
···
 	})
 }
 
+func testHelperFunction() string {
+	return "helper result"
+}
+
+func TestSnapFunc(t *testing.T) {
+	freeze.SnapFuncWithName(t, "testHelperFunction", testHelperFunction())
+}
+
+func TestSnapFuncAnotherHelper(t *testing.T) {
+	freeze.SnapFuncWithName(t, "calculateSomething", calculateSomething(5))
+}
+
+func calculateSomething(n int) int {
+	return n * 2
+}
+
 func TestSerializeDeserialize(t *testing.T) {
 	snap := &freeze.Snapshot{
-		Version: "1.0.0",
 		Name:    "TestExample",
 		Content: "test content\nmultiline",
 	}
 
 	serialized := snap.Serialize()
-	expected := "---\nversion: 1.0.0\ntest_name: TestExample\n---\ntest content\nmultiline"
+	expected := "---\ntest_name: TestExample\nfile_path: \nfunc_name: \n---\ntest content\nmultiline"
 	if serialized != expected {
 		t.Errorf("expected:\n%s\ngot:\n%s", expected, serialized)
 	}
···
 		t.Fatalf("failed to deserialize: %v", err)
 	}
 
-	if deserialized.Version != snap.Version {
-		t.Errorf("version mismatch: %s != %s", deserialized.Version, snap.Version)
-	}
 	if deserialized.Name != snap.Name {
 		t.Errorf("test name mismatch: %s != %s", deserialized.Name, snap.Name)
 	}
···
 
 func TestFileOperations(t *testing.T) {
 	snap := &freeze.Snapshot{
-		Version: "0.1.0",
 		Name:    "TestFileOps",
 		Content: "file test content",
 	}
 
-	if err := freeze.SaveSnapshot(snap, "test"); err != nil {
+	if err := api.SaveSnapshot(snap, "test"); err != nil {
 		t.Fatalf("failed to save snapshot: %v", err)
 	}
 
···
 
 func TestDiffSnapshotBox(t *testing.T) {
 	old := &freeze.Snapshot{
-		Version: "0.1.0",
 		Name:    "TestDiff",
 		Content: "old content",
 	}
 
 	new := &freeze.Snapshot{
-		Version: "0.1.0",
 		Name:    "TestDiff",
 		Content: "new content",
 	}
···
 
 func TestNewSnapshotBox(t *testing.T) {
 	snap := &freeze.Snapshot{
-		Version: "0.1.0",
 		Name:    "TestNew",
 		Content: "test content",
 	}
···
 
 	if !contains(box, "New Snapshot") {
 		t.Error("NewSnapshotBox missing header")
-	}
-}
-
-func TestFormatFunctions(t *testing.T) {
-	tests := []struct {
-		name string
-		fn   func(string) string
-		text string
-	}{
-		{"Red", freeze.Red, "error"},
-		{"Green", freeze.Green, "success"},
-		{"Yellow", freeze.Yellow, "warning"},
-		{"Blue", freeze.Blue, "info"},
-	}
-
-	for _, tt := range tests {
-		result := tt.fn(tt.text)
-		if result == "" {
-			t.Errorf("%s returned empty string", tt.name)
-		}
 	}
 }
 

go.mod

···
 
 go 1.25.2
 
-require github.com/kortschak/utter v1.7.0 // indirect
+require github.com/kortschak/utter v1.7.0

internal/api/api.go

···
 	return pretty.NewSnapshotBox(snap)
 }
 
+func NewSnapshotBoxFunc(snap *Snapshot) string {
+	return pretty.NewSnapshotBoxFunc(snap)
+}
+
 func DiffSnapshotBox(old, new *Snapshot) string {
 	diffLines := convertDiffLines(diff.Histogram(old.Content, new.Content))
 	return pretty.DiffSnapshotBox(old, new, diffLines)

internal/files/files.go

···
 )
 
 type Snapshot struct {
-	Version string
-	Name    string
-	Content string
+	Name     string
+	FilePath string
+	FuncName string
+	Content  string
 }
 
 func (s *Snapshot) Serialize() string {
-	header := fmt.Sprintf("---\nversion: %s\ntest_name: %s\n---\n", s.Version, s.Name)
+	header := fmt.Sprintf("---\ntest_name: %s\nfile_path: %s\nfunc_name: %s\n---\n", s.Name, s.FilePath, s.FuncName)
 	return header + s.Content
 }
 
···
 		Content: content,
 	}
 
-	for _, line := range strings.Split(header, "\n") {
+	for line := range strings.SplitSeq(header, "\n") {
 		line = strings.TrimSpace(line)
 		if line == "" {
 			continue
···
 
 		key, value := kv[0], kv[1]
 		switch key {
-		case "version":
-			snap.Version = value
 		case "test_name":
 			snap.Name = value
+		case "file_path":
+			snap.FilePath = value
+		case "func_name":
+			snap.FuncName = value
 		}
 	}
 

internal/files/files_test.go

···
 
 func TestSerializeDeserialize(t *testing.T) {
 	snap := &files.Snapshot{
-		Version: "1.0.0",
-		Name:    "TestExample",
-		Content: "test content\nmultiline",
+		Name:     "TestExample",
+		FilePath: "/path/to/test.go",
+		Content:  "test content\nmultiline",
 	}
 
 	serialized := snap.Serialize()
-	expected := "---\nversion: 1.0.0\ntest_name: TestExample\n---\ntest content\nmultiline"
+	expected := "---\ntest_name: TestExample\nfile_path: /path/to/test.go\nfunc_name: \n---\ntest content\nmultiline"
 	if serialized != expected {
 		t.Errorf("Serialize():\nexpected:\n%s\n\ngot:\n%s", expected, serialized)
 	}
···
 		t.Fatalf("Deserialize failed: %v", err)
 	}
 
-	if deserialized.Version != snap.Version {
-		t.Errorf("Version mismatch: %s != %s", deserialized.Version, snap.Version)
-	}
 	if deserialized.Name != snap.Name {
 		t.Errorf("Name mismatch: %s != %s", deserialized.Name, snap.Name)
+	}
+	if deserialized.FilePath != snap.FilePath {
+		t.Errorf("FilePath mismatch: %s != %s", deserialized.FilePath, snap.FilePath)
 	}
 	if deserialized.Content != snap.Content {
 		t.Errorf("Content mismatch: %s != %s", deserialized.Content, snap.Content)
···
 	tests := []struct {
 		name        string
 		input       string
-		wantVer     string
 		wantTest    string
 		wantContent string
 	}{
 		{
 			"simple",
-			"---\nversion: 1.0\ntest_name: Test\n---\ncontent",
-			"1.0",
+			"---\ntest_name: Test\nfile_path: /path\nfunc_name: \n---\ncontent",
 			"Test",
 			"content",
 		},
 		{
 			"multiline content",
-			"---\nversion: 0.1\ntest_name: MyTest\n---\nline1\nline2\nline3",
-			"0.1",
+			"---\ntest_name: MyTest\nfile_path: /path\nfunc_name: \n---\nline1\nline2\nline3",
 			"MyTest",
 			"line1\nline2\nline3",
 		},
 		{
 			"with extra fields",
-			"---\nversion: 1.0\ntest_name: Test\nextra: ignored\n---\ncontent",
-			"1.0",
+			"---\ntest_name: Test\nfile_path: /path\nfunc_name: \nextra: ignored\n---\ncontent",
 			"Test",
 			"content",
 		},
···
 			if err != nil {
 				t.Fatalf("Deserialize failed: %v", err)
 			}
-			if snap.Version != tt.wantVer {
-				t.Errorf("Version = %s, want %s", snap.Version, tt.wantVer)
-			}
 			if snap.Name != tt.wantTest {
 				t.Errorf("Name = %s, want %s", snap.Name, tt.wantTest)
 			}
···
 
 func TestSaveAndReadSnapshot(t *testing.T) {
 	snap := &files.Snapshot{
-		Version: "0.1.0",
 		Name:    "TestSaveRead",
 		Content: "saved content",
 	}
···
 	if read.Content != snap.Content {
 		t.Errorf("Content mismatch: %s != %s", read.Content, snap.Content)
 	}
-	if read.Version != snap.Version {
-		t.Errorf("Version mismatch: %s != %s", read.Version, snap.Version)
-	}
 
 	cleanupSnapshot(t, "TestSaveRead", "test")
 }
···
 
 func TestAcceptSnapshot(t *testing.T) {
 	newSnap := &files.Snapshot{
-		Version: "0.1.0",
 		Name:    "TestAccept",
 		Content: "new content to accept",
 	}
···
 
 func TestRejectSnapshot(t *testing.T) {
 	snap := &files.Snapshot{
-		Version: "0.1.0",
 		Name:    "TestReject",
 		Content: "content to reject",
 	}

internal/pretty/boxes.go

···
 	DiffNew
 )
 
-func NewSnapshotBox(snap *files.Snapshot) string {
+func newSnapshotBoxInternal(snap *files.Snapshot, isFuncSnapshot bool) string {
 	width := TerminalWidth()
 
 	var sb strings.Builder
 	sb.WriteString("─── " + "New Snapshot " + strings.Repeat("─", width-15) + "\n\n")
-	sb.WriteString(fmt.Sprintf("  test: %s\n", Blue("\""+snap.Name+"\"")))
-	sb.WriteString(fmt.Sprintf("  snapshot: %s\n\n", Gray(files.SnapshotFileName(snap.Name))))
+
+	if isFuncSnapshot && snap.FuncName != "" {
+		sb.WriteString(fmt.Sprintf("  func: %s\n", Blue("\""+snap.FuncName+"\"")))
+		sb.WriteString(fmt.Sprintf("  test: %s\n", Blue("\""+snap.Name+"\"")))
+	} else {
+		sb.WriteString(fmt.Sprintf("  test: %s\n", Blue("\""+snap.Name+"\"")))
+	}
+
+	sb.WriteString(fmt.Sprintf("  snapshot: %s\n", Gray(files.SnapshotFileName(snap.Name)+".snap.new")))
+	if snap.FilePath != "" {
+		sb.WriteString(fmt.Sprintf("  file: %s\n", Gray(snap.FilePath)))
+	}
+	sb.WriteString("\n")
 
 	lines := strings.Split(snap.Content, "\n")
 	numLines := len(lines)
···
 	return sb.String()
 }
 
-// TODO: needs to get overhauled with styling like above
-// - should show line numbers, line numbers with diffs should be the same
-// - should show test name and path in the header section
-// TODO: additional styling
-// show helper text to say + is new results, - is old snapshot
+func NewSnapshotBox(snap *files.Snapshot) string {
+	return newSnapshotBoxInternal(snap, false)
+}
+
+func NewSnapshotBoxFunc(snap *files.Snapshot) string {
+	return newSnapshotBoxInternal(snap, true)
+}
+
+// TODO: diff should show old and new line numbers
 func DiffSnapshotBox(old, new *files.Snapshot, diffLines []DiffLine) string {
 	width := TerminalWidth()
 
 	var sb strings.Builder
 	sb.WriteString(strings.Repeat("─", width) + "\n")
 	sb.WriteString(fmt.Sprintf("  %s\n", Blue("Snapshot Diff")))
+	if new.FilePath != "" {
+		sb.WriteString(fmt.Sprintf("  file: %s\n", Gray(new.FilePath)))
+	}
 	sb.WriteString(strings.Repeat("─", width) + "\n")
 
 	for _, dl := range diffLines {

internal/review/review.go

···
 			diffLines := computeDiffLines(accepted, newSnap)
 			fmt.Println(pretty.DiffSnapshotBox(accepted, newSnap, diffLines))
 		} else {
-			fmt.Println(pretty.NewSnapshotBox(newSnap))
+			if newSnap.FuncName != "" {
+				fmt.Println(pretty.NewSnapshotBoxFunc(newSnap))
+			} else {
+				fmt.Println(pretty.NewSnapshotBox(newSnap))
+			}
 		}
 
 		for {