The two came apart silently. PDFBox draws a font's ligatures for the engine, so in + * most of the bundled families {@code ti}, {@code tf} and {@code ft} each became one + * glyph that the font's glyph-to-character map had no entry for — and the letters were + * simply gone from the text layer. {@code Platform} extracted as {@code Pla orm} while the + * page looked perfect. For a CV that is not a cosmetic problem: an applicant tracking + * system parses the text layer, so the keyword an applicant was matched on was not in the + * file, and neither the author nor the renderer had any way to see it.
+ * + *Every preset gets the same document, and the probe words are ordinary English words + * carrying the pairs that broke. Asking for them back is the only check that sees this — + * a rendered page cannot show it, and a layout snapshot holds what the engine meant to + * draw rather than what the file says it drew.
+ */ +class CvPresetTextLayerTest { + + /** + * Words carrying the letter pairs the bundled families ligate, planted in the profile + * paragraph — the one block every preset renders as ordinary prose, rather than + * upper-casing or letter-spacing it into something no extractor would return whole. + */ + private static final ListPDFBox runs a font's {@code GSUB} substitutions itself: the moment a + * {@link PDType0Font} that carries them is made current on a content stream, every + * string shown through it is rewritten from characters into glyph identifiers, and + * {@code ti}, {@code tf} and {@code ft} become one glyph each in most of the + * bundled families. Nothing then records what that glyph meant. The + * {@code ToUnicode} map a subset font carries is built by reading the font's + * character map backwards, and a ligature is reachable from no character at all — + * so the entry is simply absent, and a reader extracting the page loses both + * letters: {@code Platform} comes back as {@code Pla orm}. It is invisible on + * screen and fatal everywhere the text layer is what is actually read — search, + * copy-and-paste, a screen reader, an applicant tracking system parsing a CV.
+ * + *The substitution was never the engine's decision. Layout measures a string + * with {@code getStringWidth}, which knows nothing of ligatures, so a line drawn + * with them is a little narrower than the box measured for it; the DOCX and PPTX + * backends do not substitute either. Turning it off is what makes the PDF draw the + * text this engine actually laid out, and it is the whole fix: with no + * substitution the glyphs come from the character map, and the map back to + * Unicode is complete by construction.
+ * + *What is silenced for a Latin face is the whole of its {@code GSUB}, not the + * ligature features alone: PDFBox applies {@code ccmp}, {@code liga} and + * {@code clig} together and offers no way to keep one without the others. In the + * bundled families that costs nothing — their Latin {@code ccmp} leaves both + * decomposed combining sequences and precomposed letters drawn exactly as before, + * and only the ligature pairs change.
+ * + *Only Latin is silenced. PDFBox also shapes Devanagari, Bengali and Gujarati + * through the same mechanism, and there the substitutions are how the script + * renders rather than a flourish on top of it — a face whose active script is one + * of those keeps them.
+ * + * @param ttf a freshly parsed face + * @param sourceDescription the face's identity, for logging + */ + private static void keepLatinTextSpelled(TrueTypeFont ttf, String sourceDescription) { + try { + GsubData substitutions = ttf.getGsubData(); + if (substitutions != GsubData.NO_DATA_FOUND + && DECORATIVE_SUBSTITUTION_SCRIPT.equals(substitutions.getActiveScriptName())) { + ttf.setEnableGsub(false); + } + } catch (IOException e) { + // A face whose substitution table cannot be read is still a usable face: + // PDFBox will reach the same conclusion and substitute nothing. + log.debug("Unable to read the substitution table of {}", sourceDescription, e); + } + } } diff --git a/render-pdf/src/test/java/com/demcha/compose/document/backend/fixed/pdf/PdfLatinLigatureTextLayerTest.java b/render-pdf/src/test/java/com/demcha/compose/document/backend/fixed/pdf/PdfLatinLigatureTextLayerTest.java new file mode 100644 index 000000000..18bbc9919 --- /dev/null +++ b/render-pdf/src/test/java/com/demcha/compose/document/backend/fixed/pdf/PdfLatinLigatureTextLayerTest.java @@ -0,0 +1,137 @@ +package com.demcha.compose.document.backend.fixed.pdf; + +import static org.assertj.core.api.Assertions.assertThat; + +import com.demcha.compose.GraphCompose; +import com.demcha.compose.document.api.DocumentSession; +import com.demcha.compose.document.style.DocumentInsets; +import com.demcha.compose.document.style.DocumentTextStyle; +import com.demcha.compose.engine.components.content.text.TextDecoration; +import com.demcha.compose.font.DefaultFonts; +import com.demcha.compose.font.FontFamilyDefinition; +import com.demcha.compose.font.FontName; + +import org.apache.fontbox.ttf.model.GsubData; +import org.apache.pdfbox.Loader; +import org.apache.pdfbox.pdmodel.PDDocument; +import org.apache.pdfbox.pdmodel.font.PDFont; +import org.apache.pdfbox.pdmodel.font.PDType0Font; +import org.apache.pdfbox.text.PDFTextStripper; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +/** + * What a bundled Latin family says its own text is, to a reader that is not this engine. + * + *PDFBox runs a font's {@code GSUB} substitutions on the engine's behalf, and most of + * the bundled families define ligatures over the commonest letter pairs in English — + * {@code ti}, {@code tf}, {@code ft}. Each pair drawn that way becomes one glyph, and the + * {@code ToUnicode} map that says what a glyph means is built by reading the font's + * character map backwards, where a ligature is reachable from no character at all. The + * entry is therefore absent and both letters are lost on extraction: {@code Platform} + * comes back as {@code Pla orm}. Nothing about the rendered page shows it.
+ * + *Which makes extraction the only place it can be caught, and the reason this asks for + * the whole sentence back rather than for the presence of a word: a test that looked for + * {@code Pla} would pass on a broken file. The probe is built from the pairs that break — + * a family that stops substituting for some other reason still has to return them.
+ */ +class PdfLatinLigatureTextLayerTest { + + /** + * A sentence of ordinary English words, chosen so that every one of them carries a + * pair the bundled families ligate. Kept to one line at the size rendered, because a + * wrap would put a line break into the extracted text and say nothing about glyphs. + */ + private static final String PROBE = + "Platform certification retired after fifteen notification drafts"; + + /** The letter pairs the bundled families draw as one glyph. */ + private static final List