Makefile

PANDOC ?= pandoc
QUARTO ?= quarto pandoc

FILTER        = container-writer.lua
STRIP_FILTER  = container-strip.lua
UNWRAP_FILTER = container-unwrap.lua

# Filter chains
WRITE  = --lua-filter=$(FILTER)
UNWRAP = --lua-filter=$(FILTER) --lua-filter=$(UNWRAP_FILTER)
STRIP  = --lua-filter=$(STRIP_FILTER) --lua-filter=$(FILTER)

# html and markdown are here to pin the passthrough contract, not to test
# wrapping: html reaches an empty table entry, html5 reaches the same one
# through variant normalisation, and markdown is absent from the table
# altogether. Between them they cover every branch of the format lookup.
# jats_publishing pins the other half of that lookup: it must resolve to the
# jats entry and tag its raw blocks 'jats', since Pandoc discards blocks
# tagged with a variant name.
TEXT_FORMATS = latex context typst html html5 markdown jats jats_publishing
BIN_FORMATS  = docx odt

# strip-*.md      : run through container-strip, compared as markdown
# noop*.md        : run through container-unwrap, output must be container-free
# everything else : the main suite
STRIP_INPUTS  = $(wildcard test/input/strip-*.md)
UNWRAP_INPUTS = $(wildcard test/input/noop*.md)
MAIN_INPUTS   = $(filter-out $(STRIP_INPUTS) $(UNWRAP_INPUTS), $(wildcard test/input/*.md))

TMP = /tmp/cw

# check LABEL EXPECTED-BASE ACTUAL-OUT ACTUAL-ERR
#   Compares stdout against EXPECTED-BASE.out, and stderr against
#   EXPECTED-BASE.err when that file exists (otherwise stderr must be empty).
#   Sets `failed` on mismatch. Shared by every test target.
#
#   Both sides are normalised first: a fenced div is the same construct with
#   three colons or with four — the count only disambiguates nesting — and
#   Pandoc changed which it emits between the versions the CI pins (3.1.3
#   writes ::: where 3.10 writes ::::). Normalising both sides means a golden
#   file stays valid whichever version generated it, and the diff printed on
#   failure shows the real difference instead of a colon count.
define CHECK
failed=0; \
check() { \
	label="$$1"; exp="$$2"; out="$$3"; err="$$4"; ok=1; \
	sed 's/^::::*/:::/' "$$out" > "$$out.norm" 2>/dev/null; \
	sed 's/^::::*/:::/' "$$exp.out" > "$$out.gold" 2>/dev/null || : > "$$out.gold"; \
	if ! diff -q "$$out.norm" "$$out.gold" >/dev/null 2>&1; then \
		echo "FAIL: $$label (stdout)"; diff "$$out.norm" "$$out.gold"; ok=0; \
	fi; \
	if [ -f "$$exp.err" ]; then \
		if ! diff -q "$$err" "$$exp.err" >/dev/null 2>&1; then \
			echo "FAIL: $$label (stderr)"; diff "$$err" "$$exp.err"; ok=0; \
		fi; \
	elif [ -s "$$err" ]; then \
		echo "FAIL: $$label (unexpected stderr)"; cat "$$err"; ok=0; \
	fi; \
	if [ $$ok -eq 1 ]; then echo "PASS: $$label"; else failed=1; fi; \
};
endef

# styles ARCHIVE FORMAT
#   Lists the paragraph and character styles applied in a docx/odt file,
#   sorted and deduplicated. Binary output cannot be diffed directly, so
#   this is what the docx/odt golden files record.
define STYLES
styles() { \
	case "$$2" in \
		docx) unzip -p "$$1" word/document.xml \
		      | grep -o 'w:[pr]Style w:val="[^"]*"';; \
		odt)  unzip -p "$$1" content.xml \
		      | grep -o 'text:style-name="[^"]*"';; \
	esac | LC_ALL=C sort -u; \
};
endef

# generate EXPECTED-BASE COMMAND...
#   Writes COMMAND's stdout to EXPECTED-BASE.out, and its stderr to
#   EXPECTED-BASE.err only when non-empty.
define GENERATE
generate() { \
	exp="$$1"; shift; \
	"$$@" >"$$exp.out" 2>"$$exp.err.tmp"; \
	if [ -s "$$exp.err.tmp" ]; then mv "$$exp.err.tmp" "$$exp.err"; \
	else rm -f "$$exp.err.tmp" "$$exp.err"; fi; \
	echo "Generated: $$exp"; \
};
endef

.PHONY: test test-main test-noop test-bin test-strip \
        test-quarto test-quarto-strip \
        generate-tests generate-noop-tests generate-bin-tests \
        generate-strip-tests clean

