[go] streamline PDF metadata handling and improve error management

Author: ddol

internal/report/typst/pdf_metadata.go

@@ -11,6 +11,8 @@ import (
 	"strings"
 )
 
+var pdfIndirectRefPattern = regexp.MustCompile(`(\d+)\s+(\d+)\s+R`)
+
 // PDFMetadata describes the extra PDF metadata velocity.report wants to stamp
 // onto Typst-generated reports.
 type PDFMetadata struct {
@@ -92,10 +94,7 @@ func applyPDFMetadata(pdf []byte, meta PDFMetadata) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	metadataRef, ok, err := parseIndirectRef(rootDict, "Metadata")
-	if err != nil {
-		return nil, err
-	}
+	metadataRef, ok := parseIndirectRef(rootDict, "Metadata")
 	if ok {
 		metadataOffset, found := xrefOffsets[metadataRef.number]
 		if !found {
@@ -253,28 +252,16 @@ func parseLastTrailerDict(pdf []byte) ([]byte, error) {
 }
 
 func parsePDFTrailer(dict []byte) (pdfTrailer, error) {
-	size, ok, err := parsePDFInt(dict, "Size")
-	if err != nil {
-		return pdfTrailer{}, err
-	}
+	size, ok := parsePDFInt(dict, "Size")
 	if !ok {
 		return pdfTrailer{}, fmt.Errorf("pdf trailer missing Size")
 	}
-	root, ok, err := parseIndirectRef(dict, "Root")
-	if err != nil {
-		return pdfTrailer{}, err
-	}
+	root, ok := parseIndirectRef(dict, "Root")
 	if !ok {
 		return pdfTrailer{}, fmt.Errorf("pdf trailer missing Root")
 	}
-	info, hasInfo, err := parseIndirectRef(dict, "Info")
-	if err != nil {
-		return pdfTrailer{}, err
-	}
-	id, _, err := parsePDFRawValue(dict, "ID", `\[[^\]]+\]`)
-	if err != nil {
-		return pdfTrailer{}, err
-	}
+	info, hasInfo := parseIndirectRef(dict, "Info")
+	id, _ := parsePDFRawValue(dict, "ID", `\[[^\]]+\]`)
 
 	trailer := pdfTrailer{size: size, root: root, id: id}
 	if hasInfo {
@@ -396,49 +383,33 @@ func extractPDFStreamObject(obj []byte) ([]byte, []byte, error) {
 	return obj[dictStart:dictEnd], stream, nil
 }
 
-func parseIndirectRef(dict []byte, key string) (pdfRef, bool, error) {
-	value, ok, err := parsePDFRawValue(dict, key, `(\d+)\s+(\d+)\s+R`)
-	if err != nil || !ok {
-		return pdfRef{}, ok, err
-	}
-	re := regexp.MustCompile(`(\d+)\s+(\d+)\s+R`)
-	match := re.FindStringSubmatch(value)
-	if len(match) != 3 {
-		return pdfRef{}, false, fmt.Errorf("malformed pdf reference for %s", key)
-	}
-	number, err := strconv.Atoi(match[1])
-	if err != nil {
-		return pdfRef{}, false, fmt.Errorf("parse %s object number: %w", key, err)
-	}
-	generation, err := strconv.Atoi(match[2])
-	if err != nil {
-		return pdfRef{}, false, fmt.Errorf("parse %s generation: %w", key, err)
+func parseIndirectRef(dict []byte, key string) (pdfRef, bool) {
+	value, ok := parsePDFRawValue(dict, key, `(\d+)\s+(\d+)\s+R`)
+	if !ok {
+		return pdfRef{}, false
 	}
-	return pdfRef{number: number, generation: generation}, true, nil
+	match := pdfIndirectRefPattern.FindStringSubmatch(value)
+	number, _ := strconv.Atoi(match[1])
+	generation, _ := strconv.Atoi(match[2])
+	return pdfRef{number: number, generation: generation}, true
 }
 
-func parsePDFInt(dict []byte, key string) (int, bool, error) {
-	value, ok, err := parsePDFRawValue(dict, key, `(\d+)`)
-	if err != nil || !ok {
-		return 0, ok, err
-	}
-	parsed, err := strconv.Atoi(value)
-	if err != nil {
-		return 0, false, fmt.Errorf("parse %s: %w", key, err)
+func parsePDFInt(dict []byte, key string) (int, bool) {
+	value, ok := parsePDFRawValue(dict, key, `(\d+)`)
+	if !ok {
+		return 0, false
 	}
-	return parsed, true, nil
+	parsed, _ := strconv.Atoi(value)
+	return parsed, true
 }
 
-func parsePDFRawValue(dict []byte, key, pattern string) (string, bool, error) {
+func parsePDFRawValue(dict []byte, key, pattern string) (string, bool) {
 	re := regexp.MustCompile(`/` + regexp.QuoteMeta(key) + `\s+(` + pattern + `)`)
 	match := re.FindSubmatch(dict)
 	if len(match) == 0 {
-		return "", false, nil
+		return "", false
 	}
-	if len(match) < 2 {
-		return "", false, fmt.Errorf("malformed pdf value for %s", key)
-	}
-	return string(match[1]), true, nil
+	return string(match[1]), true
 }
 
 func replaceOrAddPDFString(dict []byte, key, value string) []byte {
@@ -475,10 +446,7 @@ func insertIntoPDFDict(dict, entry []byte) []byte {
 }
 
 func replaceOrAddXMLTag(doc []byte, tag, value string) ([]byte, error) {
-	escaped, err := escapeXMLText(value)
-	if err != nil {
-		return nil, err
-	}
+	escaped := escapeXMLText(value)
 	replacement := []byte(fmt.Sprintf("<%s>%s</%s>", tag, escaped, tag))
 	re := regexp.MustCompile(`(?s)<` + regexp.QuoteMeta(tag) + `>.*?</` + regexp.QuoteMeta(tag) + `>`)
 	if re.Match(doc) {
@@ -515,12 +483,10 @@ func escapePDFString(value string) string {
 	return out.String()
 }
 
-func escapeXMLText(value string) (string, error) {
+func escapeXMLText(value string) string {
 	var out bytes.Buffer
-	if err := xml.EscapeText(&out, []byte(value)); err != nil {
-		return "", err
-	}
-	return out.String(), nil
+	_ = xml.EscapeText(&out, []byte(value))
+	return out.String()
 }
 
 func skipPDFWhitespace(pdf []byte, index int) int {

internal/report/typst/render.go

@@ -6,8 +6,7 @@
 // out to `typst compile`. The Atkinson Hyperlegible fonts are materialised
 // from the chart asset package so generation works from a deployed binary
 // with no source tree present. The typst executable itself is resolved via the
-// typstbin subpackage (VELOCITY_TYPST_PATH → embedded binary → PATH → dev
-// download).
+// typstbin subpackage (embedded binary → PATH → dev download).
 package typst
 
 import (
@@ -30,6 +29,21 @@ import (
 //go:embed templates
 var templatesFS embed.FS
 
+type templateSourceFS interface {
+	fs.FS
+	fs.ReadFileFS
+}
+
+var (
+	renderTemplatesFS  = templateSourceFS(templatesFS)
+	renderResolveTypst = typstbin.Resolve
+	renderMkdirTemp    = os.MkdirTemp
+	renderRemoveAll    = os.RemoveAll
+	renderMkdirAll     = os.MkdirAll
+	renderWriteFile    = os.WriteFile
+	renderAllFonts     = assets.AllFonts
+)
+
 // Asset is a binary blob (chart SVG, map SVG, etc.) that the report embeds
 // via #image(). The Name is used as the relative path inside the working
 // directory; the template references it as e.g. `data.charts.timeseries`.
@@ -69,22 +83,17 @@ type Options struct {
 	// the document. Typst 0.13.x exposes document metadata, but not the PDF
 	// creator tool, so we patch the finished PDF incrementally.
 	PDFMetadata PDFMetadata
-
-	// TypstPath overrides the typst executable. When empty, the binary is
-	// resolved via typstbin (VELOCITY_TYPST_PATH → embedded → PATH → dev
-	// download).
-	TypstPath string
 }
 
 // Render compiles the embedded templates against opts.Data and writes the
 // resulting PDF to out. The working directory used for compilation is removed
 // before Render returns.
 func Render(out io.Writer, opts Options) error {
-	workDir, err := os.MkdirTemp("", "velocity-report-typst-*")
+	workDir, err := renderMkdirTemp("", "velocity-report-typst-*")
 	if err != nil {
 		return fmt.Errorf("create temp dir: %w", err)
 	}
-	defer os.RemoveAll(workDir)
+	defer renderRemoveAll(workDir)
 
 	if err := materialiseTemplates(workDir); err != nil {
 		return err
@@ -105,23 +114,19 @@ func Render(out io.Writer, opts Options) error {
 		if dest != workDir && !strings.HasPrefix(dest, workDir+string(os.PathSeparator)) {
 			return fmt.Errorf("asset name %q escapes work dir", asset.Name)
 		}
-		if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
+		if err := renderMkdirAll(filepath.Dir(dest), 0o755); err != nil {
 			return fmt.Errorf("mkdir %s: %w", filepath.Dir(dest), err)
 		}
-		if err := os.WriteFile(dest, asset.Data, 0o644); err != nil {
+		if err := renderWriteFile(dest, asset.Data, 0o644); err != nil {
 			return fmt.Errorf("write asset %s: %w", asset.Name, err)
 		}
 	}
 
-	execPath := opts.TypstPath
-	if execPath == "" {
-		resolved, cleanup, rerr := typstbin.Resolve()
-		if rerr != nil {
-			return fmt.Errorf("resolve typst binary: %w", rerr)
-		}
-		defer cleanup()
-		execPath = resolved
+	execPath, cleanup, rerr := renderResolveTypst()
+	if rerr != nil {
+		return fmt.Errorf("resolve typst binary: %w", rerr)
 	}
+	defer cleanup()
 	caller := gotypst.CLI{ExecutablePath: execPath}
 
 	// Bootstrap: typst reads the document from stdin, which has no implicit
@@ -173,14 +178,14 @@ func Render(out io.Writer, opts Options) error {
 // recompilable source ZIP that ships alongside each generated PDF.
 func Sources() (map[string][]byte, error) {
 	out := map[string][]byte{}
-	err := fs.WalkDir(templatesFS, "templates", func(path string, d fs.DirEntry, err error) error {
+	err := fs.WalkDir(renderTemplatesFS, "templates", func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			return err
 		}
 		if d.IsDir() {
 			return nil
 		}
-		body, rerr := templatesFS.ReadFile(path)
+		body, rerr := renderTemplatesFS.ReadFile(path)
 		if rerr != nil {
 			return rerr
 		}
@@ -202,38 +207,35 @@ func MarshalData(data any) ([]byte, error) {
 // materialiseTemplates copies the embedded templates/ tree into workDir at
 // the top level (so report.typ ends up at workDir/report.typ).
 func materialiseTemplates(workDir string) error {
-	return fs.WalkDir(templatesFS, "templates", func(path string, d fs.DirEntry, err error) error {
+	return fs.WalkDir(renderTemplatesFS, "templates", func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			return err
 		}
 		if d.IsDir() {
 			return nil
 		}
-		rel, err := filepath.Rel("templates", path)
-		if err != nil {
-			return err
-		}
+		rel := strings.TrimPrefix(path, "templates/")
 		dest := filepath.Join(workDir, rel)
-		if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
+		if err := renderMkdirAll(filepath.Dir(dest), 0o755); err != nil {
 			return err
 		}
-		body, err := templatesFS.ReadFile(path)
+		body, err := renderTemplatesFS.ReadFile(path)
 		if err != nil {
 			return err
 		}
-		return os.WriteFile(dest, body, 0o644)
+		return renderWriteFile(dest, body, 0o644)
 	})
 }
 
 // materialiseFonts writes the embedded Atkinson Hyperlegible fonts into
 // workDir/fonts and returns that directory for use as a typst --font-path.
 func materialiseFonts(workDir string) (string, error) {
 	fontDir := filepath.Join(workDir, "fonts")
-	if err := os.MkdirAll(fontDir, 0o755); err != nil {
+	if err := renderMkdirAll(fontDir, 0o755); err != nil {
 		return "", fmt.Errorf("mkdir fonts: %w", err)
 	}
-	for name, data := range assets.AllFonts() {
-		if err := os.WriteFile(filepath.Join(fontDir, name), data, 0o644); err != nil {
+	for name, data := range renderAllFonts() {
+		if err := renderWriteFile(filepath.Join(fontDir, name), data, 0o644); err != nil {
 			return "", fmt.Errorf("write font %s: %w", name, err)
 		}
 	}
@@ -245,5 +247,5 @@ func writeData(workDir string, data any) error {
 	if err != nil {
 		return fmt.Errorf("marshal report data: %w", err)
 	}
-	return os.WriteFile(filepath.Join(workDir, "data.json"), body, 0o644)
+	return renderWriteFile(filepath.Join(workDir, "data.json"), body, 0o644)
 }

internal/report/typst/typstbin/deps.go

@@ -5,6 +5,13 @@ import (
 	"os/exec"
 )
 
+type tempExecutable interface {
+	Name() string
+	Write([]byte) (int, error)
+	Chmod(os.FileMode) error
+	Close() error
+}
+
 var (
 	osGetenv       = os.Getenv
 	osStat         = os.Stat
@@ -15,6 +22,7 @@ var (
 	osCreateTemp   = os.CreateTemp
 	osRename       = os.Rename
 	osChmod        = os.Chmod
+	createTempExec = func(dir, pattern string) (tempExecutable, error) { return osCreateTemp(dir, pattern) }
 
 	cacheDirFunc       = cacheDir
 	typstTargetFunc    = typstTarget

internal/report/typst/typstbin/embed_off.go

@@ -3,7 +3,7 @@
 package typstbin
 
 // embeddedTypst returns no binary in the default build. The typst executable
-// is resolved from VELOCITY_TYPST_PATH or PATH instead. Build with
+// is resolved from PATH or the development downloader instead. Build with
 // `-tags typst_embed` (after placing a platform binary at dist/typst via
 // `make install-typst-dist`) to embed the binary into the program.
 func embeddedTypst() ([]byte, bool) { return nil, false }