refactor(render): 将输出渲染逻辑重构为统一的内容写入接口

- 移除 strings 包依赖，统一使用 render.Content 进行文本输出
- 创建 internal/render 包封装格式化写入功能
- 将 writeAnalyzeText 和 writeRestoreText 函数重写为返回错误
- 更新 README 中的构建说明使用新脚本
- 添加对 report.WriteText 的错误处理测试
- 重构 Text 函数使用新的 WriteText 接口实现

Author: walker1211

README.en.md

@@ -30,10 +30,10 @@ go install github.com/walker1211/histprune/cmd/histprune@latest
 histprune version
 ```
 
-For local development, you can also build a binary:
+For local development, you can build a binary with the helper script:
 
 ```bash
-go build -o histprune ./cmd/histprune
+./build.sh
 ./histprune version
 ```
 

README.md

@@ -2,7 +2,7 @@
 
 Safe, explainable shell history cleanup in Go.
 
-[中文文档](./README.zh-CN.md) | [English Documentation](./README.en.md)
+[中文](./README.zh-CN.md) | [English](./README.en.md)
 
 ## Features
 

README.zh-CN.md

@@ -30,10 +30,10 @@ go install github.com/walker1211/histprune/cmd/histprune@latest
 histprune version
 ```
 
-仓库本地开发时也可以构建二进制：
+仓库本地开发时可以用脚本构建二进制：
 
 ```bash
-go build -o histprune ./cmd/histprune
+./build.sh
 ./histprune version
 ```
 

build.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+cd "$(dirname "$0")" || exit
+
+echo "Building..."
+go build -o histprune ./cmd/histprune
+echo "Done. Binary: ./histprune"

internal/app/app.go

@@ -6,11 +6,11 @@ import (
 	"fmt"
 	"io"
 	"sort"
-	"strings"
 
 	"github.com/walker1211/histprune/internal/cli"
 	"github.com/walker1211/histprune/internal/history"
 	"github.com/walker1211/histprune/internal/prune"
+	"github.com/walker1211/histprune/internal/render"
 	"github.com/walker1211/histprune/internal/report"
 	"github.com/walker1211/histprune/internal/storage"
 )
@@ -61,8 +61,7 @@ func (a App) analyze(ctx context.Context, opts cli.AnalyzeOptions) error {
 		if opts.JSON {
 			return writeJSON(a.stdout, summary)
 		}
-		_, err = io.WriteString(a.stdout, renderAnalyzeText(summary))
-		return err
+		return writeAnalyzeText(a.stdout, summary)
 	})
 }
 
@@ -107,8 +106,7 @@ func (a App) prune(ctx context.Context, opts cli.PruneOptions) error {
 			_, err = fmt.Fprintln(a.stdout, text)
 			return err
 		}
-		_, err = io.WriteString(a.stdout, report.Text(summary))
-		return err
+		return report.WriteText(a.stdout, summary)
 	})
 }
 
@@ -168,8 +166,7 @@ func (a App) restore(ctx context.Context, opts cli.RestoreOptions) error {
 		if err != nil {
 			return err
 		}
-		_, err = fmt.Fprintf(a.stdout, "Restored: %s\nCurrent backup: %s\n", target, currentBackup)
-		return err
+		return writeRestoreText(a.stdout, target, currentBackup)
 	})
 }
 
@@ -186,7 +183,8 @@ func (a App) version(ctx context.Context) error {
 func (a App) run(fn func() error) error {
 	err := fn()
 	if err != nil {
-		_, _ = fmt.Fprintf(a.stderr, "error: %v\n", err)
+		content := render.NewContent(a.stderr)
+		content.Writef("error: %v\n", err)
 	}
 	return err
 }
@@ -293,23 +291,30 @@ func formatName(format history.Format) string {
 	}
 }
 