# Runs every suite even when one of them fails, so a single broken format
# does not hide the state of the others, and fails if any of them did.
test:
	@rc=0; \
	$(MAKE) --no-print-directory test-main || rc=1; \
	$(MAKE) --no-print-directory test-noop || rc=1; \
	$(MAKE) --no-print-directory test-bin  || rc=1; \
	exit $$rc

test-main:
	@$(CHECK) \
	for f in $(MAIN_INPUTS); do \
		name=$$(basename $$f .md); \
		for fmt in $(TEXT_FORMATS); do \
			$(PANDOC) $(WRITE) $$f -t $$fmt \
				>$(TMP)_$$name-$$fmt.out 2>$(TMP)_$$name-$$fmt.err; \
			check "$$name ($$fmt)" test/expected/$$name-$$fmt \
				$(TMP)_$$name-$$fmt.out $(TMP)_$$name-$$fmt.err; \
		done; \
	done; \
	exit $$failed

test-noop:
	@$(CHECK) \
	for f in $(UNWRAP_INPUTS); do \
		name=$$(basename $$f .md); \
		for fmt in $(TEXT_FORMATS); do \
			$(PANDOC) $(UNWRAP) $$f -t $$fmt \
				>$(TMP)_$$name-$$fmt.out 2>$(TMP)_$$name-$$fmt.err; \
			check "$$name ($$fmt)" test/expected/$$name-$$fmt \
				$(TMP)_$$name-$$fmt.out $(TMP)_$$name-$$fmt.err; \
		done; \
	done; \
	exit $$failed

# docx/odt are zip archives — compare the applied styles, not the bytes.
test-bin:
	@$(CHECK) $(STYLES) \
	for f in $(MAIN_INPUTS) $(UNWRAP_INPUTS); do \
		name=$$(basename $$f .md); \
		for fmt in $(BIN_FORMATS); do \
			$(PANDOC) $(WRITE) $$f -t $$fmt -o $(TMP)_$$name.$$fmt \
				2>$(TMP)_$$name-$$fmt.err; \
			styles $(TMP)_$$name.$$fmt $$fmt >$(TMP)_$$name-$$fmt.out; \
			check "$$name ($$fmt)" test/expected/$$name-$$fmt \
				$(TMP)_$$name-$$fmt.out $(TMP)_$$name-$$fmt.err; \
		done; \
	done; \
	exit $$failed

test-strip:
	@$(CHECK) \
	for f in $(STRIP_INPUTS); do \
		name=$$(basename $$f .md); \
		$(PANDOC) $(STRIP) $$f -t markdown \
			>$(TMP)_$$name.out 2>$(TMP)_$$name.err; \
		check "$$name" test/expected/$$name $(TMP)_$$name.out $(TMP)_$$name.err; \
	done; \
	exit $$failed

# Quarto tests — the same suites under Quarto's bundled Pandoc, to catch a
# version or a wrapper that behaves differently from a plain pandoc call.
# Delegating rather than repeating the loops means Quarto covers whatever the
# Pandoc targets cover: when docx and odt were added, the copies here were
# left behind and tested less than they appeared to.
test-quarto:
	@$(MAKE) --no-print-directory test PANDOC="$(QUARTO)"

test-quarto-strip:
	@$(MAKE) --no-print-directory test-strip PANDOC="$(QUARTO)"

generate-tests:
	@mkdir -p test/expected
	@$(GENERATE) \
	for f in $(MAIN_INPUTS); do \
		name=$$(basename $$f .md); \
		for fmt in $(TEXT_FORMATS); do \
			generate test/expected/$$name-$$fmt \
				$(PANDOC) $(WRITE) $$f -t $$fmt; \
		done; \
	done

generate-noop-tests:
	@mkdir -p test/expected
	@$(GENERATE) \
	for f in $(UNWRAP_INPUTS); do \
		name=$$(basename $$f .md); \
		for fmt in $(TEXT_FORMATS); do \
			generate test/expected/$$name-$$fmt \
				$(PANDOC) $(UNWRAP) $$f -t $$fmt; \
		done; \
	done

generate-bin-tests:
	@mkdir -p test/expected
	@$(STYLES) \
	for f in $(MAIN_INPUTS) $(UNWRAP_INPUTS); do \
		name=$$(basename $$f .md); \
		for fmt in $(BIN_FORMATS); do \
			$(PANDOC) $(WRITE) $$f -t $$fmt -o $(TMP)_$$name.$$fmt; \
			styles $(TMP)_$$name.$$fmt $$fmt \
				>test/expected/$$name-$$fmt.out; \
			echo "Generated: test/expected/$$name-$$fmt"; \
		done; \
	done

generate-strip-tests:
	@mkdir -p test/expected
	@$(GENERATE) \
	for f in $(STRIP_INPUTS); do \
		name=$$(basename $$f .md); \
		generate test/expected/$$name $(PANDOC) $(STRIP) $$f -t markdown; \
	done

clean:
	rm -f $(TMP)_*