Automate the Boring Stuff with Go, Ch. 10: PDFs

go get github.com/pdfcpu/pdfcpu github.com/ledongthuc/pdf

// read-pdf-text prints the page count of a PDF and the plain text of every page.
// PDFs store drawing instructions, not paragraphs, so extracted text is only as tidy
// as the document that produced it.
//
//	go run ./ch10/projects/read-pdf-text ./ch10/projects/read-pdf-text/sample.pdf
package main

import (
	"errors"
	"fmt"
	"os"
	"strings"

	"github.com/ledongthuc/pdf"
)

// PageTexts returns the plain text of each page, in order.
func PageTexts(path string) ([]string, error) {
	f, r, err := pdf.Open(path)
	if err != nil {
		return nil, fmt.Errorf("open %s: %w", path, err)
	}
	defer f.Close()

	var pages []string
	for i := 1; i <= r.NumPage(); i++ {
		p := r.Page(i)
		if p.V.IsNull() {
			pages = append(pages, "")
			continue
		}
		text, err := p.GetPlainText(nil)
		if err != nil {
			return nil, fmt.Errorf("page %d: %w", i, err)
		}
		pages = append(pages, strings.TrimSpace(text))
	}
	return pages, nil
}

func run(args []string) error {
	if len(args) != 1 {
		return errors.New("usage: read-pdf-text <file.pdf>")
	}
	pages, err := PageTexts(args[0])
	if err != nil {
		return err
	}
	fmt.Printf("%s: %d page(s)\n", args[0], len(pages))
	for i, text := range pages {
		fmt.Printf("\n--- page %d ---\n%s\n", i+1, text)
	}
	return nil
}

func main() {
	if err := run(os.Args[1:]); err != nil {
		fmt.Fprintln(os.Stderr, "error:", err)
		os.Exit(1)
	}
}

// merge-pdfs joins PDF files into one, in the order given, and reports the page count
// of the result. Pass a folder instead of files to merge every PDF in it, sorted by name.
//
//	go run ./ch10/projects/merge-pdfs -out merged.pdf ./ch10/projects/merge-pdfs
package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"github.com/pdfcpu/pdfcpu/pkg/api"
)

// Inputs expands the arguments: a folder becomes its *.pdf files sorted by name; a file
// is taken as given. The output file is never included even if it sits in the folder.
func Inputs(args []string, out string) ([]string, error) {
	var files []string
	outAbs, _ := filepath.Abs(out)
	for _, a := range args {
		info, err := os.Stat(a)
		if err != nil {
			return nil, err
		}
		if !info.IsDir() {
			files = append(files, a)
			continue
		}
		matches, err := filepath.Glob(filepath.Join(a, "*.pdf"))
		if err != nil {
			return nil, err
		}
		for _, m := range matches {
			if abs, _ := filepath.Abs(m); abs == outAbs {
				continue
			}
			files = append(files, m)
		}
	}
	if len(files) < 2 {
		return nil, fmt.Errorf("need at least two PDFs, found %d", len(files))
	}
	return files, nil
}

// Merge writes the concatenation of in to out and returns the page count of out.
func Merge(ctx context.Context, in []string, out string) (int, error) {
	if err := api.MergeCreateFile(ctx, in, out, false, nil); err != nil {
		return 0, fmt.Errorf("merge: %w", err)
	}
	n, err := api.PageCountFile(ctx, out)
	if err != nil {
		return 0, fmt.Errorf("count pages of %s: %w", out, err)
	}
	return n, nil
}

func run(args []string) error {
	flags := flag.NewFlagSet("merge-pdfs", flag.ContinueOnError)
	out := flags.String("out", "merged.pdf", "output file")
	if err := flags.Parse(args); err != nil {
		return err
	}
	if flags.NArg() == 0 {
		return errors.New("usage: merge-pdfs [-out merged.pdf] <folder or file.pdf ...>")
	}
	in, err := Inputs(flags.Args(), *out)
	if err != nil {
		return err
	}
	n, err := Merge(context.Background(), in, *out)
	if err != nil {
		return err
	}
	fmt.Printf("merged %s\ninto %s (%d pages)\n", strings.Join(in, ", "), *out, n)
	return nil
}

func main() {
	if err := run(os.Args[1:]); err != nil {
		fmt.Fprintln(os.Stderr, "error:", err)
		os.Exit(1)
	}
}

// watermark-pdfs stamps a word diagonally across every page of a PDF, the way "DRAFT"
// or "CONFIDENTIAL" appears on documents that leave the building.
//
//	go run ./ch10/projects/watermark-pdfs -text DRAFT ./ch10/projects/watermark-pdfs/contract.pdf
package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"github.com/pdfcpu/pdfcpu/pkg/api"
	"github.com/pdfcpu/pdfcpu/pkg/pdfcpu/types"
)

// Stamp writes a copy of in to out with text across every page.
func Stamp(ctx context.Context, in, out, text string) error {
	desc := "font:Helvetica, points:56, rot:45, op:0.25, fillcolor:#b00020, scale:0.8 rel"
	wm, err := api.TextWatermark(ctx, text, desc, true, false, types.POINTS, nil)
	if err != nil {
		return fmt.Errorf("describe watermark: %w", err)
	}
	if err := api.AddWatermarksFile(ctx, in, out, nil, wm, nil); err != nil {
		return fmt.Errorf("stamp %s: %w", in, err)
	}
	return nil
}

// OutputName puts "_stamped" before the extension: contract.pdf -> contract_stamped.pdf.
func OutputName(in string) string {
	ext := filepath.Ext(in)
	return strings.TrimSuffix(in, ext) + "_stamped" + ext
}

func run(args []string) error {
	flags := flag.NewFlagSet("watermark-pdfs", flag.ContinueOnError)
	text := flags.String("text", "DRAFT", "the word to stamp")
	if err := flags.Parse(args); err != nil {
		return err
	}
	if flags.NArg() == 0 {
		return errors.New("usage: watermark-pdfs [-text DRAFT] <file.pdf ...>")
	}
	for _, in := range flags.Args() {
		out := OutputName(in)
		if err := Stamp(context.Background(), in, out, *text); err != nil {
			return err
		}
		fmt.Println("wrote", out)
	}
	return nil
}

func main() {
	if err := run(os.Args[1:]); err != nil {
		fmt.Fprintln(os.Stderr, "error:", err)
		os.Exit(1)
	}
}