-func renderAnalyzeText(summary analyzeSummary) string {
-	var b strings.Builder
-	fmt.Fprintf(&b, "Scanned: %d\n", summary.Scanned)
-	b.WriteString("Formats:\n")
+func writeAnalyzeText(w io.Writer, summary analyzeSummary) error {
+	content := render.NewContent(w)
+	content.Writef("Scanned: %d\n", summary.Scanned)
+	content.WriteString("Formats:\n")
 	for _, name := range []string{"zsh_extended", "plain", "malformed"} {
-		fmt.Fprintf(&b, "  %s: %d\n", name, summary.Formats[name])
+		content.Writef("  %s: %d\n", name, summary.Formats[name])
 	}
-	fmt.Fprintf(&b, "Duplicate commands: %d\n", summary.DuplicateCommands)
-	b.WriteString("Top commands:\n")
+	content.Writef("Duplicate commands: %d\n", summary.DuplicateCommands)
+	content.WriteString("Top commands:\n")
 	if len(summary.TopCommands) == 0 {
-		b.WriteString("  (none)\n")
-		return b.String()
+		content.WriteString("  (none)\n")
+		return content.Err()
 	}
 	for _, top := range summary.TopCommands {
-		fmt.Fprintf(&b, "  %s: %d\n", top.Command, top.Count)
+		content.Writef("  %s: %d\n", top.Command, top.Count)
 	}
-	return b.String()
+	return content.Err()
+}
+
+func writeRestoreText(w io.Writer, restoredPath, currentBackupPath string) error {
+	content := render.NewContent(w)
+	content.Writef("Restored: %s\n", restoredPath)
+	content.Writef("Current backup: %s\n", currentBackupPath)
+	return content.Err()
 }
 
 func writeJSON(w io.Writer, payload any) error {

internal/render/content.go

@@ -0,0 +1,33 @@
+package render
+
+import (
+	"fmt"
+	"io"
+)
+
+type Content struct {
+	writer io.Writer
+	err    error
+}
+
+func NewContent(writer io.Writer) *Content {
+	return &Content{writer: writer}
+}
+
+func (c *Content) WriteString(text string) {
+	if c.err != nil {
+		return
+	}
+	_, c.err = io.WriteString(c.writer, text)
+}
+
+func (c *Content) Writef(format string, args ...any) {
+	if c.err != nil {
+		return
+	}
+	_, c.err = fmt.Fprintf(c.writer, format, args...)
+}
+
+func (c *Content) Err() error {
+	return c.err
+}

internal/render/content_test.go

@@ -0,0 +1,52 @@
+package render
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestContentWritesFormattedText(t *testing.T) {
+	writer := &recordingWriter{}
+	content := NewContent(writer)
+
+	content.WriteString("Scanned: ")
+	content.Writef("%d\n", 3)
+
+	if err := content.Err(); err != nil {
+		t.Fatalf("Err() = %v, want nil", err)
+	}
+	if got, want := writer.text, "Scanned: 3\n"; got != want {
+		t.Fatalf("content = %q, want %q", got, want)
+	}
+}
+
+func TestContentReturnsFirstWriteErrorAndStops(t *testing.T) {
+	wantErr := errors.New("write failed")
+	writer := &recordingWriter{err: wantErr}
+	content := NewContent(writer)
+
+	content.Writef("first %s", "write")
+	content.WriteString("second write")
+
+	if !errors.Is(content.Err(), wantErr) {
+		t.Fatalf("Err() = %v, want %v", content.Err(), wantErr)
+	}
+	if got, want := writer.calls, 1; got != want {
+		t.Fatalf("writer calls = %d, want %d", got, want)
+	}
+}
+
+type recordingWriter struct {
+	text  string
+	err   error
+	calls int
+}
+
+func (w *recordingWriter) Write(p []byte) (int, error) {
+	w.calls++
+	if w.err != nil {
+		return 0, w.err
+	}
+	w.text += string(p)
+	return len(p), nil
+}

internal/report/report_test.go

@@ -2,6 +2,7 @@ package report
 
 import (
 	"encoding/json"
+	"errors"
 	"strings"
 	"testing"
 
@@ -112,6 +113,24 @@ func TestTextIncludesRemovedEntryDetails(t *testing.T) {
 	}
 }
 
+func TestWriteTextReturnsWriterError(t *testing.T) {
+	wantErr := errors.New("write failed")
+
+	err := WriteText(failingWriter{err: wantErr}, Summary{Scanned: 1})
+
+	if !errors.Is(err, wantErr) {
+		t.Fatalf("WriteText() error = %v, want %v", err, wantErr)
+	}
+}
+
+type failingWriter struct {
+	err error
+}
+
+func (w failingWriter) Write([]byte) (int, error) {
+	return 0, w.err
+}
+
 func TestJSONIncludesTotalsAndRemovedEntries(t *testing.T) {
 	ts := int64(1710000000)
 	summary := Summary{

internal/report/text.go

@@ -1,11 +1,12 @@
 package report
 
 import (
-	"fmt"
+	"io"
 	"sort"
 	"strings"
 
 	"github.com/walker1211/histprune/internal/prune"
+	"github.com/walker1211/histprune/internal/render"
 )
 
 // Summary is the report model shared by text, JSON, and app-level integration.
@@ -60,40 +61,46 @@ func FromDecisions(decisions []prune.Decision, dryRun bool, backupPath string) S
 // Text renders a compact human-readable report.
 func Text(summary Summary) string {
 	var b strings.Builder
-	fmt.Fprintf(&b, "Scanned: %d\n", summary.Scanned)
-	fmt.Fprintf(&b, "Removed: %d\n", summary.Removed)
-	fmt.Fprintf(&b, "Kept: %d\n", summary.Kept)
+	_ = WriteText(&b, summary)
+	return b.String()
+}
+
+func WriteText(w io.Writer, summary Summary) error {
+	content := render.NewContent(w)
+	content.Writef("Scanned: %d\n", summary.Scanned)
+	content.Writef("Removed: %d\n", summary.Removed)
+	content.Writef("Kept: %d\n", summary.Kept)
 	if summary.DryRun {
-		b.WriteString("Mode: dry-run\n")
+		content.WriteString("Mode: dry-run\n")
 	} else {
-		b.WriteString("Mode: write\n")
+		content.WriteString("Mode: write\n")
 	}
 	if summary.BackupPath != "" {
-		fmt.Fprintf(&b, "Backup: %s\n", summary.BackupPath)
+		content.Writef("Backup: %s\n", summary.BackupPath)
 	}
 	if len(summary.RuleCounts) > 0 {
-		b.WriteString("Rules:\n")
+		content.WriteString("Rules:\n")
 		keys := make([]string, 0, len(summary.RuleCounts))
 		for key := range summary.RuleCounts {
 			keys = append(keys, key)
 		}
 		sort.Strings(keys)
 		for _, key := range keys {
-			fmt.Fprintf(&b, "  %s: %d\n", key, summary.RuleCounts[key])
+			content.Writef("  %s: %d\n", key, summary.RuleCounts[key])
 		}
 	}
 	if len(summary.RemovedEntries) > 0 {
-		b.WriteString("Removed entries:\n")
+		content.WriteString("Removed entries:\n")
 		for _, entry := range summary.RemovedEntries {
-			fmt.Fprintf(&b, "  Line %d: %s\n", entry.LineNo, entry.Command)
+			content.Writef("  Line %d: %s\n", entry.LineNo, entry.Command)
 			for _, reason := range entry.Reasons {
 				if reason.Detail == "" {
-					fmt.Fprintf(&b, "    - %s\n", reason.Type)
+					content.Writef("    - %s\n", reason.Type)
 					continue
 				}
-				fmt.Fprintf(&b, "    - %s: %s\n", reason.Type, reason.Detail)
+				content.Writef("    - %s: %s\n", reason.Type, reason.Detail)
 			}
 		}
 	}
-	return b.String()
+	return content.Err()
 }