From ab41d9d09b9d0a3318fe8a9940166c8ac2a1aaf9 Mon Sep 17 00:00:00 2001 From: Pjandro Date: Sun, 8 Nov 2026 21:26:32 +0000 Subject: [PATCH 1/9] =?UTF-8?q?build(core):=20docx4j=2017.3.2=20=E2=86=92?= =?UTF-8?q?=2017.3.6=20=E2=80=94=20=D0=BF=D0=B5=D1=80=D0=B5=D0=B2=D0=B5?= =?UTF-8?q?=D0=BD=D0=B4=D0=BE=D1=80=D0=BA=D0=B0=20docx2fo.xslt=20(AUDIT-FI?= =?UTF-8?q?X-1/2=20=D0=BF=D0=B5=D1=80=D0=B5=D0=BD=D0=B5=D1=81=D0=B5=D0=BD?= =?UTF-8?q?=D1=8B),=20repair=3Dword,=20=D1=83=D0=B4=D0=B0=D0=BB=D0=B5?= =?UTF-8?q?=D0=BD=D0=B8=D0=B5=20=D0=BF=D1=80=D0=B0=D0=B2=D0=B8=D0=BB=20Sym?= =?UTF-8?q?bol/Field=20(=D0=B4=D0=B5=D0=BB=D0=B0=D0=B5=D1=82=20=D1=81?= =?UTF-8?q?=D0=B0=D0=BC=20=D1=8D=D0=BA=D1=81=D0=BF=D0=BE=D1=80=D1=82=2017.?= =?UTF-8?q?3.x)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 6 +- .../ru/pjandro/wordpdf/WordPdfConverter.java | 25 +- .../wordpdf/internal/DocxRewritePipeline.java | 33 +- .../wordpdf/internal/FieldNormalizer.java | 226 -------- .../internal/GlyphCoverageNormalizer.java | 6 +- .../internal/SymbolFontNormalizer.java | 491 ------------------ .../src/main/resources/xslt/docx2fo.xslt | 40 +- .../pjandro/wordpdf/SampleDocxGenerator.java | 9 +- .../pjandro/wordpdf/WordPdfConverterTest.java | 24 +- .../wordpdf/internal/FieldNormalizerTest.java | 233 --------- .../wordpdf/internal/RubyNormalizerTest.java | 2 +- .../internal/SymbolFontNormalizerTest.java | 342 ------------ .../wordpdf/internal/doc/ListsTest.java | 2 +- 13 files changed, 92 insertions(+), 1347 deletions(-) delete mode 100644 wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FieldNormalizer.java delete mode 100644 wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizer.java delete mode 100644 wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/FieldNormalizerTest.java delete mode 100644 wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizerTest.java diff --git a/pom.xml b/pom.xml index a1cfe86..3c6dded 100644 --- a/pom.xml +++ b/pom.xml @@ -22,8 +22,8 @@ UTF-8 - 17.3.2 - 1.28.0 2.0.20 @@ -78,7 +78,7 @@ ${docx4j.version} + docx4j 17.3.6 — 1.28.0; в Boot-BOM 4.1.1 не управляется --> org.apache.commons commons-compress diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java index 7c3cf51..25a6b3a 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java @@ -77,12 +77,18 @@ public final class WordPdfConverter { // classpath'а за шрифтами — всё найденное выбрасывает // BundledFonts.restrictToBundled() перед каждой конвертацией. // Реестр обязан оставаться бандл + встроенные в docx. Свойства читает - // тот же static-блок BestMatchingMapper (docx4j-core 17.3.2); наша + // тот же static-блок BestMatchingMapper (docx4j-core 17.3.6); наша // инициализация предшествует первому new BundledFontMapper(). // discoverJarFonts("fonts-symbol") свойством не гейтится — символ- // шрифт регистрируется как раньше и снимается restrict'ом как раньше. Docx4jProperties.setProperty("docx4j.fonts.discoverPhysicalFonts.enabled", "false"); Docx4jProperties.setProperty("docx4j.fonts.discoverJarFonts.enabled", "false"); + // docx4j 17.3.6 (RepairMode, свойство docx4j.openpackaging.load.repair): + // пакеты, которые Word открывает только через «восстановить», по умолчанию + // (NONE) отказываются грузиться — для конвертера это регрессия 500 на + // «битых, но читаемых Word» файлах. Значение "word" возвращает толерантность + // уровня Word. + Docx4jProperties.setProperty("docx4j.openpackaging.load.repair", "word"); } private WordPdfConverter() { @@ -156,8 +162,8 @@ public final class WordPdfConverter { * считаются ровно раз по сырому входу, до аллокаций docx4j: для .docx — * lightweight-скан по zip, для .doc — по чистому бинарному документу до * конвертации. Повторного скана по нормализованным байтам нет: правила - * 1–10 {@code DocxRewritePipeline} число учитываемых разрывов не - * увеличивают (правило 9 способно только убрать разрыв внутри скрытого + * 1–8 {@code DocxRewritePipeline} число учитываемых разрывов не + * увеличивают (правило 7 способно только убрать разрыв внутри скрытого * рана — счёт по сырому входу остаётся верхней оценкой лимита), а скан * внутри живой JAXB-модели удваивал бы пиковую память. * @@ -435,7 +441,7 @@ public final class WordPdfConverter { } /** - * Нормализация входных байтов (цепочка {@link #normalizers}: правила 1–10 + * Нормализация входных байтов (цепочка {@link #normalizers}: правила 1–8 * одним zip-проходом {@code DocxRewritePipeline} + условная OLE-вычистка) * и {@code WordprocessingMLPackage.load} полученного transitional-байта. * Нормализация переиспользует слот {@code bytes}: каждая замена массива @@ -453,7 +459,7 @@ public final class WordPdfConverter { /** * Конвейер байтовой нормализации docx. Порядок фиксирован: сначала один * zip-проход переписывания XML-частей (внутри части порядок рерайтов - * Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→ + * Strict→OnOff→Invisible→GlyphCoverage→TableIndent→ * NumberingSuffix→Hidden→Ruby значим: Strict первым — дальше transitional-байт; * GlyphCoverage — по финальному тексту рана; Hidden — вырезает скрытые * раны по финальному содержимому; Ruby — разворачивает руби-разметку, @@ -463,10 +469,11 @@ public final class WordPdfConverter { */ private static List normalizers(ConvertOptions options) { return List.of( - // один zip-проход: strict→transitional, on/off, Symbol-PUA, - // поля PAGE/NUMPAGES, невидимки, покрытие глифов, tblInd при - // jc≠left, suff=space, скрытый текст (vanish) — порядок - // рерайтов внутри части фиксирован (DocxRewritePipeline) + // один zip-проход: strict→transitional, on/off, невидимки, + // покрытие глифов, tblInd при jc≠left, suff=space, скрытый + // текст (vanish) — порядок рерайтов внутри части фиксирован + // (DocxRewritePipeline); символьные шрифты и complex-поля + // PAGE/NUMPAGES с docx4j 17.3.x обрабатывает сам экспорт DocxRewritePipeline.STEP, // OLE-объекты: при выключенном errorOnOle тихо удаляем // (часть/rels/w:object), при включённом — DrawingFoundException diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DocxRewritePipeline.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DocxRewritePipeline.java index eefb4c7..032a098 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DocxRewritePipeline.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DocxRewritePipeline.java @@ -15,21 +15,28 @@ import org.apache.commons.compress.utils.SeekableInMemoryByteChannel; /** * Единый zip-проход переписывания XML-частей (.docx) вместо отдельных * проходов нормализаторов: к каждой записи {@code word/*.xml} применяются - * все десять рерайтов в фиксированном порядке - * Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby. + * все восемь рерайтов в фиксированном порядке + * Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby. * Порядок значим: Strict первым — дальше части в transitional-виде * (TableIndent читает transitional-атрибуты {@code w:}); GlyphCoverage - * режет раны по финальному тексту рана (после Symbol/Invisible); Hidden - * последним — вырезает уже финальные раны (после Symbol/GLYPH-разбиений), + * режет раны по финальному тексту рана (после Invisible); Hidden + * последним — вырезает уже финальные раны (после GLYPH-разбиений), * а его OnOff-форма vanish читается после правила 2. Каждый * рерайт работает только содержимым одной части, поэтому по-частная * цепочка эквивалентна последовательным полным проходам. Исключения из - * «по-частности» — контексты, читаемые один раз до цикла: правило 7 + * «по-частности» — контексты, читаемые один раз до цикла: правило 5 * (TableIndent) — у header/footer-частей своей sectPr нет, ширина полосы * передаётся из document.xml (многосекционный документ — полоса - * неоднозначна, header/footer пропускаются); правило 9 (Hidden) — + * неоднозначна, header/footer пропускаются); правило 7 (Hidden) — * стилевые vanish читаются из word/styles.xml (цепочка w:basedOn). * + *

Правил Symbol (символьные шрифты → Unicode) и Field (PAGE/NUMPAGES → + * fldSimple) здесь больше нет: с docx4j 17.3.3/#701 символьные маркеры + * маппит сам экспорт, а с 17.3.5 (CR-067) {@code FieldsCombiner} сворачивает + * complex-поля в {@code w:fldSimple} и внутри {@code w:sdt}. Пины отсутствия + * регрессии — WordPdfConverterTest#symbolFonts_bulletsAreNotHash, + * #pageNumbers_recomputedNotCached. + * *

Неизменённые записи (медиа, rels, прочее) переносятся raw-копией * сжатых байтов — без inflate/deflate; прочие (редкие методы сжатия, * шифрованные) — обычный перенос. Ни одна часть не изменилась → @@ -52,7 +59,7 @@ public final class DocxRewritePipeline { public static final DocxNormalizer STEP = DocxRewritePipeline::normalize; /** - * Применяет десять рерайтов к каждой записи {@code word/*.xml} за один + * Применяет восемь рерайтов к каждой записи {@code word/*.xml} за один * проход zip. * * @param docx байты .docx (валидный zip) @@ -63,7 +70,7 @@ public final class DocxRewritePipeline { boolean changed = false; try (ZipFile zf = new ZipFile(new SeekableInMemoryByteChannel(docx)); ZipArchiveOutputStream zos = new ZipArchiveOutputStream(out)) { - // Ширина полосы набора для правила 7 (таблицы в header/footer- + // Ширина полосы набора для правила 5 (таблицы в header/footer- // частях своей sectPr не содержат): из сырого document.xml — // геометрия инвариантна к рерайтам цепочки (Strict не трогает // w:pgSz/@w:w, а pgMar-чередование left|start покрывает strict). @@ -76,7 +83,7 @@ public final class DocxRewritePipeline { new String(zf.getInputStream(docEntry).readAllBytes(), StandardCharsets.UTF_8)); } - // Стилевые vanish для правила 9 (скрытый текст): часть стилевой + // Стилевые vanish для правила 7 (скрытый текст): часть стилевой // цепочки w:basedOn вычисляется один раз до цикла. Записи нет → // пустое множество, рерайт работает по прямому vanish. Set hiddenStyles = Set.of(); @@ -101,14 +108,6 @@ public final class DocxRewritePipeline { if (next != null) { cur = next; } - next = SymbolFontNormalizer.rewrite(cur); - if (next != null) { - cur = next; - } - next = FieldNormalizer.rewrite(cur); - if (next != null) { - cur = next; - } next = InvisibleCharNormalizer.rewrite(cur); if (next != null) { cur = next; diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FieldNormalizer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FieldNormalizer.java deleted file mode 100644 index 78a26d1..0000000 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FieldNormalizer.java +++ /dev/null @@ -1,226 +0,0 @@ -package ru.pjandro.wordpdf.internal; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.nio.charset.StandardCharsets; -import java.util.Locale; -import java.util.zip.ZipEntry; -import java.util.zip.ZipInputStream; -import java.util.zip.ZipOutputStream; - -/** - * Разворачивание «сложных» полей PAGE/NUMPAGES в {@code w:fldSimple} — - * до загрузки docx4j. - * - * Word записывает поле как последовательность ранов: - * {@code fldChar begin} → {@code instrText "PAGE"} → {@code fldChar separate} - * → закэшированный результат → {@code fldChar end}. Экспорт docx4j в XSL-FO - * игнорирует {@code w:instrText} внутри такого поля и печатает кэш из docx, - * поэтому в колонтитулах всех страниц стоит одно и то же число - * (в эталонном экспорте Word — «2» вместо 1, 2, 3 …). - * - * Собственно поле docx4j умеет: {@code w:fldSimple} обрабатывает - * {@code FldSimpleWriter} из docx4j-export-fo, у которого есть обработчики - * {@code PAGE} (→ {@code fo:page-number}), {@code NUMPAGES} и - * {@code SECTIONPAGES}. Поэтому переписываем поле в {@code w:fldSimple}, - * сохраняя внутри закэшированные ран — они дают оформление (шрифт, размер). - * - * Штатный {@code FieldsCombiner} docx4j делает то же самое, но не заходит - * внутрь {@code w:sdt}: нумерация страниц Word почти всегда лежит в - * контентном контроле («Page Numbers (Top of Page)»), и до поля не добирается. - * Отсюда и нормализация байтов, как в {@link DocxOnOffNormalizer}. - * - * Трогаются только поля, которые действительно есть кому рисовать - * ({@link #SUPPORTED}); остальные остаются как были. Вложенные поля не - * разбираются — если внутри {@code begin … end} встречается ещё один - * {@code begin}, поле пропускается. - */ -final class FieldNormalizer { - - /** Инструкции, для которых в docx4j-export-fo есть обработчик fldSimple. */ - private static final String[] SUPPORTED = {"PAGE", "NUMPAGES", "SECTIONPAGES"}; - - private FieldNormalizer() { - } - - /** Шаг конвейера WordPdfConverter#normalizers: этот нормализатор как DocxNormalizer. */ - static final DocxNormalizer STEP = FieldNormalizer::normalize; - - /** - * Переписывает поддерживаемые поля во всех word/*.xml частях docx. - * - * @param docx байты .docx (zip) - * @return те же или переупакованные байты - */ - static byte[] normalize(byte[] docx) throws IOException { - ByteArrayOutputStream out = new ByteArrayOutputStream(docx.length); - boolean changed = false; - try (ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(docx)); - ZipOutputStream zos = new ZipOutputStream(out)) { - ZipEntry entry; - while ((entry = zis.getNextEntry()) != null) { - byte[] data = zis.readAllBytes(); - String name = entry.getName(); - if (name.startsWith("word/") && name.endsWith(".xml")) { - String fixed = rewrite(new String(data, StandardCharsets.UTF_8)); - if (fixed != null) { - changed = true; - data = fixed.getBytes(StandardCharsets.UTF_8); - } - } - zos.putNextEntry(new ZipEntry(name)); - zos.write(data); - zos.closeEntry(); - } - } - return changed ? out.toByteArray() : docx; - } - - /** - * @return новая строка либо null, если менять нечего - */ - static String rewrite(String xml) { - if (xml.indexOf("fldCharType=\"begin\"") < 0) { - return null; - } - StringBuilder sb = new StringBuilder(xml.length()); - int pos = 0; - boolean changed = false; - while (true) { - int begin = xml.indexOf("fldCharType=\"begin\"", pos); - if (begin < 0) { - break; - } - int runStart = runStart(xml, begin); - int runEnd = xml.indexOf(RUN_CLOSE, begin); - if (runStart < 0 || runEnd < 0) { - break; - } - runEnd += RUN_CLOSE.length(); - - int end = xml.indexOf("fldCharType=\"end\"", runEnd); - int endRunEnd = end < 0 ? -1 : endRunEnd(xml, end); - int nested = xml.indexOf("fldCharType=\"begin\"", runEnd); - // поле без конца, битое или с вложенным полем — пропускаем целиком - int skipTo = endRunEnd >= 0 ? endRunEnd : runEnd; - if (endRunEnd < 0 || (nested >= 0 && nested < end)) { - sb.append(xml, pos, skipTo); - pos = skipTo; - continue; - } - - String instr = instruction(xml.substring(runStart, endRunEnd)); - if (instr.isBlank() || !isSupported(instr)) { - sb.append(xml, pos, endRunEnd); - pos = endRunEnd; - continue; - } - sb.append(xml, pos, runStart) - .append(toFldSimple(instr, cached(xml, runEnd, end))); - pos = endRunEnd; - changed = true; - } - if (!changed) { - return null; - } - return sb.append(xml, pos, xml.length()).toString(); - } - - private static final String RUN_CLOSE = ""; - - /** - * Результат поля: ран-маркер {@code separate} и всё, что идёт после него - * до рана с {@code end}. Если {@code separate} нет, кэша нет — поле - * отрисует обработчик. - */ - private static String cached(String xml, int from, int endMarker) { - int sep = xml.indexOf("fldCharType=\"separate\"", from); - int sepRunEnd = xml.indexOf(RUN_CLOSE, sep); - if (sep < 0 || sep > endMarker || sepRunEnd < 0) { - return ""; - } - sepRunEnd += RUN_CLOSE.length(); - int endRunStart = runStart(xml, endMarker); - if (endRunStart < 0 || endRunStart < sepRunEnd) { - return ""; - } - return xml.substring(sepRunEnd, endRunStart); - } - - /** Склеивает все {@code w:instrText} блока — Word дробит инструкцию на части. */ - private static String instruction(String block) { - StringBuilder instr = new StringBuilder(64); - int pos = 0; - while (true) { - int open = block.indexOf("', open); - int close = block.indexOf("", gt); - if (gt < 0 || close < 0) { - break; - } - instr.append(unescape(block.substring(gt + 1, close))); - pos = close + "".length(); - } - // не trim(): пробелы вокруг инструкции — часть записи Word - return instr.toString(); - } - - private static boolean isSupported(String instr) { - String name = instr.trim().split("[\\\\\\s]", 2)[0].toUpperCase(Locale.ROOT); - for (String s : SUPPORTED) { - if (s.equals(name)) { - return true; - } - } - return false; - } - - private static String toFldSimple(String instr, String cached) { - return "" - + cached + ""; - } - - /** Начало рана, содержащего позицию {@code idx} (раны не вложены). */ - private static int runStart(String xml, int idx) { - for (int i = xml.lastIndexOf("= 0; i = xml.lastIndexOf("= xml.length()) { - continue; - } - char next = xml.charAt(i + 4); - if (next != '>' && next != ' ') { - continue; - } - // между найденным открытием и idx не должно быть конца рана - if (xml.indexOf(RUN_CLOSE, i) > idx) { - return i; - } - } - return -1; - } - - /** Позиция сразу за {@code } рана, содержащего {@code idx}. */ - private static int endRunEnd(String xml, int idx) { - int end = xml.indexOf(RUN_CLOSE, idx); - return end < 0 ? -1 : end + RUN_CLOSE.length(); - } - - private static String escapeAttr(String value) { - return value.replace("&", "&") - .replace("<", "<") - .replace(">", ">") - .replace("\"", """); - } - - private static String unescape(String value) { - String v = value; - if (v.indexOf('&') < 0) { - return v; - } - v = v.replace("<", "<").replace(">", ">").replace(""", "\""); - return v.replace("&", "&"); - } -} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizer.java index dfdda09..eaefbe0 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizer.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizer.java @@ -52,7 +52,8 @@ import java.util.concurrent.ConcurrentHashMap; * честнее оставить, чем подменять случайным шрифтом. * * - * Как и {@link SymbolFontNormalizer}, правим байты zip до JAXB-разбора. + * Как и прочие рерайты {@link DocxRewritePipeline}, правим байты zip до + * JAXB-разбора. */ final class GlyphCoverageNormalizer { @@ -128,8 +129,7 @@ final class GlyphCoverageNormalizer { * Проходит блоки {@code } ... {@code } и заменяет каждый через * {@link #rewriteBlock}. Вложенные раны текстбоксов (w:r → w:drawing → * txbxContent → w:r) переписываются рекурсивно по телу внешнего блока — - * каркас внешнего рана остаётся нетронутым. Приём общий с - * {@link SymbolFontNormalizer}. + * каркас внешнего рана остаётся нетронутым. */ private static String rewriteBlocks(String xml, String tag) { String open = "<" + tag; diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizer.java deleted file mode 100644 index cdf26a2..0000000 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizer.java +++ /dev/null @@ -1,491 +0,0 @@ -package ru.pjandro.wordpdf.internal; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.nio.charset.StandardCharsets; -import java.util.HashMap; -import java.util.Locale; -import java.util.Map; -import java.util.regex.Matcher; -import java.util.regex.Pattern; -import java.util.zip.ZipEntry; -import java.util.zip.ZipInputStream; -import java.util.zip.ZipOutputStream; - -/** - * Замена символьных шрифтов (Symbol/Wingdings/Webdings) на Unicode + - * бандл-шрифт — до загрузки docx4j. - * - * Word хранит маркеры списков и спецсимволы кодами из private use area - * (U+F0xx), а какой именно глиф покажет документ, задаёт шрифт: - * {@code } + {@code w:rFonts w:ascii="Wingdings"} - * — это «▪», а тот же код в Symbol — «♣». Экспорт docx4j в XSL-FO эти - * шрифты не знает: код уходит в fallback-семейство, глифа там нет, и FOP - * рисует {@code .notdef} — в PDF решётку «#» (регрессия: - * {@code WordPdfConverterTest#symbolFonts_bulletsAreNotHash}). - * - * Делаем то же, что Word: код из PUA заменяем его Unicode-эквивалентом, - * а имя шрифта — на fallback-семейство (в нём этих глифов достаточно). - * Таблица кодов — из {@code org.docx4j.convert.out.common.writer.SymbolMapper} - * (docx4j 17.x), отфильтрована по наличию глифа в DejaVu Sans; она же - * сверяется с эталоном Word (develop/, вне git). - * - * Обрабатываются оба места, где встречается символный шрифт: - *

    - *
  • {@code w:lvl} (numbering.xml): {@code w:lvlText/@w:val} + - * {@code w:lvl/w:rPr/w:rFonts} — маркеры списков;
  • - *
  • {@code w:r}: текст в {@code w:t} и элементы {@code w:sym} - * ({@code w:sym} имеет собственный {@code w:font}, поэтому ран с ним - * разрезается на части — иначе соседнему тексту поменялся бы шрифт).
  • - *
- * - * Как и {@link DocxOnOffNormalizer}, правим байты zip до JAXB-разбора. - */ -final class SymbolFontNormalizer { - - /** Семейство, на которое заменяются символьные шрифты (есть в jar). */ - static final String REPLACEMENT_FAMILY = "DejaVu Sans"; - - /** - * Имя шрифта (lowercase) -> таблица из 256 слотов по 4 hex-цифры: - * младший байт кода из PUA -> Unicode-код цели (0 — соответствия нет). - * Источник — SymbolMapper из docx4j 17.x; сгенерировано, см. javadoc - * класса. Коды вне U+F000–U+F0FF (обычная ASCII-часть символьного - * шрифта) не переписываются. - */ - private static final Map SYMBOL_MAPS = buildMaps(); - - /** w:rFonts с именем символьного шрифта в любом из атрибутов. */ - private static final Pattern SYMBOL_FONT_ATTR = Pattern.compile( - "w:(?:ascii|hAnsi|cs|eastAsia)=\"([^\"]+)\""); - - /** w:sym w:font="Symbol" w:char="F02D" */ - private static final Pattern SYM_ELEMENT = Pattern.compile( - "]*?/>"); - - private static final Pattern SYM_FONT = Pattern.compile("w:font=\"([^\"]+)\""); - private static final Pattern SYM_CHAR = Pattern.compile("w:char=\"([0-9A-Fa-f]{4})\""); - - private SymbolFontNormalizer() { - } - - /** Шаг конвейера WordPdfConverter#normalizers: этот нормализатор как DocxNormalizer. */ - static final DocxNormalizer STEP = SymbolFontNormalizer::normalize; - - /** - * Заменяет символьные шрифты в XML-частях docx (word/*.xml). - * - * @param docx байты .docx (zip) - * @return те же или переупакованные байты - */ - static byte[] normalize(byte[] docx) throws IOException { - ByteArrayOutputStream out = new ByteArrayOutputStream(docx.length); - boolean changed = false; - try (ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(docx)); - ZipOutputStream zos = new ZipOutputStream(out)) { - ZipEntry entry; - while ((entry = zis.getNextEntry()) != null) { - byte[] data = zis.readAllBytes(); - String name = entry.getName(); - if (name.startsWith("word/") && name.endsWith(".xml")) { - String fixed = rewrite(new String(data, StandardCharsets.UTF_8)); - if (fixed != null) { - changed = true; - data = fixed.getBytes(StandardCharsets.UTF_8); - } - } - zos.putNextEntry(new ZipEntry(name)); - zos.write(data); - zos.closeEntry(); - } - } - return changed ? out.toByteArray() : docx; - } - - /** - * Переписывает {@code w:lvl} и {@code w:r} с символьными шрифтами. - * - * @return новая строка либо null, если менять нечего - */ - static String rewrite(String xml) { - // Быстрый путь: ни кода из PUA (U+F000–U+F0FF), ни w:sym. - if (!hasPua(xml) && xml.indexOf("} ... {@code } и заменяет каждый через - * {@link #rewriteBlock}. Вложенные раны текстбоксов (w:r → w:drawing → - * txbxContent → w:r) переписываются рекурсивно по телу внешнего блока — - * каркас внешнего рана остаётся нетронутым (тот же приём, что в - * {@link GlyphCoverageNormalizer}). - */ - private static String rewriteBlocks(String xml, String tag) { - String open = "<" + tag; - String close = ""; - StringBuilder sb = new StringBuilder(xml.length()); - int pos = 0; - while (true) { - int start = indexOfOpenTag(xml, open, pos); - if (start < 0) { - break; - } - int openEnd = xml.indexOf('>', start); - int end = xml.indexOf(close, openEnd); - if (openEnd < 0 || end < 0) { - break; - } - int matching = matchingClose(xml, open, close, openEnd); - if (matching > end) { - // Внешний ран с вложенным: тело — рекурсивно, каркас внешнего не трогаем. - sb.append(xml, pos, start).append(xml, start, openEnd + 1) - .append(rewriteBlocks(xml.substring(openEnd + 1, matching), tag)) - .append(close); - pos = matching + close.length(); - continue; - } - end += close.length(); - String block = xml.substring(start, end); - sb.append(xml, pos, start).append(rewriteBlock(block)); - pos = end; - } - if (pos == 0) { - return xml; - } - return sb.append(xml, pos, xml.length()).toString(); - } - - /** Есть ли в строке символ из U+F000–U+F0FF. */ - private static boolean hasPua(String xml) { - for (int i = 0; i < xml.length(); i++) { - char c = xml.charAt(i); - if (c >= 0xF000 && c <= 0xF0FF) { - return true; - } - } - return false; - } - - /** Позиция открывающего (не самозакрывающегося) тега {@code open}. */ - private static int indexOfOpenTag(String xml, String open, int from) { - int i = xml.indexOf(open, from); - while (i >= 0) { - char next = i + open.length() < xml.length() ? xml.charAt(i + open.length()) : 0; - if (next == '>' || next == ' ' || next == '\t' || next == '\n' || next == '\r') { - int openEnd = xml.indexOf('>', i); - if (openEnd < 0) { - return -1; - } - // самозакрывающийся — блока нет - return xml.charAt(openEnd - 1) == '/' ? indexOfOpenTag(xml, open, openEnd) : i; - } - i = xml.indexOf(open, i + open.length()); - } - return -1; - } - - /** Позиция закрывающего тега, балансирующего открывающий тег на openEnd; -1 — не сбалансирован. */ - private static int matchingClose(String xml, String open, String close, int openEnd) { - int depth = 1; - int i = openEnd; - while (i < xml.length()) { - int nextOpen = indexOfOpenTag(xml, open, i); - int nextClose = xml.indexOf(close, i); - if (nextClose < 0) { - return -1; - } - if (nextOpen >= 0 && nextOpen < nextClose) { - depth++; - i = nextOpen + open.length(); - } else { - depth--; - if (depth == 0) { - return nextClose; - } - i = nextClose + close.length(); - } - } - return -1; - } - - /** Переписывает один блок {@code w:lvl} или {@code w:r}. */ - private static String rewriteBlock(String block) { - String symbolFont = symbolFontOf(block); - String map = symbolFont == null ? null : SYMBOL_MAPS.get(symbolFont.toLowerCase(Locale.ROOT)); - boolean hasSym = block.indexOf("= 0; - if (map == null && !hasSym) { - return block; - } - // w:sym имеет собственный w:font, поэтому обрабатывается и в ране - // с обычным шрифтом (например, Times New Roman + Symbol). - String result = hasSym ? replaceSymElements(block, map) : block; - if (map == null) { - return result; - } - result = mapPua(result, map); - return replaceFontNames(result); - } - - /** Имя символьного шрифта, объявленного в {@code w:rFonts} блока. */ - private static String symbolFontOf(String block) { - int rFonts = block.indexOf("', rFonts); - if (end < 0) { - return null; - } - Matcher m = SYMBOL_FONT_ATTR.matcher(block.substring(rFonts, end)); - while (m.find()) { - String name = m.group(1).toLowerCase(Locale.ROOT); - if (SYMBOL_MAPS.containsKey(name)) { - return m.group(1); - } - } - return null; - } - - /** - * Заменяет коды из U+F000–U+F0FF на Unicode по таблице {@code map}. - * Касается {@code w:t}, {@code w:lvlText/@w:val} и текста самого блока. - */ - private static String mapPua(String block, String map) { - StringBuilder sb = new StringBuilder(block.length()); - for (int i = 0; i < block.length(); i++) { - char c = block.charAt(i); - if (c >= 0xF000 && c <= 0xF0FF) { - char mapped = mapped(map, c & 0xFF); - sb.append(mapped != 0 ? mapped : c); - } else { - sb.append(c); - } - } - return sb.toString(); - } - - /** - * Разрезает ран по элементам {@code w:sym}: каждый заменяется раном с - * {@code w:t} (Unicode-глиф) и fallback-шрифтом, соседний текст - * остаётся со своим {@code w:rPr}. - */ - private static String replaceSymElements(String block, String map) { - if (!block.endsWith("")) { - return block; - } - int tagEnd = block.indexOf('>'); - String openTag = block.substring(0, tagEnd + 1); - String body = block.substring(tagEnd + 1, block.length() - "".length()); - - String rPr = ""; - if (body.startsWith("")) { - int rPrEnd = body.indexOf(""); - if (rPrEnd < 0) { - return block; - } - rPr = body.substring(0, rPrEnd + "".length()); - body = body.substring(rPrEnd + "".length()); - } - String fallbackRPr = rPr.isEmpty() - ? "" - : forceFont(rPr, REPLACEMENT_FAMILY); - - StringBuilder sb = new StringBuilder(block.length()); - int pos = 0; - Matcher m = SYM_ELEMENT.matcher(body); - while (m.find()) { - String text = body.substring(pos, m.start()); - if (!text.isEmpty()) { - sb.append(openTag).append(rPr).append(text).append(""); - } - String charHex = firstGroup(SYM_CHAR, m.group()); - String font = firstGroup(SYM_FONT, m.group()); - String fontMap = font == null ? map - : SYMBOL_MAPS.getOrDefault(font.toLowerCase(Locale.ROOT), map); - char mapped = 0; - if (charHex != null && fontMap != null) { - char code = (char) Integer.parseInt(charHex, 16); - if (code >= 0xF000 && code <= 0xF0FF) { - mapped = mapped(fontMap, code & 0xFF); - } - } - if (mapped != 0) { - sb.append(openTag).append(fallbackRPr) - .append("").append(mapped) - .append(""); - } - pos = m.end(); - } - if (pos == 0) { - return block; - } - String tail = body.substring(pos); - if (!tail.isEmpty()) { - sb.append(openTag).append(rPr).append(tail).append(""); - } - return sb.toString(); - } - - /** - * Принудительно ставит семейство в {@code w:rPr}: заменяет значения - * атрибутов {@code w:rFonts}, а если {@code w:rFonts} нет — вставляет - * его первым ребёнком (так делает Word). - */ - private static String forceFont(String rPr, String family) { - if (rPr.indexOf("", ""); - } - Matcher m = SYMBOL_FONT_ATTR.matcher(rPr); - StringBuilder sb = new StringBuilder(rPr.length()); - while (m.find()) { - m.appendReplacement(sb, Matcher.quoteReplacement( - m.group().replace(m.group(1), family))); - } - m.appendTail(sb); - return sb.toString(); - } - - /** Имена символьных шрифтов в {@code w:rFonts} -> fallback-семейство. */ - private static String replaceFontNames(String block) { - Matcher m = SYMBOL_FONT_ATTR.matcher(block); - if (!m.find()) { - return block; - } - m.reset(); - StringBuilder sb = new StringBuilder(block.length()); - while (m.find()) { - String replacement = SYMBOL_MAPS.containsKey(m.group(1).toLowerCase(Locale.ROOT)) - ? m.group().replace(m.group(1), REPLACEMENT_FAMILY) - : m.group(); - m.appendReplacement(sb, Matcher.quoteReplacement(replacement)); - } - m.appendTail(sb); - return sb.toString(); - } - - private static String firstGroup(Pattern p, String input) { - Matcher m = p.matcher(input); - return m.find() ? m.group(1) : null; - } - - /** Unicode-код цели для младшего байта кода PUA; 0 — соответствия нет. */ - private static char mapped(String map, int slot) { - int hi = Character.digit(map.charAt(slot * 4), 16) << 12 - | Character.digit(map.charAt(slot * 4 + 1), 16) << 8 - | Character.digit(map.charAt(slot * 4 + 2), 16) << 4 - | Character.digit(map.charAt(slot * 4 + 3), 16); - return (char) hi; - } - - private static Map buildMaps() { - Map m = new HashMap<>(); - m.put("symbol", MAP_SYMBOL); - m.put("wingdings", MAP_WINGDINGS); - m.put("wingdings 2", MAP_WINGDINGS_2); - m.put("wingdings 3", MAP_WINGDINGS_3); - m.put("webdings", MAP_WEBDINGS); - return Map.copyOf(m); - } - - // Symbol: 256 слотов по 4 hex-цифры, индекс = младший байт кода U+F0?? - private static final String MAP_SYMBOL = - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000002122000023220300250026220D002800292217002B002C2212002E002F" + - "0030003100320033003400350036003700380039003A003B003C003D003E003F" + - "22450391039203A70394039503A603930397039903D1039A039B039C039D039F" + - "03A0039803A103A303A403A503C203A9039E03A80396005B2234005D22A5005F" + - "000003B103B203C703B403B503C603B303B703B903D503BA03BB03BC03BD03BF" + - "03C003B803C103C303C403C503D603C903BE03C803B6007B007C007D223C0000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "000003D2203222642044221E0192266326662665266021942190219121922193" + - "00B000B12033226500D7221D2202202200F7226022612248202623D023AF21B5" + - "21352111211C21182297229522052229222A2283228722842282228622082209" + - "2220220700AE00A92122220F221A22C500AC2227222821D421D021D121D221D3" + - "25CA232900AE00A921222211239B239C239D23A123A223A323A723A823A923AA" + - "20AC232A222B232023AE2321239E239F23A023A423A523A623AB23AC23AD0000"; - - // Wingdings: 256 слотов по 4 hex-цифры, индекс = младший байт кода U+F0?? - private static final String MAP_WINGDINGS = - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000027022701000000000000000000002706000000000000000000000000" + - "000000000000000000000000231B00000000000000000000000000002707270D" + - "0000270C000000000000261C261E261D261F0000263A00002639000026200000" + - "00002708263C000027440000271E000027202721262A262F0950263826482649" + - "264A264B264C264D264E264F26502651265226530000000025CF000025A025A1" + - "0000275127522B2729EB25C627562B2523272BB9231800000000000000000000" + - "24EA246024612462246324642465246624672468246924FF2776277727782779" + - "277A277B277C277D277E277F0000000000000000000000000000000000B72022" + - "25AA26AA0000000025C925CE000025AA25FB0000272626052736273427392735" + - "2BD0231627E123112BD1272A2730000000000000000000000000000000000000" + - "0000000000002BB02BB12BB22BB32BB42BB52BB62BB700000000000000000000" + - "00000000000000000000232B23262B9827A22B992B9B2B882B8A2B892B8B0000" + - "00000000000000000000000000000000000000000000000000000000000021E6" + - "21E821E721E92B0421F32B002B012B032B02000000000000271300000000229E"; - - // Wingdings 2: 256 слотов по 4 hex-цифры, индекс = младший байт кода U+F0?? - private static final String MAP_WINGDINGS_2 = - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000027042700000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "271300002611261226122BBE2BBF29B829B80000000000000000203D00000000" + - "00000000000000000000000000000000000024EA246024612462246324642465" + - "246624672468246924FF2776277727782779277A277B277C277D277E277F0000" + - "26090000263D263E2E3F271D0000000000000000000000000000000000000000" + - "00000000000000000000202225CF26AB2B240000000000000000000029BF25FE" + - "25A025FC2B1B2B1C000000000000000025A30000000000002B292B2525C625C7" + - "000025C80000000000002B2A2B2729EB25CA000025D625D72BCA2BCB25FC2B25" + - "2B1F2BC22B232B222BC32BC40000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000027260000260527360000273700000000" + - "273900000000272F000000002BCC2BCD203B2042000000000000000000000000"; - - // Wingdings 3: 256 слотов по 4 hex-цифры, индекс = младший байт кода U+F0?? - private static final String MAP_WINGDINGS_3 = - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "00002B602B622B612B632B662B672B692B682B702B722B712B732B762B782B7B" + - "2B7D2B642B652B6A2B6C2B6B2B6D2B4D2BA02BA12BA22BA32BA42BA52BA62BA7" + - "2B902B912B922B932B802B832B7E2B7F2B842B862B852B872B8F2B8D2B8E2B8C" + - "2B6E2B6F238B23242303232523B5237D21EA2BB8000000000000000000000000" + - "0000000000000000000000002190219221912193219621972199219800000000" + - "25B225BC25B325BD25C425BA25C125B725E325E225E425E50000000000000000" + - "000025B225BC25C025B62B9C2B9E2B9D2B9F0000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000002BA82BA92BAA2BAB2BAC2BAD2BAE" + - "2BAF000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000"; - - // Webdings: 256 слотов по 4 hex-цифры, индекс = младший байт кода U+F0?? - private static final String MAP_WEBDINGS = - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "00000000000023F423F523F623F723EA23E923EE23ED23F823F923FA00000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "2B942714000025A100000000000025A000000000000000000000000026AB0000" + - "000000000000275300000000000026F30000229600000000007C000000000000" + - "000000000000000000000000000026F700000000000000000000000000000000" + - "00000000000000000000000000000000272F0000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000" + - "0000000000000000000000000000000000002601000000000000000000000000" + - "0000000000000000000000000000000024C5267F000000000000000000000000" + - "0000000000000000000000000000000000000000000000000000000000000000"; -} diff --git a/wordpdf-core/src/main/resources/xslt/docx2fo.xslt b/wordpdf-core/src/main/resources/xslt/docx2fo.xslt index 264924b..2277583 100644 --- a/wordpdf-core/src/main/resources/xslt/docx2fo.xslt +++ b/wordpdf-core/src/main/resources/xslt/docx2fo.xslt @@ -401,7 +401,10 @@ - + + - - - + + + + + + + + + 
 + @@ -867,7 +886,15 @@ - + + + + 
 + + + + + @@ -1116,7 +1143,8 @@ AbstractVisitorExporterGenerator.walkJAXBElements. @since 17.1.0 --> + select="mc:Choice[java:org.docx4j.utils.XSLTUtils.mcPrefersChoice(string(@Requires)) + or java:org.docx4j.utils.XSLTUtils.mcSelectsChoice($conversionContext, .)][1]"/> " - + "" + instr - + "" - + "" - + "" + cached + "" - + ""; - } - - @Test - void pageFieldBecomesFldSimple() { - String xml = "" + field(" PAGE \\* MERGEFORMAT ", "2") + ""; - String out = FieldNormalizer.rewrite(xml); - - assertTrue(out.startsWith(""), - out); - // кэш остаётся внутри — он даёт оформление (шрифт, размер) - assertTrue(out.contains("2"), out); - assertTrue(out.endsWith(""), out); - assertTrue(!out.contains("fldChar"), "fldChar не удалён: " + out); - } - - @Test - void numpagesAndSectionpagesAreSupported() { - for (String instr : new String[]{" NUMPAGES \\* ARABIC ", " SECTIONPAGES "}) { - String out = FieldNormalizer.rewrite("" + field(instr, "11") + ""); - assertTrue(out.contains(""), instr + ": " + out); - } - } - - /** Инструкцию Word дробит на несколько w:instrText — их нужно склеить. */ - @Test - void instructionSplitAcrossRuns() { - String xml = "" - + " NUM" - + "PAGES " - + "" - + "11" - + ""; - String out = FieldNormalizer.rewrite(xml); - - assertTrue(out.contains(""), out); - } - - @Test - void otherFieldsUntouched() { - String xml = "" + field(" HYPERLINK \"https://example.com\" ", "ссылка") - + ""; - assertNull(FieldNormalizer.rewrite(xml), "чужое поле переписано"); - } - - /** Вложенное поле: разбирать его не берёмся, но и ломать не должны. */ - @Test - void nestedFieldUntouched() { - String xml = "" - + "" - + "= PAGE " - + field(" PAGE ", "2") - + ""; - assertNull(FieldNormalizer.rewrite(xml), "вложенное поле переписано"); - } - - /** Соседние ран-свойства и остальной документ остаются без изменений. */ - @Test - void surroundingContentPreserved() { - String xml = "" - + "до" + field(" PAGE ", "2") - + "после"; - String out = FieldNormalizer.rewrite(xml); - - assertTrue(out.startsWith("" - + "до"), out); - assertTrue(out.endsWith("после"), out); - } - - /** Поле внутри w:sdt — так Word пишет нумерацию «Page Numbers (Top of Page)». */ - @Test - void fieldInsideSdt() { - String xml = "" - + field(" PAGE ", "2") + ""; - String out = FieldNormalizer.rewrite(xml); - - assertTrue(out.startsWith("" - + ""), out); - } - - @Test - void nothingToChangeReturnsNull() { - assertNull(FieldNormalizer.rewrite("текст")); - } - - /** Поле без separate/end — битое, пропускаем, остальное не трогаем. */ - @Test - void unterminatedFieldSkipped() { - String xml = "" - + " PAGE "; - assertNull(FieldNormalizer.rewrite(xml)); - } - - /** Кавычка и ampersand в инструкции не должны сломать атрибут. */ - @Test - void instructionEscapedIntoAttribute() { - String out = FieldNormalizer.rewrite( - "" + field(" STYLEREF \"Раздел & номер\" ", "1") + ""); - // STYLEREF не поддерживается — поле должно остаться как было - assertNull(out); - - String page = FieldNormalizer.rewrite( - "" + field(" PAGE ", "1") + ""); - assertEquals("" - + "1" - + "", page); - } - - /** Маркер begin без единого до него — поле-контейнер не найти, пропускаем. */ - @Test - void beginWithoutAnyRun_skipped() { - assertNull(FieldNormalizer.rewrite("fldCharType=\"begin\"")); - } - - /** begin после закрытого рана: ран-контейнер не найден — пропускаем. */ - @Test - void beginOutsideRun_skipped() { - assertNull(FieldNormalizer.rewrite( - "доfldCharType=\"begin\"")); - } - - /** Ран с begin не закрыт — битое поле, пропускаем. */ - @Test - void beginRunUnclosed_skipped() { - assertNull(FieldNormalizer.rewrite( - "" - + ""; - assertNull(FieldNormalizer.rewrite(xml)); - } - - /** PAGE без separate: кэша нет — fldSimple пустой, число нарисует обработчик. */ - @Test - void fieldWithoutSeparate_emptyFldSimple() { - String xml = "" - + " PAGE " - + ""; - assertEquals("", - FieldNormalizer.rewrite(xml)); - } - - /** separate другого поля после end: кэшем этого поля оно быть не может. */ - @Test - void separateAfterFieldEnd_notCapturedAsCache() { - String xml = "" - + " PAGE " - + "" - + ""; - String out = FieldNormalizer.rewrite(xml); - - assertTrue(out.startsWith(""), out); - assertTrue(out.endsWith(""), out); - } - - /** end вне рана: начало его рана не найти — кэш не берём, поле переписываем пустым. */ - @Test - void endMarkerOutsideRun_noCacheCaptured() { - String xml = "" - + " PAGE " - + "" - + "2" - + "fldCharType=\"end\"" - + "после"; - assertEquals("", - FieldNormalizer.rewrite(xml)); - } - - /** separate и end в одном ране: «кэш» лежал бы раньше маркера — не берём. */ - @Test - void separateAndEndInOneRun_noCacheCaptured() { - String xml = "" - + " PAGE " - + "" - + ""; - assertEquals("", - FieldNormalizer.rewrite(xml)); - } - - /** instrText без закрывающего тега: инструкцию не собрать — поле остаётся. */ - @Test - void unclosedInstrText_fieldSkipped() { - String xml = "" - + " PAGE " - + ""; - assertNull(FieldNormalizer.rewrite(xml)); - } - - /** Ран с атрибутами () — корректное открытие рана, поле переписывается. */ - @Test - void runWithAttributes_fieldRewritten() { - String xml = "" - + " PAGE " - + "" - + "2" - + ""; - String out = FieldNormalizer.rewrite(xml); - - assertTrue(out.startsWith(""), out); - assertTrue(out.contains("2"), "кэш потерян: " + out); - } - - /** Ран с end не закрыт — поле битое, пропускаем. */ - @Test - void endRunUnclosed_fieldSkipped() { - String xml = "" - + " PAGE " - + " ▪, Symbol F0B7 -> •, F02D -> −. */ - private static final String NUMBERING_XML = - "" - + "" - + "" - + "" - + "" - + "" - + "" - + "" - + "" - + "" - + "" - + "" - + ""; - - /** Символьный шрифт в ране + w:sym с собственным w:font. */ - private static final String DOCUMENT_XML = - "" - + "" - + "\uF0B7 хвостик" - + "" - + "до " - + " после" - + "" - + "обычный текст" - + ""; - - private static byte[] makeDocx(String documentXml, String numberingXml) throws IOException { - ByteArrayOutputStream out = new ByteArrayOutputStream(); - try (ZipOutputStream zos = new ZipOutputStream(out)) { - zos.putNextEntry(new ZipEntry("[Content_Types].xml")); - zos.write("\uF0A7".getBytes(StandardCharsets.UTF_8)); - zos.closeEntry(); - zos.putNextEntry(new ZipEntry("word/document.xml")); - zos.write(documentXml.getBytes(StandardCharsets.UTF_8)); - zos.closeEntry(); - if (numberingXml != null) { - zos.putNextEntry(new ZipEntry("word/numbering.xml")); - zos.write(numberingXml.getBytes(StandardCharsets.UTF_8)); - zos.closeEntry(); - } - } - return out.toByteArray(); - } - - private static String readEntry(byte[] zip, String name) throws IOException { - try (ZipInputStream zis = new ZipInputStream( - new java.io.ByteArrayInputStream(zip))) { - ZipEntry e; - while ((e = zis.getNextEntry()) != null) { - if (e.getName().equals(name)) { - return new String(zis.readAllBytes(), StandardCharsets.UTF_8); - } - } - } - throw new AssertionError("нет записи " + name); - } - - @Test - void listMarkersBecomeUnicode() throws Exception { - byte[] result = SymbolFontNormalizer.normalize(makeDocx("", NUMBERING_XML)); - - String numbering = readEntry(result, "word/numbering.xml"); - assertTrue(numbering.contains(""), - "Wingdings F0A7 не стал ▪: " + numbering); - assertTrue(numbering.contains(""), - "Symbol F0B7 не стал •: " + numbering); - assertTrue(numbering.contains(""), - "уровень без символьного шрифта изменён: " + numbering); - assertFalse(numbering.contains("Wingdings"), "имя шрифта не заменено: " + numbering); - assertTrue(numbering.contains("w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY + "\""), - "fallback-семейство не проставлено: " + numbering); - } - - @Test - void symbolFontInRunIsReplaced() throws Exception { - byte[] result = SymbolFontNormalizer.normalize(makeDocx(DOCUMENT_XML, null)); - - String document = readEntry(result, "word/document.xml"); - assertTrue(document.contains("• хвостик"), - "PUA в ране не заменён: " + document); - assertFalse(document.contains("=\"Symbol\""), - "Symbol остался в w:rFonts: " + document); - assertTrue(document.contains("обычный текст"), - "чужой ран изменён: " + document); - } - - /** - * w:sym имеет собственный w:font, поэтому ран разрезается: символ - * уходит в fallback-шрифт, соседний текст сохраняет Times New Roman. - */ - @Test - void symElementSplitsRunAndKeepsNeighbourFont() throws Exception { - byte[] result = SymbolFontNormalizer.normalize(makeDocx(DOCUMENT_XML, null)); - - String document = readEntry(result, "word/document.xml"); - assertTrue(document.contains("♥"), "w:sym F0A9 не стал ♥: " + document); - assertFalse(document.contains("до "), - "текст до w:sym потерян: " + document); - assertTrue(document.contains(" после"), - "текст после w:sym потерян: " + document); - // Соседний текст остался на своём шрифте, символ — на fallback - assertTrue(document.contains("w:ascii=\"Times New Roman\""), - "шрифт соседнего текста изменён: " + document); - assertTrue(document.contains("♥"), "символ потерян: " + document); - } - - @Test - void nothingToChangeReturnsOriginalArray() throws Exception { - byte[] docx = makeDocx("обычный текст", null); - - assertSame(docx, SymbolFontNormalizer.normalize(docx)); - } - - /** Часть вне word/*.xml не трогаем (та же политика, что у DocxOnOffNormalizer). */ - @Test - void nonWordPartsNotTouched() throws Exception { - byte[] result = SymbolFontNormalizer.normalize(makeDocx("", NUMBERING_XML)); - - assertEquals("\uF0A7", readEntry(result, "[Content_Types].xml")); - } - - @Test - void rewriteWithoutMatchesIsNull() { - assertNull(SymbolFontNormalizer.rewrite("текст")); - assertNull(SymbolFontNormalizer.rewrite("нет символных шрифтов")); - } - - /** Символьный шрифт без кодов из PUA и коды из PUA без шрифта — не трогаем. */ - @Test - void fontWithoutPuaAndPuaWithoutFontUntouched() { - assertNull(SymbolFontNormalizer.rewrite( - "текст")); - assertNull(SymbolFontNormalizer.rewrite( - "\uF0A7")); - } - - /** - * Ран внутри текстбокса (вложенный w:r): внутренний ран с Wingdings - * переписывается, каркас внешнего остаётся целым. - * Регрессия — SymbolFontNormalizerTest#nestedRunInTextBox_innerNormalized. - */ - @Test - void nestedRunInTextBox_innerNormalized() { - String xml = "" - + "" - + "\uF0A7 хвостик" - + ""; - - String out = SymbolFontNormalizer.rewrite(xml); - - assertNotNull(out, "внутренний ран не переписан"); - assertTrue(out.contains("▪ хвостик"), "PUA не стал Unicode: " + out); - assertFalse(out.contains("Wingdings"), "имя шрифта не заменено: " + out); - assertTrue(out.contains("w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY + "\""), - "нет fallback-семейства: " + out); - assertTrue(out.contains(""), - "каркас внешнего рана повреждён: " + out); - } - - /** Нет кодов из PUA, но есть w:sym — быстрый путь не отсекает, символ заменяется. */ - @Test - void symWithoutPuaStillRewritten() { - String out = SymbolFontNormalizer.rewrite( - "" - + "a"); - assertNotNull(out, "ран с w:sym без PUA пропущен"); - assertTrue(out.contains("♥"), "w:sym без w:font не взят из шрифта рана: " + out); - assertTrue(out.contains("w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY + "\""), - "нет fallback-семейства у символа: " + out); - assertTrue(out.contains("a"), "текст до w:sym потерян: " + out); - } - - /** Битые/незакрытые конструкции не правим (контракт: null = не трогать). */ - @Test - void malformedRunsUntouched() { - // открывающий есть, закрывающего нет - assertNull(SymbolFontNormalizer.rewrite("\uF0B7")); - // открывающий тег без '>' - assertNull(SymbolFontNormalizer.rewrite("\uF0B7\uF0B7" - + "\uF0B7" - + "\uF0B7"); - assertNotNull(out, "ран с табуляцией/переносом в теге пропущен"); - assertTrue(out.contains("•"), "PUA не стал Unicode: " + out); - assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out); - } - - /** Самозакрывающийся — не блок, поиск продолжается со следующего рана. */ - @Test - void selfClosingRunSkipped() { - String out = SymbolFontNormalizer.rewrite( - "" - + "\uF0B7"); - assertNotNull(out, "ран после не переписан"); - assertTrue(out.contains(""), "самозакрывающийся ран повреждён: " + out); - assertTrue(out.contains("•"), "PUA не стал Unicode: " + out); - } - - /** Два открывающих, один закрывающий: блок берётся до единственного . */ - @Test - void unbalancedNestedRuns_blockUpToSoleClose() { - String out = SymbolFontNormalizer.rewrite( - "" - + "\uF0B7"); - assertNotNull(out, "несбалансированный блок не переписан"); - assertTrue(out.contains("•"), "PUA не стал Unicode: " + out); - assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out); - } - - /** Хвост после единственного без собственного рана — не трогаем. */ - @Test - void danglingTailAfterCloseUntouched() { - assertNull(SymbolFontNormalizer.rewrite("\uF0B7")); - } - - /** Коды вне U+F000–U+F0FF — обычная часть символьного шрифта, не переписываются. */ - @Test - void puaAboveBlockKept() { - assertNull(SymbolFontNormalizer.rewrite( - "\uF100")); - String out = SymbolFontNormalizer.rewrite( - "\uF0B7\uF100"); - assertNotNull(out); - assertTrue(out.contains("•\uF100"), "F0B7/F100 обработаны неверно: " + out); - } - - /** PUA-код без соответствия в таблице остаётся как был, шрифт всё равно меняется. */ - @Test - void unmappedPuaSlotKeepsCode() { - String out = SymbolFontNormalizer.rewrite( - "\uF000"); - assertNotNull(out); - assertTrue(out.contains("\uF000"), "код без маппинга потерян: " + out); - assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out); - } - - /** w:sym в блоке w:lvl (не ран) — не разрезаем. */ - @Test - void symInLevelBlockNotSplit() { - assertNull(SymbolFontNormalizer.rewrite( - "")); - } - - /** Открытый без перед w:sym — битый ран не правим. */ - @Test - void unclosedRPrBeforeSymUntouched() { - assertNull(SymbolFontNormalizer.rewrite( - "")); - } - - /** w:sym без w:char / без w:font в ране без символьного шрифта / код вне PUA / - * слот без маппинга — элемент удаляется, соседний текст сохраняется. */ - @Test - void unresolvableSymElementDropped() { - String noChar = SymbolFontNormalizer.rewrite( - "a"); - assertNotNull(noChar); - assertFalse(noChar.contains("a"), "текст потерян: " + noChar); - - String noFontNoMap = SymbolFontNormalizer.rewrite( - "a"); - assertNotNull(noFontNoMap); - assertFalse(noFontNoMap.contains("a"); - assertNotNull(asciiChar); - assertFalse(asciiChar.contains("a"); - assertNotNull(unmappedChar); - assertFalse(unmappedChar.contains("a")); - } - - /** rPr без w:rFonts: fallback-семейство вставляется первым ребёнком. */ - @Test - void forceFontInsertsRFontsWhenAbsent() { - String out = SymbolFontNormalizer.rewrite( - "" - + ""); - assertNotNull(out); - assertTrue(out.contains(""), - "w:rFonts не вставлен в rPr: " + out); - assertTrue(out.contains("♥"), "символ потерян: " + out); - } - - /** В обработанном блоке несимвольные имена шрифтов остаются как были. */ - @Test - void nonSymbolFontAttrKept() { - String out = SymbolFontNormalizer.rewrite( - "" - + "\uF0B7"); - assertNotNull(out); - assertTrue(out.contains("w:eastAsia=\"Arial\""), "несимвольный шрифт изменён: " + out); - assertTrue(out.contains("w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY + "\""), - "символьный шрифт не заменён: " + out); - assertTrue(out.contains("•"), "PUA не стал Unicode: " + out); - } -} diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/doc/ListsTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/doc/ListsTest.java index 3a621d9..c828be6 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/doc/ListsTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/doc/ListsTest.java @@ -156,7 +156,7 @@ class ListsTest { assertTrue(xml.contains(""), xml); assertTrue(xml.contains(""), xml); assertTrue(xml.contains(""), - "PUA-символ дословно (чинит SymbolFontNormalizer): " + xml); + "PUA-символ дословно (маппит экспорт docx4j 17.3.x): " + xml); } @Test -- 2.56.1 From b8d0e4433b6ca5a123728929fc32fa121601f740 Mon Sep 17 00:00:00 2001 From: Pjandro Date: Sun, 8 Nov 2026 21:26:32 +0000 Subject: [PATCH 2/9] =?UTF-8?q?docs:=20=D0=B0=D0=BA=D1=82=D1=83=D0=B0?= =?UTF-8?q?=D0=BB=D0=B8=D0=B7=D0=B0=D1=86=D0=B8=D1=8F=20=D0=BF=D0=BE=D0=B4?= =?UTF-8?q?=20docx4j=2017.3.6=20=E2=80=94=20=D0=BF=D1=80=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=D0=B0=201=E2=80=939,=20=D1=84=D0=BE=D1=80=D0=BA=20FOP=20?= =?UTF-8?q?2.12,=20=D1=80=D0=B5=D0=B0=D1=83=D0=B4=D0=B8=D1=82=20=D0=B3?= =?UTF-8?q?=D1=8D=D0=BF=D0=BE=D0=B2=20(framePr=20=D0=BF=D0=BE=D1=87=D0=B8?= =?UTF-8?q?=D0=BD=D0=B5=D0=BD=20=D0=B0=D0=BF=D1=81=D1=82=D1=80=D0=B8=D0=BC?= =?UTF-8?q?=D0=BE=D0=BC;=20distribute/lvlJc/=D0=BA=D0=B5=D1=80=D0=BD=D0=B8?= =?UTF-8?q?=D0=BD=D0=B3=20=D0=B1=D0=B5=D0=B7=20=D0=B8=D0=B7=D0=BC=D0=B5?= =?UTF-8?q?=D0=BD=D0=B5=D0=BD=D0=B8=D0=B9),=20=D1=81=D1=87=D1=91=D1=82?= =?UTF-8?q?=D1=87=D0=B8=D0=BA=D0=B8=20=D1=82=D0=B5=D1=81=D1=82=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- AGENTS.md | 17 +++++++++-------- README.md | 23 ++++++++++++----------- docs/agent/doc-bridge.md | 2 +- docs/agent/pipeline.md | 27 ++++++++++++++------------- docs/agent/render-limitations.md | 4 ++-- docs/agent/repo-map.md | 6 +++--- docs/agent/testing.md | 2 +- 7 files changed, 42 insertions(+), 39 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 01b922c..fb4e8b2 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -4,11 +4,11 @@ ## Project Overview -Конвертер `.docx`/`.doc` → `.pdf` на чистом Java: docx4j 17.3.2 → XSL-FO → форк Apache FOP, без LibreOffice/Aspose. Бинарный `.doc` (Word 97-2003) переносится мостом MS-DOC/MS-CFB (`internal/doc`) в in-memory `.docx` и идёт тем же конвейером. Java 17, только Maven. +Конвертер `.docx`/`.doc` → `.pdf` на чистом Java: docx4j 17.3.6 → XSL-FO → форк Apache FOP, без LibreOffice/Aspose. Бинарный `.doc` (Word 97-2003) переносится мостом MS-DOC/MS-CFB (`internal/doc`) в in-memory `.docx` и идёт тем же конвейером. Java 17, только Maven. | Модуль | Содержимое | |---|---| -|`wordpdf-core`|библиотека: 61 Java-файл (6 — публичный API, 16 `internal/`, 18 `internal/doc/`, 18 `internal/chart/`, 3 `fonts/`)| +|`wordpdf-core`|библиотека: 59 Java-файл (6 — публичный API, 14 `internal/`, 18 `internal/doc/`, 18 `internal/chart/`, 3 `fonts/`)| | `wordpdf-app` | REST API на Spring Boot 4.1.1: 11 классов, единственный `public` — `WordPdfApplication` | | `wordpdf-web` | SPA (React 19 + TS + Vite + Tailwind), вне Maven-реактора, отдельный образ | @@ -18,11 +18,11 @@ Порядок шагов 0–7 фиксирован (`convertToStream`), местами менять нельзя. Вход роутируется по сигнатуре: `PK\x03\x04` → docx-путь; `D0 CF 11 E0 A1 B1 1A E1` (CFB, MS-CFB §2.2) → `DocToDocx.convert` → in-memory `.docx` → тот же конвейер (предикат — `WordPdfValidator.isBinaryDoc`). Валидация — **до** `convertToStream`: `WordPdfValidator.validate(bytes, options)` (размер → подпись zip/CFB → контейнер → страницы); для `.doc` — `checkPageCountDoc` по сырым байтам. -Порядок: шрифты (`BundledFontMapper` → `BundledFonts.init` → `restrictToBundled`) и правила 1–10 (`DocxRewritePipeline.STEP`) + `OleObjectNormalizer` — до `WordprocessingMLPackage.load`; `FOSettings`/`FopFallbackFonts`/`LayoutPostRenderer` — до `setCustomXsltTemplates(VendoredXslt.TEMPLATES)`; `Docx4J.toFO(…, FLAG_EXPORT_PREFER_XSL)` — последним; `finally` → `deleteEmbeddedFontTempFiles()` + сброс имиджевых кешей общей FopFactory + `BundledFonts.restrictToBundled()` (реестр шрифтов возвращается в бандл-состояние: `load()` регистрирует встроенные шрифты документа в глобальном `PhysicalFonts`). Полная таблица шагов и подсчёт страниц — `docs/agent/pipeline.md`. +Порядок: шрифты (`BundledFontMapper` → `BundledFonts.init` → `restrictToBundled`) и правила 1–8 (`DocxRewritePipeline.STEP`) + `OleObjectNormalizer` — до `WordprocessingMLPackage.load`; `FOSettings`/`FopFallbackFonts`/`LayoutPostRenderer` — до `setCustomXsltTemplates(VendoredXslt.TEMPLATES)`; `Docx4J.toFO(…, FLAG_EXPORT_PREFER_XSL)` — последним; `finally` → `deleteEmbeddedFontTempFiles()` + сброс имиджевых кешей общей FopFactory + `BundledFonts.restrictToBundled()` (реестр шрифтов возвращается в бандл-состояние: `load()` регистрирует встроенные шрифты документа в глобальном `PhysicalFonts`). Полная таблица шагов и подсчёт страниц — `docs/agent/pipeline.md`. ## Нормализаторы (`internal/DocxNormalizer`) -Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame`). Порядок фиксирован: Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby. Правила 1–10 применяет `DocxRewritePipeline.STEP` одним zip-проходом (неизменённые записи копируются raw-сжатыми байтами); `OleObjectNormalizer` (правило 11) — лямбдой в `WordPdfConverter.normalizers()`. `STEP` выставляют 9 из 10 rewrite-нормализаторов (нет у `RubyNormalizer`), у `OleObjectNormalizer` её нет. Правила 1–11, guard'ы, номера секций и инвариант `mc-preprocessor.xslt` (собственный рерайт strict-URI ломать нельзя) — `docs/agent/pipeline.md`. +Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame`). Порядок фиксирован: Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby. Правила 1–8 применяет `DocxRewritePipeline.STEP` одним zip-проходом (неизменённые записи копируются raw-сжатыми байтами); `OleObjectNormalizer` (правило 9) — лямбдой в `WordPdfConverter.normalizers()`. `STEP` выставляют 7 из 8 rewrite-нормализаторов (нет у `RubyNormalizer`), у `OleObjectNormalizer` её нет. Правил Symbol-шрифтов и complex-полей PAGE/NUMPAGES больше нет — с docx4j 17.3.x их делает сам экспорт (#701, CR-067); пины отсутствия регрессии — `symbolFonts_bulletsAreNotHash`, `pageNumbers_recomputedNotCached`. Правила 1–9, guard'ы, номера секций и инвариант `mc-preprocessor.xslt` (собственный рерайт strict-URI ломать нельзя) — `docs/agent/pipeline.md`. ## Мост `.doc` → `.docx` (`internal/doc`) @@ -47,15 +47,16 @@ Java2D → PNG: `ChartRenderer.DPI = 300`, потолок `MAX_PIXELS = 16_777_2 ## Критические инварианты (нарушение = битый вывод, не исключение) - `docx4j.convert.out.fo.gsubFeatures=false` — static-блок `WordPdfConverter`; иначе FO невалиден → `WordLayoutFixups` молча отказывает всем фиксам → FOP падает на `docx4j-baseline`. +- `docx4j.openpackaging.load.repair=word` — static-блок `WordPdfConverter` (17.3.6, `RepairMode`): с дефолтным NONE пакеты, которые Word открывает через «восстановить» (напр. case-folded дубликаты zip-записей), отказываются грузиться — для конвертера это 500 на читаемых Word файлах. - `docx4j.fonts.discoverPhysicalFonts.enabled=false` и `discoverJarFonts.enabled=false` — static-блок: иначе `BestMatchingMapper` сканирует системные шрифты и jar'ы classpath'а, а `restrictToBundled()` всё найденное выбрасывает (~100–140 мс впустую на JVM). `discoverJarFonts("fonts-symbol")` свойством не гейтится — символ-шрифт регистрируется и снимается restrict'ом как раньше. -- Единственный XSL-FO-стилист — вендорный `xslt/docx2fo.xslt` (копия из docx4j-export-fo 17.3.2 + два AUDIT-FIX-патча: `w:rPr/w:position` → `baseline-shift`, Part 1 §17.3.2.24; AUDIT-FIX-2 — `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir`, иначе их ловит catch-all `match="*"` и текст теряется). Дрейф-гейт `vendoredXsltTracksJarCopy`: вне AUDIT-FIX-регионов копия побайтно равна стилю из jar'а. `setCustomXsltTemplates` принимает предкомпилированный `Templates`. +- Единственный XSL-FO-стилист — вендорный `xslt/docx2fo.xslt` (копия из docx4j-export-fo 17.3.6 + два AUDIT-FIX-патча: `w:rPr/w:position` → `baseline-shift`, Part 1 §17.3.2.24; AUDIT-FIX-2 — `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir`, иначе их ловит catch-all `match="*"` и текст теряется). Дрейф-гейт `vendoredXsltTracksJarCopy`: вне AUDIT-FIX-регионов копия побайтно равна стилю из jar'а. `setCustomXsltTemplates` принимает предкомпилированный `Templates`. - `slf4j-simple` обязателен в ядре: без SLF4J-провайдера docx4j пишет «TO HIDE THESE MESSAGES» прямо в PDF (регрессия `noLoggingWarningInPdf`); приложение исключает его — логи ведёт logback. -- FOP — форк `org.docx4j:docx4j-fo-renderer*` 2.11-docx4j.6 (транзитив от `docx4j-export-fo`, в pom не пинится; пакеты `org.apache.fop.*`). `FopFallbackFonts` берёт `w:renderer` с mime `application/pdf`, иначе первый со шрифтами. +- FOP — форк `org.docx4j:docx4j-fo-renderer*` 2.12-docx4j.1 (транзитив от `docx4j-export-fo`, в pom не пинится; пакеты `org.apache.fop.*`). `FopFallbackFonts` берёт `w:renderer` с mime `application/pdf`, иначе первый со шрифтами. - `BundledFonts.init()` идемпотентен, распаковывает TTF в `wordpdf-fonts-*` (`deleteOnExit`); `dropNonBundled()` чистит `PhysicalFonts` от всего, что вне бандла; ВСЕ синхронизированные методы `BundledFonts` (`init`/`restrictToBundled`/`font`) держат монитор `WordPdfConverter.class` (не собственный замок класса) — тот же, что сериализует конвертации, поэтому внешний вызов рядом с идущей конвертацией безопасен автоматически. Регрессия — `WordPdfConverterTest#concurrentFontMutators_conversionsUnharmed`. - `PhysicalFonts` — глобальный и мутируемый → конвертации сериализуются монитором `WordPdfConverter.class` внутри ядра (общая `FopFactory` и сброс её image-кешей — под тем же монитором); приложение держит однопоточный воркер ради 503/timeout; `warmup()` идёт тем же потоком. - Страницы в валидаторе = `max(кэш docProps/app.xml, явные разрывы, lastRenderedPageBreak+1)`; правила StAX-подсчёта — `docs/agent/pipeline.md`. -- Не чинить: `jc="distribute"`, `suff="tab"`/`lvlJc`, метрика «single», кернинг, `framePr`, `REF`/`SEQ`/`TOC`-кэш, руби-надстрочница, U+2188/U+218A — доказательства в `docs/agent/render-limitations.md`. -- Комментарии в `WordPdfConverter`/`DocxOnOffNormalizer` говорят «docx4j 11.x» — устаревшее число, фактически 17.3.2 (описанное поведение верно). +- Не чинить: `jc="distribute"` (в FOP-форке 2.12 есть `text-align-last`, но маппинг `Justification` не эмитит его и межсимвольного разноса нет), `suff="tab"`/`lvlJc`, метрика «single», кернинг, `REF`/`SEQ`/`TOC`-кэш, руби-надстрочница, U+2188/U+218A — доказательства в `docs/agent/render-limitations.md`. `framePr` починен апстримом 17.3.6 (фрейм позиционируется). +- Комментарии в `WordPdfConverter`/`DocxOnOffNormalizer` говорят «docx4j 11.x» — устаревшее число, фактически 17.3.6 (описанное поведение верно). ## Шрифты (30 TTF + 3 лицензии, SIL OFL, `wordpdf-core/src/main/resources/fonts/`) diff --git a/README.md b/README.md index 00eebc4..adf3893 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # java-word-pdf -Конвертация **.docx/.doc → PDF** на чистом Java: `docx4j` 17.3.2 + форк +Конвертация **.docx/.doc → PDF** на чистом Java: `docx4j` 17.3.6 + форк `Apache FOP`, без LibreOffice/Aspose. Бинарный `.doc` (Word 97–2003) читается собственным мостом [MS-DOC]/[MS-CFB] и переносится в .docx в памяти — дальше идёт тем же конвейером. Шрифты упакованы в jar — конвертация не зависит от @@ -41,7 +41,7 @@ java-word-pdf/ |`ru.pjandro.wordpdf.ConversionException`|ошибки конвертации; подтипы `ValidationException` (некорректный вход) и `DrawingFoundException` (`enum Kind {CHARTS, SMARTART, OLE}`)| |`ru.pjandro.wordpdf.fonts.BundledFonts`|выгрузка TTF из jar и регистрация в docx4j| |`ru.pjandro.wordpdf.fonts.BundledFontMapper`|маппинг имён шрифтов документа → TTF| -|`ru.pjandro.wordpdf.internal.DocxRewritePipeline`|правила 1–10 нормализации XML-частей одним zip-проходом (+ `OleObjectNormalizer`, правило 11)| +|`ru.pjandro.wordpdf.internal.DocxRewritePipeline`|правила 1–8 нормализации XML-частей одним zip-проходом (+ `OleObjectNormalizer`, правило 9)| |`ru.pjandro.wordpdf.internal.doc.DocToDocx`|мост бинарного `.doc` → in-memory `.docx` (`convert`/`countPages`)| |`ru.pjandro.wordpdf.internal.FopFallbackFonts`|декларация fallback-семейства в FOP-конфиге| |`ru.pjandro.wordpdf.internal.chart.DrawingPreRenderer`|диаграммы/SmartArt → PNG до XSL-FO| @@ -294,15 +294,16 @@ Dev-режим без контейнеров: бэкенд `java -jar wordpdf-ap 1. Вход проверяется до рендера: размер → сигнатура (zip PK или CFB) → (.docx: контейнер и страницы lightweight-StAX по zip; .doc: страницы по чистому бинарному документу мостом) — `WordPdfValidator`, без зависимости от docx4j. -2. XML-части переписывает `DocxRewritePipeline` одним zip-проходом — десять +2. XML-части переписывает `DocxRewritePipeline` одним zip-проходом — восемь правил (порядок значим): strict→transitional (`w:start`/`w:end`, проценты), `on/off` → `true/false` (иначе docx4j теряет значение, и regular-раны - рендерились жирным курсивом), маркеры Symbol/Wingdings → Unicode (вместо «#»), - поля `PAGE`/`NUMPAGES` → `w:fldSimple` (пересчитываются, а не печатают кэш - из docx), невидимые символы, раны со знаками вне их шрифта (резка по покрытию - глифов), `w:jc` center/right + `w:tblInd` → абсолютный отступ таблицы, - `w:suff="space"` → пробел в номере списка, скрытые раны (`w:vanish`), руби - (надстрочница вырезается). Затем вычищаются OLE-объекты (правило 11, + рендерились жирным курсивом), невидимые символы, раны со знаками вне их + шрифта (резка по покрытию глифов), `w:jc` center/right + `w:tblInd` → + абсолютный отступ таблицы, `w:suff="space"` → пробел в номере списка, + скрытые раны (`w:vanish`), руби (надстрочница вырезается). Маркеры + Symbol/Wingdings и поля `PAGE`/`NUMPAGES` не переписываем — с docx4j 17.3.x + экспорт делает это сам (маркеры → Unicode, complex-поля → пересчёт вместо + кэша). Затем вычищаются OLE-объекты (правило 9, `OleObjectNormalizer`, картинка-плейсхолдер сохраняется). 3. Документ загружается в `WordprocessingMLPackage`, привязывается `BundledFontMapper`. @@ -326,9 +327,9 @@ Dev-режим без контейнеров: бэкенд `java -jar wordpdf-ap целиком на SIL OFL. - Поддержка таблиц/изображений — базовая (через docx4j/FOP). - Часть расхождений с Word — неустранимые невозможности FOP/docx4j - (`jc="distribute"`, `suff="tab"`, кернинг, `framePr`, кэш `REF`/`SEQ`/`TOC`, + (`jc="distribute"`, `suff="tab"`, кернинг, кэш `REF`/`SEQ`/`TOC`, надстрочница руби) — полный перечень с доказательствами: - `docs/agent/render-limitations.md`. + `docs/agent/render-limitations.md`. `w:framePr` с docx4j 17.3.6 позиционируется. - На `.doc` error-флаги диаграмм/SmartArt/OLE не срабатывают: BLIP-плейсхолдеры бинарного формата — уже растры, они вставляются картинками; EMF/WMF/PICT пропускаются с warn. diff --git a/docs/agent/doc-bridge.md b/docs/agent/doc-bridge.md index 8d327e2..7e33868 100644 --- a/docs/agent/doc-bridge.md +++ b/docs/agent/doc-bridge.md @@ -15,7 +15,7 @@ |`Sections`|PlcfSed (§2.8.26): aCP n+1 + Sed n (12 Б) + Sepx (cb + секционные sprm) → `list()` — список record'ов `Section` (CP-диапазон, геометрия секции, `continuous` из sprmSBkc, `landscape` из sprmSBOrientation 0x301D (§2.9.236: 1/2), нумерация страниц — `pgNumStart` (0 = не задан; sprmSFPgnRestart 0x3011 + sprmSPgnStart97 0x501C, restart без start клампится к 1) и `nfcPgn` (sprmSNfcPgn 0x300E, MSONFC), колонки — sprmSCcolumns 0x500B (число − 1, кап 44), sprmSFEvenlySpaced 0x3005 (Bool8, дефолт true), sprmSDxaColumns 0x900C; при неравных колонках per-column ширины/зазоры из sprmSDxaColWidth 0xF203/sprmSDxaColSpacing 0xF204 (SDxaColWidthOperand/SDxaColSpacingOperand §2.9.241/.242: iCol+dxa)); `titlePage` из sprmSFTitlePage 0x300A (Bool8)); невозрастающие aCP → `ConversionException`; финальный aCP реальные файлы пишут за ccpText (PLC покрывает весь текстовый поток) — конец последней секции клампится к ccpText; `pageWidth()`/`header()`/`footer()` — геометрия последней секции (полоса набора для правила 7), `continuousSectionEnds()` — вычитание из подсчёта страниц (последняя секция не считается)| |`FontTable`|SttbfFfn (§2.9.147): индекс ftc → имя семейства в `w:rFonts`| |`SummaryInfo`|[MS-OLEPS §2.2] PropertySet-поток `\x01SummaryInformation`; **offset'ы заголовка относительны начала PropertySet-потока** (`abs = Offset0 + offset`); PIDSI_PAGECOUNT=0x0E| -|`Headers`|Plcfhdd (§2.4.1): 6 разделителей + по 6 историй на секцию (even/odd/first × hdr/ftr); odd hdr/ftr **каждой** секции → своя часть `headerN.xml`/`footerN.xml` (нумерация независимая по типу) и `headerReference`/`footerReference` type="default" в её sectPr; **first hdr/ftr (слоты 4/5 §2.8.22)** — только когда у секции Sepx задал sprmSFTitlePage → `type="first"` (нумерация общая с first-частями; регрессия — DocToDocxFormattingTest#titlePage_emittedAfterCols, WordPdfConverterTest#docTitlePage_firstHeaderOnlyFirstPage); пустая история [x,x) → части нет, docx4j наследует колонтитук предыдущей секции; guard-¶ отрезается; PAGE/NUMPAGES/SECTIONPAGES → `w:fldSimple` (та же семантика, что `FieldNormalizer` в docx-пути)| +|`Headers`|Plcfhdd (§2.4.1): 6 разделителей + по 6 историй на секцию (even/odd/first × hdr/ftr); odd hdr/ftr **каждой** секции → своя часть `headerN.xml`/`footerN.xml` (нумерация независимая по типу) и `headerReference`/`footerReference` type="default" в её sectPr; **first hdr/ftr (слоты 4/5 §2.8.22)** — только когда у секции Sepx задал sprmSFTitlePage → `type="first"` (нумерация общая с first-частями; регрессия — DocToDocxFormattingTest#titlePage_emittedAfterCols, WordPdfConverterTest#docTitlePage_firstHeaderOnlyFirstPage); пустая история [x,x) → части нет, docx4j наследует колонтитук предыдущей секции; guard-¶ отрезается; PAGE/NUMPAGES/SECTIONPAGES → `w:fldSimple` (та же семантика, что в docx-пути, где complex-поля пересчитывает экспорт docx4j 17.3.x)| |`OfficeArt`|[MS-ODRAW] PICF @ fcDggInfo/lcbDggInfo (Table-поток), delay-поток = WordDocument; DggContainer → BStoreContainer(0xF004)/BStoreContainerDelay(0xF007)/инлайн → FBSE → BLIP: 0xF01A EMF / 0xF01B WMF / 0xF01C PICT / 0xF01D JPEG (=0xF02A) / 0xF01E PNG / 0xF01F DIB; PNG/JPEG дословно, DIB → ImageIO → PNG, EMF/WMF/PICT → пропуск + warn (EMF-рендера в Java2D нет)| |`PrcData`|§2.9.210 PrcData в Data-потоке (`[cbGrpprl:2][grpprl]`, капа cb 0x3FA2, поля `next` нет): `resolve(data, grpprl)` разворачивает grpprl абзаца, чьи свойства Word вынес за FKP-страницу PAPX, — одиночный Prl `sprmPHugePapx` (0x6646; в grpprl GrpPrlAndIstd — единственный Prl при istd=0, §2.6.2) и `sprmPTableProps` (0x646B — цепочка продолжается в указанном PrcData). Оба указателя разворачиваются на своей позиции **без обрыва** текущего массива, не-спец-спрмы сохраняются (union): spec §2.6.2 велит хвост за PTableProps игнорировать, но Word пишет в нём легаси-зеркало (в `samples/ru-table-image.doc` — единственный `sprmTDefTable`, Appendix A <9>), а `sprmTInsert` из PrcData конвертер не читает — замещение ломало бы сетку; спец-спрмов нет → **тот же массив** (по ссылке); любой брак (ptr за Data, cb вне [1, 0x3FA2], цикл A→B→A — бюджет 32 PrcData) → останов без исключения, снисходительно (образец `Styles`/`Lists`). Подключается единственной точкой — `DocxBody.buildRange` (покрывает тело, колонтитуки, TTP-ветку и обычные huge-PAPX абзацы). Регрессия — `DocToDocxFormattingTest#hugePapxRowMark_closesRowWithGridFromPrcData` | |`DocToDocx`|Оркестратор + вложенный `DocxBody`: текст → раны (CHPX+стилевой chpx-цепочка +chpx-цепочка символьного стиля по **sprmCIstd** (`Styles.charChain` — между стилевой цепочкой и прямыми, §2.4.6.5) → rPr (в т.ч. `w:highlight`/`w:shd`), прямой PAPX — после `PrcData.resolve` — +стилевая papx-цепочка (отступы через `Grpprl.Indents`, 80-варианты включительно; `sprmPChgTabsPapx`/`sprmPChgTabs` → `w:tabs`, у стилевого варианта радиус удаления из `rgdxaClose`) + sprmPIlfo/sprmPIlvl → pPr + `w:numPr` (между pageBreakBefore и tabs, CT_PPr §17.3.1.26; ilfo=0 перекрывает стилевой, ilvl=0x0C и неразрешённый numId → без numPr), base→derived→direct last-wins; флаги рана: vanish — мост фильтрует вывод рана (`w:vanish` в FO мёртв), caps/smallCaps — `Character.toUpperCase` в мосту (`w:caps`/`w:smallCaps` конвейер не читает, FOP без font-variant), rMarkIns/rMarkDel — ран оборачивается в `w:ins`/`w:del`+`w:delText` (шаблоны docx2fo рисуют правки — вид «Show Markup»), hpsPos → `w:position` (вендорный AUDIT-FIX → baseline-shift)), ¶ → ``; TAB/0x0B → `w:tab`/`w:br`, 0x0E → `w:br type="column"` (конец колонки при sprmSCcolumns), 0x0C в ране → `w:br type="page"`, 0x0C в конце абзаца — **разрыв секции**: `sectPr` соответствующей `Sections.Section` (матчинг по конечному CP) в pPr этого абзаца, внутри таблицы деградирует в `w:br type="page"`; body-level `sectPr` — последняя секция; `w:type continuous` из sprmSBkc; `w:pgSz w:orient="landscape"` со сменой w/h местами, `w:pgNumType` (`w:start` при restart, `w:fmt` только для числовых nfc — общий маппинг `Lists.numFmt`), `w:cols` (evenly → `w:num`+`w:space`, иначе per-column `w:col`; неравные/неполные ширины → деградация в одноколонную), `w:titlePg` из `Section.titlePage` (после w:cols, CT_SectPrBase §17.2.3) — `DocxBody.sectPrXml`/`appendPgNumType`/`appendCols`; pPr: `w:shd` из sprmPShd/…80 перед `w:tabs` (CT_PPr §17.3.1.26), `w:keepNext`/`w:keepLines` перед `w:pageBreakBefore` (CT_PPr §17.3.1.26); 0x1E → U+2011, 0x1F → U+00AD, 0x02/0x03/0x04 (сноски) → пропуск; U+0001/U+0008 со sprmCPicLocation → DrawingML `pic` (общий путь с картинками и OLE-fallback; 0x08 — якорь плавающей картинки §2.9.267, переносится inline-приближением: PlcfSpa не читается, позиция/обтекание теряются); field-символы в основном тексте: инструкция скрыта, кэшированный результат после разделителя видим; **табличный автомат**: абзац с 0x07 без TTP закрывает ячейку, 0x07+sprmPFTtp — конец строки (`Tables.parse` по TAP → `w:tbl`/`w:tr`/`w:tc`, сам маркер не эмитится), sprmPFInTable открывает ячейку; без корректного TDefTable строка деградирует в плоские абзацы (прежнее поведение); сетка первой строки действует на всю таблицу как `tblGrid`, ширины/объединение ячеек каждой строки — из её собственного TDefTable (горизонтальное слияние → `w:gridSpan`)| diff --git a/docs/agent/pipeline.md b/docs/agent/pipeline.md index d45a6a1..87b0fe0 100644 --- a/docs/agent/pipeline.md +++ b/docs/agent/pipeline.md @@ -6,7 +6,7 @@ |---|---|---| | 0 | `DependencyGuard.check()` | API-проба `ZipArchiveInputStream.getNextEntry()` — совместимость commons-compress ≥ 1.25.0; иначе `ConversionException` с инструкцией вместо мутного `NoSuchMethodError` внутри docx4j | | 1 | `new BundledFontMapper()` → `BundledFonts.init()` → `restrictToBundled()` | Конструктор маппера (static `BestMatchingMapper`) регистрирует в `PhysicalFonts` только symbol-шрифты из `docx4j-export-fo-fonts-symbol` (сканы системы и jar'ов отключены в static-блоке `WordPdfConverter` гейт-свойствами — всё найденное всё равно выбрасывает `restrictToBundled()`); `init()` вызывает `dropNonBundled()` **до** регистрации бандла, `restrictToBundled()` оставляет реестр = бандл + встроенные в docx. Порядок `init()` после конструктора — инвариант: `addPhysicalFont` не перезаписывает занятый ключ (иначе системный Calibri ломает em-dash-fallback) | -|2|`DocxRewritePipeline.STEP` → `OleObjectNormalizer` → `WordprocessingMLPackage.load`|Один zip-проход переписывания XML-частей (правила 1–10 — раздел «Нормализаторы: контракт и правила 1–11» в этом файле) + условная OLE-вычистка (правило 11)| +|2|`DocxRewritePipeline.STEP` → `OleObjectNormalizer` → `WordprocessingMLPackage.load`|Один zip-проход переписывания XML-частей (правила 1–8 — раздел «Нормализаторы: контракт и правила 1–9» в этом файле) + условная OLE-вычистка (правило 9)| | 3 | `pkg.setFontMapper(mapper)` | Привязка шрифтов документа к физическим TTF | | 3.5 | `DrawingPreRenderer.run(pkg, options)` | `c:chart`/`dgm:relIds` → PNG 300 dpi → `pic:pic` (docx2fo.xslt их не умеет) | | 4 | `new FOSettings(pkg)` + `FopFallbackFonts.declare(foSettings)` | В FOP-конфиг добавляются **все** бандл-семейства: FOP встраивает только задекларированные | @@ -22,24 +22,25 @@ ### Валидация входа и подсчёт страниц -Вход валидируется **до** `convertToStream`: `WordPdfValidator.validate(bytes, options)` (размер → подпись: zip `PK\x03\x04` или CFB `D0 CF 11 E0` → контейнер → страницы). Для `.doc` страницы считаются **по сырым байтам .doc, до конвертации**: `checkPageCountDoc` = `max(SummaryInfo PageCount, 1 + явные разрывы)`; явные — 0x0C в основном тексте + `sprmPFPageBreakBefore` из PAPX. Тот же метод — вход приложения. Скан выполняется ровно один раз по сырому входу, до аллокаций docx4j: правила 1–10 число учитываемых разрывов не увеличивают (правило 9 способно только убрать разрыв внутри скрытого рана — счёт по сырому входу остаётся верхней оценкой лимита). +Вход валидируется **до** `convertToStream`: `WordPdfValidator.validate(bytes, options)` (размер → подпись: zip `PK\x03\x04` или CFB `D0 CF 11 E0` → контейнер → страницы). Для `.doc` страницы считаются **по сырым байтам .doc, до конвертации**: `checkPageCountDoc` = `max(SummaryInfo PageCount, 1 + явные разрывы)`; явные — 0x0C в основном тексте + `sprmPFPageBreakBefore` из PAPX. Тот же метод — вход приложения. Скан выполняется ровно один раз по сырому входу, до аллокаций docx4j: правила 1–8 число учитываемых разрывов не увеличивают (правило 7 способно только убрать разрыв внутри скрытого рана — счёт по сырому входу остаётся верхней оценкой лимита). - Страницы в валидаторе = `max(кэш docProps/app.xml, явные разрывы, lastRenderedPageBreak+1)`; explicit = межсекционные `w:sectPr` в body + `w:br type="page"` + `pageBreakBefore` (включая таблицы и `w:sdt`). Единственный путь — lightweight (StAX по zip, secure-ридер без DTD/external entities; `WordPdfValidator` не зависит от docx4j): атрибуты — по локальному имени (`attrLocal`, не по transitional-URI: иначе в strict-документе `w:br type="page"` не засчитываются); `sectPr` внутри `pPr` не считает, последнюю body-direct секцию не считает, `continuous`-секции не считает, в колонтитуках — только `w:br type="page"`, `pageBreakBefore` — только внутри `pPr` вне `sectPr` (truthy `val`: `null|true|1|on`). На не-zip молчит — подпись проверяет вызывающий. `checkPageCount` — один стриминговый проход `ZipInputStream` без буферизации частей (хелпер `noClose` глушит `close()` сканеров): потребление O(одной части) вместо O(суммы XML-частей). -### Нормализаторы: контракт и правила 1–11 (детали) +### Нормализаторы: контракт и правила 1–9 (детали) -Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame` в тестах). Десять rewrite-нормализаторов цепляются в фиксированном порядке Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby; константу `STEP` (`public static final DocxNormalizer`) выставляют девять из десяти (нет только у `RubyNormalizer` — он цепочный, подключается внутри пайплайна), у `OleObjectNormalizer` STEP **нет** — он подключается лямбдой в `WordPdfConverter.normalizers()`. Правила 1–10 применяет `internal/DocxRewritePipeline` — **один zip-проход**: к каждой записи `word/*.xml` рерайты применяются последовательно (каждое правило работает только содержимым одной части — по-частная цепочка эквивалентна последовательным полным проходам); до прохода из `word/document.xml` извлекается полоса набора (`TableIndentNormalizer.bandOf`, −1 — полосы нет), и `word/headerN.xml`/`footerN.xml` дополнительно прогоняются через `TableIndentNormalizer.rewritePart` с этой полосой, и из `word/styles.xml` читается множество vanish-стилей (`HiddenTextNormalizer.vanishStyles`, цепочка `w:basedOn`) — контекст правила 9; неизменённые записи переносятся raw-копией сжатых байтов (без inflate/deflate); нигде не поменялось → тот же массив. `OleObjectNormalizer` — второй условный проход (меняет части, а не XML). Индивидуальные `normalize()` десяти нормализаторов сохранены (контракт юнит-тестов), но `WordPdfConverter` их не вызывает — его `normalizers(options)` = `DocxRewritePipeline.STEP` + лямбда OLE. Порядок правил значим: +Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame` в тестах). Восемь rewrite-нормализаторов цепляются в фиксированном порядке Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby; константу `STEP` (`public static final DocxNormalizer`) выставляют семь из восьми (нет только у `RubyNormalizer` — он цепочный, подключается внутри пайплайна), у `OleObjectNormalizer` STEP **нет** — он подключается лямбдой в `WordPdfConverter.normalizers()`. Правила 1–8 применяет `internal/DocxRewritePipeline` — **один zip-проход**: к каждой записи `word/*.xml` рерайты применяются последовательно (каждое правило работает только содержимым одной части — по-частная цепочка эквивалентна последовательным полным проходам); до прохода из `word/document.xml` извлекается полоса набора (`TableIndentNormalizer.bandOf`, −1 — полосы нет), и `word/headerN.xml`/`footerN.xml` дополнительно прогоняются через `TableIndentNormalizer.rewritePart` с этой полосой, и из `word/styles.xml` читается множество vanish-стилей (`HiddenTextNormalizer.vanishStyles`, цепочка `w:basedOn`) — контекст правила 7; неизменённые записи переносятся raw-копией сжатых байтов (без inflate/deflate); нигде не поменялось → тот же массив. `OleObjectNormalizer` — второй условный проход (меняет части, а не XML). Индивидуальные `normalize()` восьми нормализаторов сохранены (контракт юнит-тестов), но `WordPdfConverter` их не вызывает — его `normalizers(options)` = `DocxRewritePipeline.STEP` + лямбда OLE. Порядок правил значим: 1. `StrictOoxmlNormalizer` — strict-OOXML → transitional: `a:`-проценты и `w14:fillToRect` → тысячные ×1000, текст `wp14:pctWidth`/`pctHeight`; элементы `w:start`/`w:end` → `w:left`/`w:right` (кроме `w:lvl/w:start` в numbering.xml); значения `w:val="start"/"end"` у `w:jc` и `w:tab` правятся **всегда** (docx4j `Justification.setXslFO` знает только left/center/right/both, для END `fo:text-align` не пишет вовсе — `jc="end"` рендерился по левому краю; Part 1 §17.3.1.13: `jc val="end"` — правовыравнивание в LTR, ST_Jc §17.18.44; RTL вне контура — FOP без complex-script). Strict-ность части определяется наличием `http://purl.oclc.org` (не «transitional-URI в документе» — mixed-документ трактуется по каждой части). **Guard сосуществования форм**: атрибут `w:start`/`w:end` переименовывается только внутри открывающего тега `w:ind` (MS-OI29500 §2.1.174a — псевдонимы left/right; у `w:pgNumType` `w:start` — старт нумерации страниц, легален в transitional, Part 1 §17.13.7 — не трогается) и не переименовывается, если в том же открывающем теге уже есть `w:left`/`w:right` (дубль атрибута ломает well-formedness — регрессии `indCoexistLeftStartUntouched`, `indCoexistForms_convertsNotRejected`, `pgNumTypeStartAttrUntouched`); элементы `w:start`/`w:end` в strict-части переименовываются глобально, в transitional — только внутри `w:tcMar`/`w:tblCellMar` без одноимённого соседа (`maxOccurs=1` на left). Ничего не поменялось → `rewrite` вернул `null` → исходный массив (`StrictOoxmlNormalizerTest#transitionalCoexistReturnsOriginalArray`). 2. `DocxOnOffNormalizer` — `w:val="off"/"on"` → `"false"/"true"`; якорь по тегу, правится только атрибут `w:val`, текст между тегами не трогается. -3. `SymbolFontNormalizer` — PUA U+F000–U+F0FF (Symbol/Wingdings/Webdings) → Unicode + DejaVu Sans; переписывает ``, правит `w:lvl` в numbering.xml; 5 карт по 256 слотов (таблица `SymbolMapper` из docx4j 17.x). -4. `FieldNormalizer` — `fldChar` PAGE/NUMPAGES/SECTIONPAGES → `w:fldSimple` (кэш страниц в PDF не попадает); вложенные/битые поля пропускаются. -5. `InvisibleCharNormalizer` — вырезает из `w:t` U+0085, U+2028, U+2029, U+200E/200F, U+202A–202E, U+2060, U+FEFF (FOP делает из них переносы/пустые строки, Arimo/Tinos рисуют боксы). U+00A0/U+00AD/U+200B–U+200D **не** трогает. -6. `GlyphCoverageNormalizer` — режет раны по покрытию глифов и пишет семейство в `w:rFonts`, иначе FOP рисует «#». Покрытие — `GlyphFont` (fontbox, cmap) + BitSet-кэш, **не** docx4j `GlyphCheck` (плодит INFO-лог; `java.awt.Font` требовал fontconfig на хосте). Для serif-ран fallback ищется сначала в `SERIF_FAMILIES` (`dejavu serif`, `tinos`, `caladea`), затем в sans. -7. `TableIndentNormalizer` — свёртка `w:tblPr/w:jc` (center/right) с любым (в т.ч. отсутствующим/нулевым) `w:tblInd` в абсолютный `w:tblInd` с удалением `w:jc` (Word: tblInd — сдвиг от поля после центрирования, MS-OI29500 §2.1.155; docx4j при jc≠left игнорирует tblInd буквально — Part 1 §17.4.50, а центрированию пишет абсолютный start-indent **без** вычета cellMar, поверх которого padding-компенсация правила LayoutPostRenderer уводит текст на +padding — свёртка обязательна и при X=0): center → (W−T)/2+X, right → (W−T)+X, W — полоса набора (pgSz − pgMar left/right в transitional и `w:start`/`w:end` в strict; дефолты 11906/1440 — измеренное поведение docx4j, не ECMA-1800), T — Σ gridCol; пропускает несколько body-level `sectPr`, не-dxa `tblInd`, `tblPr` с `tblCellSpacing` без `tblInd` (нет корректной позиции вставки по CT_TblPrBase), `tblW pct`, нецелые gridCol. Кроме `rewrite`/`STEP` (document.xml, полоса из собственного sectPr) есть `rewritePart(part, xml, band)` — `word/headerN.xml`/`footerN.xml` с полосой из document.xml (в частях колонтитуков своего sectPr нет) и `bandOf(documentXml)` — экстрактор полосы (−1 — полосы нет). Регрессия — WordPdfConverterTest#tableIndentCentered_shiftedLikeWord, #headerTableIndent_centeredInHeader, #tableCenteredNoIndent_shiftedLikeWord. -8. `NumberingSuffixNormalizer` — `w:suff w:val="space"` → дописанный обычный пробел в конце следующего `w:lvlText` того же уровня (порядок CT_Lvl suff→lvlText, wml.xsd; Part 1 §17.3.1.28): docx4j разделитель не эмитит вовсе (дамп n4.fo); уже пробельный lvlText не дублируется; suff=tab — отдельный Class C-остаток (нужна per-item ширина), nothing совпадает с docx4j. Регрессия — WordPdfConverterTest#suffSpace_labelGetsSpace. -9. `HiddenTextNormalizer` — вырезание скрытых ранов (Part 1 §17.3.2.30): truthy `w:vanish` в собственном `w:rPr` ранa (обе OnOff-формы; вал опущен — default true) **или** `w:rStyle` ∈ vanish-стили из `word/styles.xml` (транзитивно по `w:basedOn`, капа цепочки 16, цикл — обрыв); ран с защищённым содержимым (`fldChar`/`instrText`/`footnoteReference`/`endnoteReference`/`drawing`/`pict`/`object`/`txbxContent`) не трогается — удаление спаренных `begin…separate…end` сломало бы поле. Word скрытое не печатает, стилист docx4j `vanish` не читает вовсе → без правила скрытое утекало в PDF. Индивидуальный `normalize()` — свой pass styles.xml. Регрессия — WordPdfConverterTest#hiddenText_notPrinted, юниты — HiddenTextNormalizerTest. -10. `RubyNormalizer` — разбор руби-разметки (Part 1 §17.3.3.18/.19/.20/.21): `w:rubyBase`/`w:rubyBaseText` разворачиваются в обычные раны, `w:rt`/`w:rubyPr`/`w:rubyAlign` вырезаются с содержимым (надстрочница — принятая деградация, ruby-разметки в FOP нет; потеря текста хуже потери аннотации). Чинится **в байтах**, а не в XSLT: схема docx4j 17.3.2 не биндит `w:rubyBase`/`w:rt` в `w:r` — unmarshaller теряет их до стилиста (в отличие от `moveFrom`/`moveTo`/`bdo`/`dir`, которых схема знает — тех ловит AUDIT-FIX-2). Регрессия — WordPdfConverterTest#rubyBase_textPrinted, юниты — RubyNormalizerTest. -11. `OleObjectNormalizer` — принимает флаг `errorOnOle`. Два этапа: дешёвый детект по центральному каталогу zip (`ZipFile`; читаются только `[Content_Types].xml` и `word/*.xml` до первого `` из `word/*.xml` не выбрасываются, а заменяются статичным представлением — картинкой-плейсхолдером (ECMA-376 §15.2.10): `w:drawing` переиспользуется дословно, `v:imagedata r:id` → inline-DrawingML на ту же image-часть (размер из `style` `v:shape`, иначе `w:dxaOrig`/`w:dyaOrig` ×635), блоки с `w:control` и без плейсхолдера удаляются. OLE-бинарники никогда не читаются. При `errorOnOle=true` вместо вычистки — `DrawingFoundException(OLE)`. Лечит оба механизма падения docx4j: JAXB-разбор бинарника под ложным XML-типом («Content is not allowed in prolog» → NPE) и NPE `chunkType is null` в VML-сериализации `w:object`. Многочастный: публичный член только `normalize(byte[], boolean)`, `rewrite`-хука нет. + +> Правил symbol-шрифтов (PUA U+F000–U+F0FF → Unicode) и complex-полей PAGE/NUMPAGES/SECTIONPAGES → `w:fldSimple` в цепочке больше нет — их удалил апгрейд docx4j до 17.3.x: экспорт сам маппит символ-маркеры и пересчитывает page-поля вместо кэша. Пины отсутствия регрессии — `WordPdfConverterTest#symbolFonts_bulletsAreNotHash`, `pageNumbers_recomputedNotCached`. + +3. `InvisibleCharNormalizer` — вырезает из `w:t` U+0085, U+2028, U+2029, U+200E/200F, U+202A–202E, U+2060, U+FEFF (FOP делает из них переносы/пустые строки, Arimo/Tinos рисуют боксы). U+00A0/U+00AD/U+200B–U+200D **не** трогает. +4. `GlyphCoverageNormalizer` — режет раны по покрытию глифов и пишет семейство в `w:rFonts`, иначе FOP рисует «#». Покрытие — `GlyphFont` (fontbox, cmap) + BitSet-кэш, **не** docx4j `GlyphCheck` (плодит INFO-лог; `java.awt.Font` требовал fontconfig на хосте). Для serif-ран fallback ищется сначала в `SERIF_FAMILIES` (`dejavu serif`, `tinos`, `caladea`), затем в sans. +5. `TableIndentNormalizer` — свёртка `w:tblPr/w:jc` (center/right) с любым (в т.ч. отсутствующим/нулевым) `w:tblInd` в абсолютный `w:tblInd` с удалением `w:jc` (Word: tblInd — сдвиг от поля после центрирования, MS-OI29500 §2.1.155; docx4j при jc≠left игнорирует tblInd буквально — Part 1 §17.4.50, а центрированию пишет абсолютный start-indent **без** вычета cellMar, поверх которого padding-компенсация правила LayoutPostRenderer уводит текст на +padding — свёртка обязательна и при X=0): center → (W−T)/2+X, right → (W−T)+X, W — полоса набора (pgSz − pgMar left/right в transitional и `w:start`/`w:end` в strict; дефолты 11906/1440 — измеренное поведение docx4j, не ECMA-1800), T — Σ gridCol; пропускает несколько body-level `sectPr`, не-dxa `tblInd`, `tblPr` с `tblCellSpacing` без `tblInd` (нет корректной позиции вставки по CT_TblPrBase), `tblW pct`, нецелые gridCol. Кроме `rewrite`/`STEP` (document.xml, полоса из собственного sectPr) есть `rewritePart(part, xml, band)` — `word/headerN.xml`/`footerN.xml` с полосой из document.xml (в частях колонтитуков своего sectPr нет) и `bandOf(documentXml)` — экстрактор полосы (−1 — полосы нет). Регрессия — WordPdfConverterTest#tableIndentCentered_shiftedLikeWord, #headerTableIndent_centeredInHeader, #tableCenteredNoIndent_shiftedLikeWord. +6. `NumberingSuffixNormalizer` — `w:suff w:val="space"` → дописанный обычный пробел в конце следующего `w:lvlText` того же уровня (порядок CT_Lvl suff→lvlText, wml.xsd; Part 1 §17.3.1.28): docx4j разделитель не эмитит вовсе (дамп n4.fo); уже пробельный lvlText не дублируется; suff=tab — отдельный Class C-остаток (нужна per-item ширина), nothing совпадает с docx4j. Регрессия — WordPdfConverterTest#suffSpace_labelGetsSpace. +7. `HiddenTextNormalizer` — вырезание скрытых ранов (Part 1 §17.3.2.30): truthy `w:vanish` в собственном `w:rPr` ранa (обе OnOff-формы; вал опущен — default true) **или** `w:rStyle` ∈ vanish-стили из `word/styles.xml` (транзитивно по `w:basedOn`, капа цепочки 16, цикл — обрыв); ран с защищённым содержимым (`fldChar`/`instrText`/`footnoteReference`/`endnoteReference`/`drawing`/`pict`/`object`/`txbxContent`) не трогается — удаление спаренных `begin…separate…end` сломало бы поле. Word скрытое не печатает, стилист docx4j `vanish` не читает вовсе → без правила скрытое утекало в PDF. Индивидуальный `normalize()` — свой pass styles.xml. Регрессия — WordPdfConverterTest#hiddenText_notPrinted, юниты — HiddenTextNormalizerTest. +8. `RubyNormalizer` — разбор руби-разметки (Part 1 §17.3.3.18/.19/.20/.21): `w:rubyBase`/`w:rubyBaseText` разворачиваются в обычные раны, `w:rt`/`w:rubyPr`/`w:rubyAlign` вырезаются с содержимым (надстрочница — принятая деградация, ruby-разметки в FOP нет; потеря текста хуже потери аннотации). Чинится **в байтах**, а не в XSLT: схема docx4j 17.3.6 не биндит `w:rubyBase`/`w:rt` в `w:r` — unmarshaller теряет их до стилиста (в отличие от `moveFrom`/`moveTo`/`bdo`/`dir`, которых схема знает — тех ловит AUDIT-FIX-2). Регрессия — WordPdfConverterTest#rubyBase_textPrinted, юниты — RubyNormalizerTest. +9. `OleObjectNormalizer` — принимает флаг `errorOnOle`. Два этапа: дешёвый детект по центральному каталогу zip (`ZipFile`; читаются только `[Content_Types].xml` и `word/*.xml` до первого `` из `word/*.xml` не выбрасываются, а заменяются статичным представлением — картинкой-плейсхолдером (ECMA-376 §15.2.10): `w:drawing` переиспользуется дословно, `v:imagedata r:id` → inline-DrawingML на ту же image-часть (размер из `style` `v:shape`, иначе `w:dxaOrig`/`w:dyaOrig` ×635), блоки с `w:control` и без плейсхолдера удаляются. OLE-бинарники никогда не читаются. При `errorOnOle=true` вместо вычистки — `DrawingFoundException(OLE)`. Лечит оба механизма падения docx4j: JAXB-разбор бинарника под ложным XML-типом («Content is not allowed in prolog» → NPE) и NPE `chunkType is null` в VML-сериализации `w:object`. Многочастный: публичный член только `normalize(byte[], boolean)`, `rewrite`-хука нет. `mc-preprocessor.xslt` docx4j (в jar `docx4j-core`) перебивает strict-namespace'ы в transitional и конвертит `pt` в twips/half-points, но ветку перевода процентов в тысячные для namespace'ных атрибутов содержит с закомментированным `` (для атрибутов без namespace — она активна), а `w:start`/`w:end` в `w:left`/`w:right` не маппит вовсе. Поэтому собственный рерайт URI ломать нельзя — он сломал бы pt-конверсию preprocessor'а (FOP получил бы «10pt»). diff --git a/docs/agent/render-limitations.md b/docs/agent/render-limitations.md index d4ec640..1cea54c 100644 --- a/docs/agent/render-limitations.md +++ b/docs/agent/render-limitations.md @@ -4,6 +4,6 @@ - Известный остаток эталона: U+2188/U+218A — глифов нет в OFL-шрифтах бандла, остаются `.notdef` (GNU FreeSerif GPL — не добавляем намеренно). -- Аудит раскладки по ECMA-376 Part 1 (2026-10) — известные нечинимые ограничения FOP/docx4j (Java-слой): `w:jc="distribute"` рендерится как left — межсимвольного распределения в FOP нет (ST_Jc §17.18.44: distribute — межсимвольный разнос, justify только межсловный), последняя строка блока не растягивается, свойства `text-align-last` в форке нет (в docx4j-fo-renderer отсутствуют классы TextAlign*); `w:suff="tab"` и `w:lvlJc` игнорируются (numbering-лейбл всегда через hanging-tab; suff=space чинит правило 8, suff=nothing совпадает с docx4j — разделителя нет); абзац без `w:line` рендерится natural-высотой FOP 15.44pt@11pt, явный `lineRule="auto"` — 13.4277pt, два «single» в конвертере (13.4277 — канонический single по метрикам Carlito/Calibri 2500/2048 em; обе величины считаются по метрикам шрифта); кернинг не применяется ни для одного бандл-семейства (замер: advance A→V = A→A — Carlito 6.369pt, DejaVu Sans 7.524pt@11pt): 22 TTF — GPOS-only, а legacy `kern`-таблица DejaVu Sans/Serif ключована glyph id, не совпадающими с cmap (2568/2727 пар без Unicode-маппинга, пары A→V нет) — латинский путь FOP (`TextLayoutManager`→`Font.hasKerning`) читает только legacy `kern` и такие пары отбрасывает; свойства `kerning` в форке нет, порог `w:kern` через FO не выражается. Word кернит только при явно заданном `w:kern` в иерархии стилей и при sz ≥ val (Part 1 §17.3.2.19; при отсутствии `w:kern` Office не кернит — MS-OI29500 §21.1.2.3.9a) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 7), `w:suff="space"` (правило 8). +- Аудит раскладки по ECMA-376 Part 1 (2026-10, реаудит на docx4j 17.3.6 + форке FOP 2.12 — 2026-11) — известные нечинимые ограничения FOP/docx4j (Java-слой): `w:jc="distribute"` рендерится как left — межсимвольного распределения в FOP нет (ST_Jc §17.18.44: distribute — межсимвольный разнос, justify только межсловный), последняя строка блока не растягивается; в форке 2.12 свойство `text-align-last` **есть** (классы `TextAlignLast*`, `Block`/`FoProperties`), но маппинг docx4j `Justification.setXslFO` для `DISTRIBUTE` не эмитит его и ничего не эмитит вовсе (значение не попадает в `fo:text-align*` — замер: край строки 184 pt при полосе до 540 pt); `w:suff="tab"` и `w:lvlJc` игнорируются (numbering-лейбл всегда через hanging-tab; `lvlJc="right"` рендерится идентично `left` — лейблы по общему левому краю; suff=space чинит правило 6, suff=nothing совпадает с docx4j — разделителя нет); абзац без `w:line` рендерится natural-высотой FOP 15.44pt@11pt, явный `lineRule="auto"` — 13.4277pt, два «single» в конвертере (13.4277 — канонический single по метрикам Carlito/Calibri 2500/2048 em; обе величины считаются по метрикам шрифта); кернинг не применяется ни для одного бандл-семейства (замер на 17.3.6/форке 2.12: dx пары = сумма advance без поправки — Carlito «Wa»/«AV», DejaVu Sans «Ta»; GPOS-only у 22 TTF, а legacy `kern`-таблица DejaVu Sans/Serif ключована glyph id, не совпадающими с cmap (2568/2727 пар без Unicode-маппинга, пары A→V нет) — латинский путь FOP (`TextLayoutManager`→`Font.hasKerning`) читает только legacy `kern` и такие пары отбрасывает; GPOS-путь в форке тоже не применяется); свойства `kerning` в форке нет, порог `w:kern` через FO не выражается. Word кернит только при явно заданном `w:kern` в иерархии стилей и при sz ≥ val (Part 1 §17.3.2.19; при отсутствии `w:kern` Office не кернит — MS-OI29500 §21.1.2.3.9a) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 5), `w:suff="space"` (правило 6). Починено апстримом 17.3.6: `w:framePr` (фрейм позиционируется — замер: FRAME на x=252pt = левое поле 72pt + `w:x=180pt`; до апгрейда текст шёл в общем потоке), symbol-шрифты и complex-поля PAGE/NUMPAGES (экспорт сам маппит PUA-маркеры и пересчитывает page-поля). -- Аудит .docx-путей по ECMA-376 (2026-11) — запинено синтетикой (без фикстур): сноски/концевые сноски с номерами (§17.11), внешние гиперссылки с `/URI`-аннотацией (§17.12.23), `PAGEREF` (complex и вложенный в результат `TOC`) и `DATE` подменяют кэш живым значением, `titlePg` → first/default колонтитуки (§17.13.1.35), `vMerge` restart/continue (§17.4.70), block-level `w:sdt` (§17.5.2), `wps:txbx`-текст (§17.3.3.23), OMML-формулы рисуются вектором jeuclid-fop (§22.1 — текст из PDF не извлекается, пинь пикселями), фон `w:highlight`/`w:shd` рисуется (§17.3.2.16/.29). Скрытый текст `w:vanish` не печатается (правило 9); текст руби-базы и `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir` не теряется (правило 10 + AUDIT-FIX-2). Остаток (не чиним): `w:framePr` игнорируется — текст печатается в общем потоке, геометрия фрейма теряется (ни XSLT, ни `createBlockForPPr` не читают); `REF`/`SEQ`/литеральные записи `TOC` печатают устаревший кэш из docx (движка пересчёта нет; инстринции полей не печатаются); надстрочница руби не выводится (правило 10 печатает только базу — ruby-разметки в FOP нет); `w:ptab` без `@w:alignment`, `bar`, `list` теряются catch-all'ом; `w:bdo`/`w:dir` печатаются LTR (bidi вне контура). +- Аудит .docx-путей по ECMA-376 (2026-11) — запинено синтетикой (без фикстур): сноски/концевые сноски с номерами (§17.11), внешние гиперссылки с `/URI`-аннотацией (§17.12.23), `PAGEREF` (complex и вложенный в результат `TOC`) и `DATE` подменяют кэш живым значением, `titlePg` → first/default колонтитуки (§17.13.1.35), `vMerge` restart/continue (§17.4.70), block-level `w:sdt` (§17.5.2), `wps:txbx`-текст (§17.3.3.23), OMML-формулы рисуются вектором jeuclid-fop (§22.1 — текст из PDF не извлекается, пинь пикселями), фон `w:highlight`/`w:shd` рисуется (§17.3.2.16/.29). Скрытый текст `w:vanish` не печатается (правило 7); текст руби-базы и `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir` не теряется (правило 8 + AUDIT-FIX-2). Остаток (не чиним): `REF`/`SEQ`/литеральные записи `TOC` печатают устаревший кэш из docx (движка пересчёта нет; инстринции полей не печатаются); надстрочница руби не выводится (правило 8 печатает только базу — ruby-разметки в FOP нет); `w:ptab` без `@w:alignment`, `bar`, `list` теряются catch-all'ом; `w:bdo`/`w:dir` печатаются LTR (bidi вне контура). diff --git a/docs/agent/repo-map.md b/docs/agent/repo-map.md index 62f665d..2dc09f5 100644 --- a/docs/agent/repo-map.md +++ b/docs/agent/repo-map.md @@ -6,7 +6,7 @@ |---|---| | `wordpdf-core/src/main/java/ru/pjandro/wordpdf/` | Публичный API: `WordPdfConverter` (`convert(byte[],String,ConvertOptions)`), `WordPdfValidator` (`checkInput`/`validate` наружу; `checkPageCount`/`checkPageCountDoc`/`isBinaryDoc` — package-private, всё без зависимости от docx4j), `ConversionException`, `ValidationException` (наследник — «вход некорректен»), `DrawingFoundException` (`enum Kind {CHARTS, SMARTART, OLE}`), `ConvertOptions` (record; дефолтов в ядре нет). Пороги защиты — производные от лимитов входа: `WordPdfValidator.maxDecompressedBytes`/`maxDecompressedXmlBytes` (`max(MIN_*×MiB, maxMb×10/4MiB + maxPages×64/32KiB)`, крышек нет), `maxZipEntries` (`max(2048, maxMb×512 + maxPages×32)`), `maxImagePixels` (`maxMb×5_000_000`); коэффициенты и полы — package-private литералы `WordPdfConverter` (`DECOMPRESS_*`, `MIN_DECOMPRESSED_*`, `IMAGE_PIXELS_PER_MAX_MB`, `ZIP_ENTRIES_*`, javac их инлайнит — валидатор не инициализирует конвертер) | | `…/wordpdf/fonts/` | `BundledFonts` (реестр/выгрузка TTF), `BundledFontMapper` (алиасы, self-map, `DISPLAY_NAMES`, `bundledFamily`), `GlyphFont` (глиф-движок fontbox) | -| `…/wordpdf/internal/` | 11 нормализаторов + `DocxRewritePipeline` (один zip-проход правил 1–10, raw-копия неизменённых записей) + `LayoutPostRenderer` (кастомный `FORenderer`, post-FO padding-компенсация таблиц, шаг 4.25) + интерфейс `DocxNormalizer` + `FopFallbackFonts` + `DependencyGuard` (проверка commons-compress, шаг 0). Классы package-private; `public` — `DocxNormalizer`, `DocxRewritePipeline` (наружу только `STEP`, `normalize` package-private), `OleObjectNormalizer`, `FopFallbackFonts` (`declare`), `LayoutPostRenderer` (`register`), `DependencyGuard` (`check`), остальные нормализаторы полностью package-private; `OleObjectNormalizer` — многочастный, публичный `normalize(byte[], boolean)`, бросает `DrawingFoundException(OLE)` | +| `…/wordpdf/internal/` | 9 нормализаторов + `DocxRewritePipeline` (один zip-проход правил 1–8, raw-копия неизменённых записей) + `LayoutPostRenderer` (кастомный `FORenderer`, post-FO padding-компенсация таблиц, шаг 4.25) + интерфейс `DocxNormalizer` + `FopFallbackFonts` + `DependencyGuard` (проверка commons-compress, шаг 0). Классы package-private; `public` — `DocxNormalizer`, `DocxRewritePipeline` (наружу только `STEP`, `normalize` package-private), `OleObjectNormalizer`, `FopFallbackFonts` (`declare`), `LayoutPostRenderer` (`register`), `DependencyGuard` (`check`), остальные нормализаторы полностью package-private; `OleObjectNormalizer` — многочастный, публичный `normalize(byte[], boolean)`, бросает `DrawingFoundException(OLE)` | | `…/wordpdf/internal/doc/` | Мост `.doc` → `.docx`: 18 классов (детали — `docs/agent/doc-bridge.md`) — `CfbReader`, `FibHeader`, `PieceTable`, `Grpprl`, `ChpxIndex`, `PapxIndex`, `Styles`, `Tables`, `Lists`, `Sections`, `FontTable`, `SummaryInfo`, `Headers`, `OfficeArt`, `PrcData`, `DocFile`, `DocxWriter`, `DocToDocx` (публичные `convert`/`countPages`; вложенный `DocxBody` — рендер текста и табличного автомата в XML) | | `…/wordpdf/internal/chart/` |18 классов Java2D-рендера диаграмм/SmartArt в PNG (public: `DrawingPreRenderer.run` и `ChartImageHandler` — второй инстанцируется из `WordPdfConverter`)| | `wordpdf-core/src/main/resources/fonts/` | 30 TTF + 3 лицензии — бинарные фикстуры, часть jar | @@ -34,7 +34,7 @@ - `wordpdf-app/src/main/resources/application.properties` — multipart 100MB (`max-file-size`/`max-request-size` + `file-size-threshold=2MB` — части крупнее 2 МБ на диск, не в память; в тон gateway `client_max_body_size 100m`), `wordpdf.convert-timeout=2m`, пустой `wordpdf.api-key`, `server.forward-headers-strategy=framework` (префикс прод-прокси для springdoc) + `springdoc.swagger-ui.persist-authorization=true`; `wordpdf.max-mb`/`max-pages` здесь намеренно нет. - `wordpdf-app/pom.xml` — `spring-boot-maven-plugin` с **явной** execution `repackage` (в 4.1.1 сам не связывается, jar останется тонким); `slf4j-simple` исключён; `spring-boot-starter-webmvc` (Boot 4: переименован из starter-web) + `spring-boot-starter-actuator` (нужен HEALTHCHECK контейнера `/actuator/health`); тест-зависимости: `spring-boot-webmvc-test` (в Boot 4 автоконфиг MockMvc вынесен из starter-test), test-jar core. - `wordpdf-core/pom.xml` — `maven-jar-plugin` execution `test-jar` (публикует фикстуры для app); JaCoCo execution `check` переопределён (LINE 0.90 + BRANCH 0.85). -- Корневой `pom.xml` — все версии зависимостей (в модулях версии не объявлять): docx4j `17.3.2`, commons-compress `1.28.0`, slf4j `2.0.20`, JUnit `6.1.3`, PDFBox/fontbox `3.0.8` (`fontbox` — compile в core: глиф-движок `GlyphFont`; `pdfbox` — test в обоих модулях; commons-logging исключён, мост — `jcl-over-slf4j`), POI `5.5.1` (test), Spring Boot `4.1.1` (BOM-import), springdoc `3.1.1`; pluginManagement: compiler `3.16.0`, surefire `3.6.0` с `-Djava.awt.headless=true`, jar `3.5.1`, PMD `3.28.0`, JaCoCo `0.8.15`; пустой дефолт `` (для `-Djacoco.skip=true`). +- Корневой `pom.xml` — все версии зависимостей (в модулях версии не объявлять): docx4j `17.3.6`, commons-compress `1.28.0`, slf4j `2.0.20`, JUnit `6.1.3`, PDFBox/fontbox `3.0.8` (`fontbox` — compile в core: глиф-движок `GlyphFont`; `pdfbox` — test в обоих модулях; commons-logging исключён, мост — `jcl-over-slf4j`), POI `5.5.1` (test), Spring Boot `4.1.1` (BOM-import), springdoc `3.1.1`; pluginManagement: compiler `3.16.0`, surefire `3.6.0` с `-Djava.awt.headless=true`, jar `3.5.1`, PMD `3.28.0`, JaCoCo `0.8.15`; пустой дефолт `` (для `-Djacoco.skip=true`). - `pmd-ruleset.xml` — ruleset PMD (см. Code Conventions). - `.ci/maven-settings.xml` — Maven-зеркало Nexus с URL из `${env.MAVEN_MIRROR_URL}` (общий файл CI-job'ов `java` и Containerfile; координаты стенда в репо не хранятся — Variable/build-arg). - `wordpdf-core/src/main/resources/slf4j-simple.properties` — без него предупреждение лезет в PDF. @@ -107,7 +107,7 @@ unzip -p ~/.m2/repository/org/docx4j/docx4j-export-fo/<версия>/docx4j-expo PMD: `failurePriority` в плагине не задан — на практике `verify` валит нарушение любой приоритетности; перечень исключённых правил в AGENTS.md не дублируется — единственный источник `pmd-ruleset.xml`. -- Нормализаторы — единый контракт `internal/DocxNormalizer` + константа `STEP`; цепочка `WordPdfConverter.normalizers()` = `DocxRewritePipeline.STEP` (правила 1–10 одним zip-проходом) + лямбда `OleObjectNormalizer`; нечего менять → **тот же массив**; package-private хук `static String rewrite(String xml)` для юнит-тестов (возвращает `null` при отсутствии изменений; есть у 10 из 11 — у многочастного `OleObjectNormalizer` нет); у `StrictOoxmlNormalizer` есть также `rewritePart(entryName, xml)`, у `TableIndentNormalizer` — `rewritePart(name, xml, band)` (per-part-логика, хуки пайплайна); правятся только части `word/*.xml`. +- Нормализаторы — единый контракт `internal/DocxNormalizer` + константа `STEP`; цепочка `WordPdfConverter.normalizers()` = `DocxRewritePipeline.STEP` (правила 1–8 одним zip-проходом) + лямбда `OleObjectNormalizer`; нечего менять → **тот же массив**; package-private хук `static String rewrite(String xml)` для юнит-тестов (возвращает `null` при отсутствии изменений; есть у 8 из 9 — у многочастного `OleObjectNormalizer` нет); у `StrictOoxmlNormalizer` есть также `rewritePart(entryName, xml)`, у `TableIndentNormalizer` — `rewritePart(name, xml, band)` (per-part-логика, хуки пайплайна); правятся только части `word/*.xml`. - Классы в `internal` — `public` (иначе родительский пакет не вызвал бы), но публичные члены наружу только `normalize`/`STEP`/`declare`/`DrawingPreRenderer.run`/`DependencyGuard.check` (`rewrite`, карты — package-private); в `wordpdf-app` всё package-private кроме `WordPdfApplication`. diff --git a/docs/agent/testing.md b/docs/agent/testing.md index 8b1e6ab..72ad428 100644 --- a/docs/agent/testing.md +++ b/docs/agent/testing.md @@ -2,7 +2,7 @@ ### Счётчики (2026-11) -- 59 тестовых классов / 898 тестов: core 53/849 (`internal/doc/` 17/225, `internal/chart/` 17/271, `WordPdfConverterTest` 77), app 6/49 (ConvertController 23, ApiKeyFilter 8, ConversionService 5, ApiExceptionHandler 5, ConvertLimits 5, ConversionTimeout 3). Обновлять при изменении набора. +- 57 тестовых классов / 881 тест: core 51/833 (`internal/doc/` 17/232, `internal/chart/` 17/277, `WordPdfConverterTest` 82), app 6/48 (ConvertController 26, ApiKeyFilter 8, ConversionService 5, ApiExceptionHandler 5, ConvertLimits 3, ConversionTimeout 1). Обновлять при изменении набора. ### Пиксели, метрики шрифтов, стенд без fontconfig -- 2.56.1 From cbd4742a9627c5c9c1acb79180c33aa49052b872 Mon Sep 17 00:00:00 2001 From: Pjandro Date: Sun, 8 Nov 2026 21:57:37 +0000 Subject: [PATCH 3/9] =?UTF-8?q?test(core):=20=D0=B2=D0=B5=D1=82=D0=BA?= =?UTF-8?q?=D0=B8=20=D0=BC=D1=83=D1=81=D0=BE=D1=80=D0=BD=D1=8B=D1=85=20?= =?UTF-8?q?=D0=B7=D0=B0=D0=B3=D0=BE=D0=BB=D0=BE=D0=B2=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D1=80=D0=B0=D1=81=D1=82=D1=80=D0=BE=D0=B2=20=D0=B8=20null-?= =?UTF-8?q?=D0=B3=D0=B5=D0=B9=D0=B4=D0=BE=D0=B2=20=D0=B2=D0=B0=D0=BB=D0=B8?= =?UTF-8?q?=D0=B4=D0=B0=D1=82=D0=BE=D1=80=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Удаление правил Symbol/Field (делает сам экспорт 17.3.x) убрало два хорошо покрытых класса и просадил branch-coverage 0.8505 → 0.8487 под гейт JaCoCo 0.85. Добавлены тесты задокументированных, но не покрытых веток WordPdfValidator#rasterArea (битые сигнатуры PNG/BMP по байтно, короткие заголовки, JPEG: нет FFD8, мусор-маркер, обход DHT/C8/CC и нетелевых RST/TEM, SOF0 без телеги) и null-контрактов validate/checkPageCountDoc/isBinaryDoc. Регрессия — WordPdfValidatorTest#validate_rasterGarbageHeadsAccepted, #nullGuards_rejectBeforeWork, #validate_nullOptions_rejected. --- .../pjandro/wordpdf/WordPdfValidatorTest.java | 90 +++++++++++++++++++ 1 file changed, 90 insertions(+) diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfValidatorTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfValidatorTest.java index 1c975f5..48de630 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfValidatorTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfValidatorTest.java @@ -661,6 +661,96 @@ class WordPdfValidatorTest { } } + /** + * Мусорные и обрезанные заголовки растров — все ветки отказа «-1» в + * сканере {@link WordPdfValidator}: PNG длиной ≥24 с битой сигнатурой + * (каждый байт отдельно), BMP короче 26 и BMP с битым вторым байтом, + * JPEG короче 4, JPEG без FFD8, мусор-маркер после валидных сегментов, + * SOFn без телеги (i+9>len), обход нетелевых маркеров (SOI внутри + * потока, RSTn, TEM) и сегментов DHT/JPEG-app (C4/C8/CC не считаются + * SOF). Ни один не отклоняется: площадь не объявлена, decode ограничен + * бюджетом распаковки. Регрессия — WordPdfValidator#rasterArea. + */ + @Test + void validate_rasterGarbageHeadsAccepted() throws Exception { + byte[][] pngs = new byte[4][]; + for (int bad = 0; bad < 4; bad++) { + byte[] png = new byte[24]; + System.arraycopy(new byte[] {(byte) 0x89, 'P', 'N', 'G', 0x0D, 0x0A, 0x1A, 0x0A}, + 0, png, 0, 8); + png[bad] = (byte) (bad == 0 ? 0x00 : 'X'); // байт сигнатуры испорчен + pngs[bad] = png; + } + byte[] bmpShort = {'B', 'M'}; // < 26 байт + byte[] bmpMagic = new byte[26]; + bmpMagic[0] = 'B'; + bmpMagic[1] = 'X'; // 'BM' битый со второго байта + byte[] jpgEmpty = {(byte) 0xFF}; // < 4 байт + byte[] jpgNoFf = {0x00, 0x01, 0x02, 0x03}; // первый байт не 0xFF + byte[] jpgNoD8 = {(byte) 0xFF, 0x00, 0x00, 0x00}; // нет FFD8 + // FFD8 FFD8 (SOI внутри потока — i+=2), APP0-сегмент (пропуск по длине), + // DHT (C4 — не SOF), RST0 (нет телеги), TEM, затем SOF0 без телеги: i+9 > len. + // Отрезано на 44-м байте: маркер FFC0 виден сканеру (окно i+4), телеги не хватает. + byte[] jpgSofTruncated = java.util.Arrays.copyOf(jpgSkippingSegments(), 44); + // тот же поток, но SOF0 полный (10×10) — проходит как маленький растр. + byte[] jpgOk = jpgSkippingSegments(); + // мусор вместо маркера после валидного APP0-сегмента (len 6 — сам + // сканер читает окно i+4, следующий «маркер» 00 попадает в него). + ByteArrayOutputStream junk = new ByteArrayOutputStream(); + junk.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xD8, (byte) 0xFF, (byte) 0xE0, 0x00, 0x06}); + junk.writeBytes(new byte[4]); + junk.writeBytes(new byte[] {0x00, 0x00, 0x00, 0x00}); + byte[][] jpgs = {jpgEmpty, jpgNoFf, jpgNoD8, jpgSofTruncated, jpgOk, junk.toByteArray()}; + for (int i = 0; i < pngs.length; i++) { + byte[] zip = zipOf("word/media/g" + i + ".png", pngs[i]); + assertDoesNotThrow(() -> WordPdfValidator.validate(zip, DEF_OPTS), "png[" + i + "]"); + } + byte[][] bmps = {bmpShort, bmpMagic}; + for (int i = 0; i < bmps.length; i++) { + byte[] zip = zipOf("word/media/g" + i + ".bmp", bmps[i]); + assertDoesNotThrow(() -> WordPdfValidator.validate(zip, DEF_OPTS), "bmp[" + i + "]"); + } + for (int i = 0; i < jpgs.length; i++) { + byte[] zip = zipOf("word/media/g" + i + ".jpg", jpgs[i]); + assertDoesNotThrow(() -> WordPdfValidator.validate(zip, DEF_OPTS), "jpg[" + i + "]"); + } + } + + /** + * JPEG-поток, проводящий сканер через все continue-ветки: двойной SOI, + * APP0 (пропуск по длине), DHT (C4 — не SOF несмотря на диапазон C0–CF), + * C8/CC (аналогично), RST0 и TEM (маркеры без телеги, i+=2), и + * завершающий полный SOF0 10×10. + */ + private static byte[] jpgSkippingSegments() { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xD8}); // SOI + out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xD8}); // второй SOI: i+=2 + out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xE0, 0x00, 0x12}); // APP0, len 18 + out.writeBytes(new byte[16]); + out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xC4, 0x00, 0x02}); // DHT: не SOF, пропуск + out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xC8, 0x00, 0x02}); // C8: не SOF + out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xCC, 0x00, 0x02}); // CC: не SOF + out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xD0}); // RST0: без телеги + out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0x01}); // TEM: без телеги + out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xC0, 0x00, 0x11, 0x08, 0x00, 0x0A, 0x00, 0x0A}); + return out.toByteArray(); + } + + /** {@code null}-входы package-private гейтов: отказ {@link ValidationException} / false. */ + @Test + void nullGuards_rejectBeforeWork() { + assertThrows(ValidationException.class, () -> WordPdfValidator.checkPageCountDoc(null, 100)); + assertFalse(WordPdfValidator.isBinaryDoc(null)); + assertFalse(WordPdfValidator.isBinaryDoc(new byte[] {(byte) 0xD0, (byte) 0xCF, 0x11, (byte) 0xE0})); + } + + /** {@code null}-параметры публичного {@code validate}: лимиты обязаны быть заданы. */ + @Test + void validate_nullOptions_rejected() { + assertThrows(ValidationException.class, () -> WordPdfValidator.validate(new byte[8], null)); + } + @Test void validate_tooManyPages() throws Exception { byte[] bytes = docxWithPageBreaks(120); -- 2.56.1 From 87b9288aaf0f26342dc258f78f1a194ae3910b82 Mon Sep 17 00:00:00 2001 From: Pjandro Date: Sun, 8 Nov 2026 22:09:52 +0000 Subject: [PATCH 4/9] =?UTF-8?q?docs(core):=20=D1=83=D1=82=D0=BE=D1=87?= =?UTF-8?q?=D0=BD=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=B3=D1=8D=D0=BF=D0=B0=20?= =?UTF-8?q?=D0=BD=D1=83=D0=BC=D0=B5=D1=80=D0=B0=D1=86=D0=B8=D0=B8=20=D0=BF?= =?UTF-8?q?=D0=BE=D1=81=D0=BB=D0=B5=20=D0=B7=D0=BE=D0=BD=D0=B4=D0=B0=20?= =?UTF-8?q?=D0=BD=D0=B0=2017.3.6+=D1=84=D0=BE=D1=80=D0=BA=D0=B5=20?= =?UTF-8?q?=E2=80=94=20suff=3Dtab/space=20=D1=80=D0=B0=D0=B1=D0=BE=D1=82?= =?UTF-8?q?=D0=B0=D0=B5=D1=82=20(docx4j:label-suffix=20+=20WordListItemLay?= =?UTF-8?q?outManager),=20=D0=BD=D0=B5=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8?= =?UTF-8?q?=D0=B7=D1=83=D0=B5=D1=82=D1=81=D1=8F=20=D1=82=D0=BE=D0=BB=D1=8C?= =?UTF-8?q?=D0=BA=D0=BE=20w:lvlJc?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/agent/render-limitations.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/agent/render-limitations.md b/docs/agent/render-limitations.md index 1cea54c..8029366 100644 --- a/docs/agent/render-limitations.md +++ b/docs/agent/render-limitations.md @@ -4,6 +4,6 @@ - Известный остаток эталона: U+2188/U+218A — глифов нет в OFL-шрифтах бандла, остаются `.notdef` (GNU FreeSerif GPL — не добавляем намеренно). -- Аудит раскладки по ECMA-376 Part 1 (2026-10, реаудит на docx4j 17.3.6 + форке FOP 2.12 — 2026-11) — известные нечинимые ограничения FOP/docx4j (Java-слой): `w:jc="distribute"` рендерится как left — межсимвольного распределения в FOP нет (ST_Jc §17.18.44: distribute — межсимвольный разнос, justify только межсловный), последняя строка блока не растягивается; в форке 2.12 свойство `text-align-last` **есть** (классы `TextAlignLast*`, `Block`/`FoProperties`), но маппинг docx4j `Justification.setXslFO` для `DISTRIBUTE` не эмитит его и ничего не эмитит вовсе (значение не попадает в `fo:text-align*` — замер: край строки 184 pt при полосе до 540 pt); `w:suff="tab"` и `w:lvlJc` игнорируются (numbering-лейбл всегда через hanging-tab; `lvlJc="right"` рендерится идентично `left` — лейблы по общему левому краю; suff=space чинит правило 6, suff=nothing совпадает с docx4j — разделителя нет); абзац без `w:line` рендерится natural-высотой FOP 15.44pt@11pt, явный `lineRule="auto"` — 13.4277pt, два «single» в конвертере (13.4277 — канонический single по метрикам Carlito/Calibri 2500/2048 em; обе величины считаются по метрикам шрифта); кернинг не применяется ни для одного бандл-семейства (замер на 17.3.6/форке 2.12: dx пары = сумма advance без поправки — Carlito «Wa»/«AV», DejaVu Sans «Ta»; GPOS-only у 22 TTF, а legacy `kern`-таблица DejaVu Sans/Serif ключована glyph id, не совпадающими с cmap (2568/2727 пар без Unicode-маппинга, пары A→V нет) — латинский путь FOP (`TextLayoutManager`→`Font.hasKerning`) читает только legacy `kern` и такие пары отбрасывает; GPOS-путь в форке тоже не применяется); свойства `kerning` в форке нет, порог `w:kern` через FO не выражается. Word кернит только при явно заданном `w:kern` в иерархии стилей и при sz ≥ val (Part 1 §17.3.2.19; при отсутствии `w:kern` Office не кернит — MS-OI29500 §21.1.2.3.9a) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 5), `w:suff="space"` (правило 6). Починено апстримом 17.3.6: `w:framePr` (фрейм позиционируется — замер: FRAME на x=252pt = левое поле 72pt + `w:x=180pt`; до апгрейда текст шёл в общем потоке), symbol-шрифты и complex-поля PAGE/NUMPAGES (экспорт сам маппит PUA-маркеры и пересчитывает page-поля). +- Аудит раскладки по ECMA-376 Part 1 (2026-10, реаудит на docx4j 17.3.6 + форке FOP 2.12 — 2026-11) — известные нечинимые ограничения FOP/docx4j (Java-слой): `w:jc="distribute"` рендерится как left — межсимвольного распределения в FOP нет (ST_Jc §17.18.44: distribute — межсимвольный разнос, justify только межсловный), последняя строка блока не растягивается; в форке 2.12 свойство `text-align-last` **есть** (классы `TextAlignLast*`, `Block`/`FoProperties`), но маппинг docx4j `Justification.setXslFO` для `DISTRIBUTE` не эмитит его и ничего не эмитит вовсе (значение не попадает в `fo:text-align*` — замер: край строки 184 pt при полосе до 540 pt); `w:lvlJc` игнорируется (numbering-лейбл всегда у number position: `lvlJc="right"`/`"center"` рендерятся идентично `left` — лейблы по общему левому краю; suff=space чинит правило 6, suff=nothing совпадает с docx4j — разделителя нет); абзац без `w:line` рендерится natural-высотой FOP 15.44pt@11pt, явный `lineRule="auto"` — 13.4277pt, два «single» в конвертере (13.4277 — канонический single по метрикам Carlito/Calibri 2500/2048 em; обе величины считаются по метрикам шрифта); кернинг не применяется ни для одного бандл-семейства (замер на 17.3.6/форке 2.12: dx пары = сумма advance без поправки — Carlito «Wa»/«AV», DejaVu Sans «Ta»; GPOS-only у 22 TTF, а legacy `kern`-таблица DejaVu Sans/Serif ключована glyph id, не совпадающими с cmap (2568/2727 пар без Unicode-маппинга, пары A→V нет) — латинский путь FOP (`TextLayoutManager`→`Font.hasKerning`) читает только legacy `kern` и такие пары отбрасывает; GPOS-путь в форке тоже не применяется); свойства `kerning` в форке нет, порог `w:kern` через FO не выражается. Word кернит только при явно заданном `w:kern` в иерархии стилей и при sz ≥ val (Part 1 §17.3.2.19; при отсутствии `w:kern` Office не кернит — MS-OI29500 §21.1.2.3.9a) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 5), `w:suff="space"` (правило 6). Починено апстримом 17.3.6: `w:framePr` (фрейм позиционируется — замер: FRAME на x=252pt = левое поле 72pt + `w:x=180pt`; до апгрейда текст шёл в общем потоке), symbol-шрифты и complex-поля PAGE/NUMPAGES (экспорт сам маппит PUA-маркеры и пересчитывает page-поля). - Аудит .docx-путей по ECMA-376 (2026-11) — запинено синтетикой (без фикстур): сноски/концевые сноски с номерами (§17.11), внешние гиперссылки с `/URI`-аннотацией (§17.12.23), `PAGEREF` (complex и вложенный в результат `TOC`) и `DATE` подменяют кэш живым значением, `titlePg` → first/default колонтитуки (§17.13.1.35), `vMerge` restart/continue (§17.4.70), block-level `w:sdt` (§17.5.2), `wps:txbx`-текст (§17.3.3.23), OMML-формулы рисуются вектором jeuclid-fop (§22.1 — текст из PDF не извлекается, пинь пикселями), фон `w:highlight`/`w:shd` рисуется (§17.3.2.16/.29). Скрытый текст `w:vanish` не печатается (правило 7); текст руби-базы и `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir` не теряется (правило 8 + AUDIT-FIX-2). Остаток (не чиним): `REF`/`SEQ`/литеральные записи `TOC` печатают устаревший кэш из docx (движка пересчёта нет; инстринции полей не печатаются); надстрочница руби не выводится (правило 8 печатает только базу — ruby-разметки в FOP нет); `w:ptab` без `@w:alignment`, `bar`, `list` теряются catch-all'ом; `w:bdo`/`w:dir` печатаются LTR (bidi вне контура). -- 2.56.1 From 6137fc705d98843ee0ed556e58452aff8e38eb45 Mon Sep 17 00:00:00 2001 From: Pjandro Date: Sun, 8 Nov 2026 23:18:56 +0000 Subject: [PATCH 5/9] =?UTF-8?q?build(core):=20FOP-=D0=BE=D0=B2=D0=B5=D1=80?= =?UTF-8?q?=D0=BB=D0=B5=D0=B9=20ru.pjandro:docx4j-fo-renderer-core=202.12-?= =?UTF-8?q?docx4j.1-pj.2=20=D0=B2=D0=BC=D0=B5=D1=81=D1=82=D0=BE=20=D1=86?= =?UTF-8?q?=D0=B5=D0=BD=D1=82=D1=80=D0=B0=D0=BB=D1=8C=D0=BD=D0=BE=D0=B3?= =?UTF-8?q?=D0=BE=20fop-core?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Exclusion org.docx4j:docx4j-fo-renderer-core из docx4j-export-fo + зависимость на собственный форк (word-layout менеджеры: label-align, line-box, tab-транспорт, distribute-пин); тонкий docx4j-fo-renderer с маркером Docx4jFop остаётся. Версия — fop-overlay.version в корневом dependencyManagement. --- pom.xml | 10 ++++++++++ wordpdf-core/pom.xml | 14 ++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/pom.xml b/pom.xml index 3c6dded..ed8f1eb 100644 --- a/pom.xml +++ b/pom.xml @@ -26,6 +26,9 @@ 1.28.0 + + 2.12-docx4j.1-pj.2 2.0.20 @@ -77,6 +80,13 @@ docx4j-export-fo ${docx4j.version}
+ + + ru.pjandro + docx4j-fo-renderer-core + ${fop-overlay.version} + diff --git a/wordpdf-core/pom.xml b/wordpdf-core/pom.xml index 5e0233f..a5ddf57 100644 --- a/wordpdf-core/pom.xml +++ b/wordpdf-core/pom.xml @@ -29,6 +29,20 @@ org.docx4j docx4j-export-fo + + + org.docx4j + docx4j-fo-renderer-core + + + + + + ru.pjandro + docx4j-fo-renderer-core -- 2.56.1 From 838ec29a69f88489fc9a53a21bec3de1977d5d85 Mon Sep 17 00:00:00 2001 From: Pjandro Date: Sun, 8 Nov 2026 23:18:56 +0000 Subject: [PATCH 6/9] =?UTF-8?q?feat(core):=20=D0=BF=D1=80=D0=B0=D0=B2?= =?UTF-8?q?=D0=B8=D0=BB=D0=BE=209=20DistributeStampNormalizer=20-=20w:jc?= =?UTF-8?q?=3Ddistribute=20=D1=80=D0=B0=D1=81=D1=82=D1=8F=D0=B3=D0=B8?= =?UTF-8?q?=D0=B2=D0=B0=D0=B5=D1=82=20=D0=B2=D1=81=D0=B5=20=D1=81=D1=82?= =?UTF-8?q?=D1=80=D0=BE=D0=BA=D0=B8=20(Part=201=2017.18.44)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit docx4j для DISTRIBUTE не эмитит в FO ничего - абзац печатался по левому краю. Нормализатор ставит в distribute-абзацы закладку-якорь pj-distribute-<часть>- (после Hidden, content-части, идемпотентно), LayoutPostRenderer по якорю дописывает блоку пару text-align/text-align-last=justify - межсловный разнос всех строк, включая последнюю (пин форка DistributeLineTestCase). Паттерн якоря принимает и префиксную, и безпрефиксную сериализацию fo:inline (DOM-поддерево toNode). Фикстура distribute.docx (хвост трёхсловный - одно слово растягивать нечем), регрессии distribute_allLinesReachRightMargin + юниты нормализатора и фильтра. Доки: правила 1-9 (Ole - правило 10), шаг 4.25, FOP-оверлей в инвариантах и новая секция AGENTS; render-limitations - distribute перенесён в починенное. Дополнительно в AGENTS: заметки про гейт готовности podman-контейнеров. --- AGENTS.md | 19 +- docs/agent/pipeline.md | 11 +- docs/agent/render-limitations.md | 2 +- .../internal/DistributeStampNormalizer.java | 187 ++++++++++++++++++ .../wordpdf/internal/DocxRewritePipeline.java | 17 +- .../wordpdf/internal/LayoutPostRenderer.java | 69 ++++++- .../pjandro/wordpdf/SampleDocxGenerator.java | 31 +++ .../pjandro/wordpdf/WordPdfConverterTest.java | 57 ++++++ .../DistributeStampNormalizerTest.java | 165 ++++++++++++++++ .../internal/LayoutPostRendererTest.java | 54 +++++ .../test/resources/samples/distribute.docx | Bin 0 -> 2447 bytes 11 files changed, 596 insertions(+), 16 deletions(-) create mode 100644 wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizer.java create mode 100644 wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizerTest.java create mode 100644 wordpdf-core/src/test/resources/samples/distribute.docx diff --git a/AGENTS.md b/AGENTS.md index fb4e8b2..5b12099 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -18,16 +18,20 @@ Порядок шагов 0–7 фиксирован (`convertToStream`), местами менять нельзя. Вход роутируется по сигнатуре: `PK\x03\x04` → docx-путь; `D0 CF 11 E0 A1 B1 1A E1` (CFB, MS-CFB §2.2) → `DocToDocx.convert` → in-memory `.docx` → тот же конвейер (предикат — `WordPdfValidator.isBinaryDoc`). Валидация — **до** `convertToStream`: `WordPdfValidator.validate(bytes, options)` (размер → подпись zip/CFB → контейнер → страницы); для `.doc` — `checkPageCountDoc` по сырым байтам. -Порядок: шрифты (`BundledFontMapper` → `BundledFonts.init` → `restrictToBundled`) и правила 1–8 (`DocxRewritePipeline.STEP`) + `OleObjectNormalizer` — до `WordprocessingMLPackage.load`; `FOSettings`/`FopFallbackFonts`/`LayoutPostRenderer` — до `setCustomXsltTemplates(VendoredXslt.TEMPLATES)`; `Docx4J.toFO(…, FLAG_EXPORT_PREFER_XSL)` — последним; `finally` → `deleteEmbeddedFontTempFiles()` + сброс имиджевых кешей общей FopFactory + `BundledFonts.restrictToBundled()` (реестр шрифтов возвращается в бандл-состояние: `load()` регистрирует встроенные шрифты документа в глобальном `PhysicalFonts`). Полная таблица шагов и подсчёт страниц — `docs/agent/pipeline.md`. +Порядок: шрифты (`BundledFontMapper` → `BundledFonts.init` → `restrictToBundled`) и правила 1–9 (`DocxRewritePipeline.STEP`) + `OleObjectNormalizer` — до `WordprocessingMLPackage.load`; `FOSettings`/`FopFallbackFonts`/`LayoutPostRenderer` — до `setCustomXsltTemplates(VendoredXslt.TEMPLATES)`; `Docx4J.toFO(…, FLAG_EXPORT_PREFER_XSL)` — последним; `finally` → `deleteEmbeddedFontTempFiles()` + сброс имиджевых кешей общей FopFactory + `BundledFonts.restrictToBundled()` (реестр шрифтов возвращается в бандл-состояние: `load()` регистрирует встроенные шрифты документа в глобальном `PhysicalFonts`). Полная таблица шагов и подсчёт страниц — `docs/agent/pipeline.md`. ## Нормализаторы (`internal/DocxNormalizer`) -Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame`). Порядок фиксирован: Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby. Правила 1–8 применяет `DocxRewritePipeline.STEP` одним zip-проходом (неизменённые записи копируются raw-сжатыми байтами); `OleObjectNormalizer` (правило 9) — лямбдой в `WordPdfConverter.normalizers()`. `STEP` выставляют 7 из 8 rewrite-нормализаторов (нет у `RubyNormalizer`), у `OleObjectNormalizer` её нет. Правил Symbol-шрифтов и complex-полей PAGE/NUMPAGES больше нет — с docx4j 17.3.x их делает сам экспорт (#701, CR-067); пины отсутствия регрессии — `symbolFonts_bulletsAreNotHash`, `pageNumbers_recomputedNotCached`. Правила 1–9, guard'ы, номера секций и инвариант `mc-preprocessor.xslt` (собственный рерайт strict-URI ломать нельзя) — `docs/agent/pipeline.md`. +Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame`). Порядок фиксирован: Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby→Distribute. Правила 1–9 применяет `DocxRewritePipeline.STEP` одним zip-проходом (неизменённые записи копируются raw-сжатыми байтами); `OleObjectNormalizer` (правило 10) — лямбдой в `WordPdfConverter.normalizers()`. `STEP` выставляют 8 из 9 rewrite-нормализаторов (нет у `RubyNormalizer`), у `OleObjectNormalizer` её нет. Правил Symbol-шрифтов и complex-полей PAGE/NUMPAGES больше нет — с docx4j 17.3.x их делает сам экспорт (#701, CR-067); пины отсутствия регрессии — `symbolFonts_bulletsAreNotHash`, `pageNumbers_recomputedNotCached`. Правила 1–9, guard'ы, номера секций и инвариант `mc-preprocessor.xslt` (собственный рерайт strict-URI ломать нельзя) — `docs/agent/pipeline.md`. ## Мост `.doc` → `.docx` (`internal/doc`) 18 классов, 17 package-private; наружу — только `DocToDocx` (`convert`/`countPages`). Общий разбор — `DocFile`: CFB → потоки WordDocument / 0Table|1Table / Data + FIB + piece table. Новых runtime-зависимостей нет (POI/POIFS — test-scope). Источники: [MS-DOC] (`docs/standards/doc/`), [MS-CFB]/[MS-OLEPS]/[MS-ODRAW] (`docs/standards/binary/`). Байтовые раскладки по классам — `docs/agent/doc-bridge.md`. +## FOP-оверлей (`ru.pjandro:docx4j-fo-renderer-core`) + +Форк `org.docx4j:docx4j-fo-renderer-core` 2.12-docx4j.1 (он же Apache FOP 2.12) в репо `ai/xmlgraphics-fop-pj` (Gitea); версии вида `2.12-docx4j.1-pj.N` (наследование по схеме форка, README репо), артефакты — Nexus maven-hosted (входит в `maven-public`). Подключение: в `wordpdf-core/pom.xml` — exclusion `org.docx4j:docx4j-fo-renderer-core` из `docx4j-export-fo` + зависимость `ru.pjandro:docx4j-fo-renderer-core` (версия `${fop-overlay.version}` в корневом pom); тонкий `docx4j-fo-renderer` (hooks-маркер `Docx4jFop`) НЕ исключается. В оверлее наши патчи помечены `Added by pjandro`/`CR-0xx`, тесты — package `org.apache.fop.layoutmgr.word` (в т.ч. `DistributeLineTestCase` — пин justify-пары для distribute). Новый релиз оверлея: `mvn deploy` в репо форка → bump `fop-overlay.version` → `mvn clean verify` здесь. Пайплайн CI форка не связан с этим репо. + ## REST API (`wordpdf-app`, всё package-private кроме `WordPdfApplication`) `POST /api/v1/convert`: multipart-поле `file` (`.docx`/`.doc`) + query/form-параметры `errorOnCharts`/`errorOnSmartArt`/`errorOnOle` (дефолт каждого — `false`), `maxMb`/`maxPages` (лимиты входа: переопределяют серверный дефолт в обе стороны; ≤ 0 → 400). Ответ — `application/pdf`, `Content-Disposition: attachment; filename*=UTF-8''…`; имя — `ConversionService.safeBaseName`. Тело ошибки — `{"error": …}`. Error-флаги на `.doc` **не срабатывают** (BLIP-плейсхолдеры → картинки). `ApiExceptionHandler` не видит ошибок фильтров — 401 пишет сам `ApiKeyFilter`. @@ -51,11 +55,11 @@ Java2D → PNG: `ChartRenderer.DPI = 300`, потолок `MAX_PIXELS = 16_777_2 - `docx4j.fonts.discoverPhysicalFonts.enabled=false` и `discoverJarFonts.enabled=false` — static-блок: иначе `BestMatchingMapper` сканирует системные шрифты и jar'ы classpath'а, а `restrictToBundled()` всё найденное выбрасывает (~100–140 мс впустую на JVM). `discoverJarFonts("fonts-symbol")` свойством не гейтится — символ-шрифт регистрируется и снимается restrict'ом как раньше. - Единственный XSL-FO-стилист — вендорный `xslt/docx2fo.xslt` (копия из docx4j-export-fo 17.3.6 + два AUDIT-FIX-патча: `w:rPr/w:position` → `baseline-shift`, Part 1 §17.3.2.24; AUDIT-FIX-2 — `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir`, иначе их ловит catch-all `match="*"` и текст теряется). Дрейф-гейт `vendoredXsltTracksJarCopy`: вне AUDIT-FIX-регионов копия побайтно равна стилю из jar'а. `setCustomXsltTemplates` принимает предкомпилированный `Templates`. - `slf4j-simple` обязателен в ядре: без SLF4J-провайдера docx4j пишет «TO HIDE THESE MESSAGES» прямо в PDF (регрессия `noLoggingWarningInPdf`); приложение исключает его — логи ведёт logback. -- FOP — форк `org.docx4j:docx4j-fo-renderer*` 2.12-docx4j.1 (транзитив от `docx4j-export-fo`, в pom не пинится; пакеты `org.apache.fop.*`). `FopFallbackFonts` берёт `w:renderer` с mime `application/pdf`, иначе первый со шрифтами. +- FOP — собственный оверлей `ru.pjandro:docx4j-fo-renderer-core:${fop-overlay.version}` (форк `org.docx4j:docx4j-fo-renderer-core` 2.12-docx4j.1 = FOP 2.12 + word-layout; пакеты `org.apache.fop.*`; репо `ai/xmlgraphics-fop-pj`, артефакт — Nexus). `docx4j-export-fo` исключает центральный `org.docx4j:docx4j-fo-renderer-core`; тонкий `docx4j-fo-renderer` (маркер `Docx4jFop`, хук word-layout) остаётся из `docx4j-export-fo`. `FopFallbackFonts` берёт `w:renderer` с mime `application/pdf`, иначе первый со шрифтами. - `BundledFonts.init()` идемпотентен, распаковывает TTF в `wordpdf-fonts-*` (`deleteOnExit`); `dropNonBundled()` чистит `PhysicalFonts` от всего, что вне бандла; ВСЕ синхронизированные методы `BundledFonts` (`init`/`restrictToBundled`/`font`) держат монитор `WordPdfConverter.class` (не собственный замок класса) — тот же, что сериализует конвертации, поэтому внешний вызов рядом с идущей конвертацией безопасен автоматически. Регрессия — `WordPdfConverterTest#concurrentFontMutators_conversionsUnharmed`. - `PhysicalFonts` — глобальный и мутируемый → конвертации сериализуются монитором `WordPdfConverter.class` внутри ядра (общая `FopFactory` и сброс её image-кешей — под тем же монитором); приложение держит однопоточный воркер ради 503/timeout; `warmup()` идёт тем же потоком. - Страницы в валидаторе = `max(кэш docProps/app.xml, явные разрывы, lastRenderedPageBreak+1)`; правила StAX-подсчёта — `docs/agent/pipeline.md`. -- Не чинить: `jc="distribute"` (в FOP-форке 2.12 есть `text-align-last`, но маппинг `Justification` не эмитит его и межсимвольного разноса нет), `suff="tab"`/`lvlJc`, метрика «single», кернинг, `REF`/`SEQ`/`TOC`-кэш, руби-надстрочница, U+2188/U+218A — доказательства в `docs/agent/render-limitations.md`. `framePr` починен апстримом 17.3.6 (фрейм позиционируется). +- Не чинить: `suff="tab"`/`lvlJc`, метрика «single», кернинг, `REF`/`SEQ`/`TOC`-кэш, руби-надстрочница, U+2188/U+218A — доказательства в `docs/agent/render-limitations.md`. `framePr` починен апстримом 17.3.6 (фрейм позиционируется); `jc="distribute"` починен правилом 9 + justify-парой в `LayoutPostRenderer` (межсловный разнос всех строк, межсимвольный kashida не реализован). - Комментарии в `WordPdfConverter`/`DocxOnOffNormalizer` говорят «docx4j 11.x» — устаревшее число, фактически 17.3.6 (описанное поведение верно). ## Шрифты (30 TTF + 3 лицензии, SIL OFL, `wordpdf-core/src/main/resources/fonts/`) @@ -84,6 +88,13 @@ python3 docs/standards/docx/validate-fixtures.py wordpdf-core/src/test/resources **«Запусти тестовый сервер» (термин пользователя)** = полный dev-стенд, НЕ `java -jar`: `podman-compose -f compose.dev.yml up -d --build --force-recreate`, вход `http://:9011` без API-ключа; гейт — контейнеры healthy + корень SPA отвечает 200. `--force-recreate` обязателен: без него контейнеры остаются на старом образе. +**Ожидание готовности podman-контейнеров** (одинаково для dev-стенда и для собственных тестовых контейнеров): +- Гейт — наблюдаемый факт готовности, а не «подождал N секунд»: HTTP-эндпоинт сервиса (`curl -fs --max-time 2 …`) или, для контейнера с healthcheck, `podman inspect --format '{{.State.Health.Status}}'` = `healthy`. +- Ждать — синхронным `until`-циклом с жёстким потолком и коротким шагом, в том же вызове, что и идущая сразу за гейтом проверка: `timeout 180 sh -c 'until curl -fs --max-time 2 http://127.0.0.1:9011/ -o /dev/null; do sleep 2; done' && <смоук>`. Готово — цикл выходит за секунды; потолок срабатывает только при настоящей неполадке (тогда читать `podman logs `). +- **Нельзя** считать `healthy` по всему списку контейнеров (`grep -c healthy`): у контейнеров без healthcheck (nginx-гейтстенд) статус никогда не содержит `healthy` — такой цикл молча крутится до самого дедлайна, стена при этом уже готова. У контейнеров без healthcheck единственный гейт — HTTP. +- **Нельзя** крутить цикл ожидания отдельным async-job'ом и поллить его: либо `podman-compose up` + `until`-гейт + смоук одним синхронным вызовом, либо (если сборка образа долгая и уходит в фон) — по её завершении гейт-цикл синхронно. +- Одноразовая проверка в контейнере вообще не ждёт готовности: `podman run --rm ` блокирующий — читать exit code и stdout. + Пересоздание фикстур и перевендоривание стилиста — `docs/agent/repo-map.md`. Деплой: **прод** — на пользовательском LAN-сервере; **перед деплоем/перезапуском прочитать `/home/pjandro/prod/java-word-pdf/DEPLOY.md`**; пуск — push в `main` или Run workflow, ручных скриптов нет (детали — `docs/agent/ci-cd.md`). ## Code Conventions & Common Patterns diff --git a/docs/agent/pipeline.md b/docs/agent/pipeline.md index 87b0fe0..a1a6c91 100644 --- a/docs/agent/pipeline.md +++ b/docs/agent/pipeline.md @@ -6,11 +6,11 @@ |---|---|---| | 0 | `DependencyGuard.check()` | API-проба `ZipArchiveInputStream.getNextEntry()` — совместимость commons-compress ≥ 1.25.0; иначе `ConversionException` с инструкцией вместо мутного `NoSuchMethodError` внутри docx4j | | 1 | `new BundledFontMapper()` → `BundledFonts.init()` → `restrictToBundled()` | Конструктор маппера (static `BestMatchingMapper`) регистрирует в `PhysicalFonts` только symbol-шрифты из `docx4j-export-fo-fonts-symbol` (сканы системы и jar'ов отключены в static-блоке `WordPdfConverter` гейт-свойствами — всё найденное всё равно выбрасывает `restrictToBundled()`); `init()` вызывает `dropNonBundled()` **до** регистрации бандла, `restrictToBundled()` оставляет реестр = бандл + встроенные в docx. Порядок `init()` после конструктора — инвариант: `addPhysicalFont` не перезаписывает занятый ключ (иначе системный Calibri ломает em-dash-fallback) | -|2|`DocxRewritePipeline.STEP` → `OleObjectNormalizer` → `WordprocessingMLPackage.load`|Один zip-проход переписывания XML-частей (правила 1–8 — раздел «Нормализаторы: контракт и правила 1–9» в этом файле) + условная OLE-вычистка (правило 9)| +|2|`DocxRewritePipeline.STEP` → `OleObjectNormalizer` → `WordprocessingMLPackage.load`|Один zip-проход переписывания XML-частей (правила 1–9 — раздел «Нормализаторы: контракт и правила 1–10» в этом файле) + условная OLE-вычистка (правило 10)| | 3 | `pkg.setFontMapper(mapper)` | Привязка шрифтов документа к физическим TTF | | 3.5 | `DrawingPreRenderer.run(pkg, options)` | `c:chart`/`dgm:relIds` → PNG 300 dpi → `pic:pic` (docx2fo.xslt их не умеет) | | 4 | `new FOSettings(pkg)` + `FopFallbackFonts.declare(foSettings)` | В FOP-конфиг добавляются **все** бандл-семейства: FOP встраивает только задекларированные | -| 4.25 | `LayoutPostRenderer.register(foSettings)` | Кастомный `FORenderer`: post-FO padding-компенсация таблиц (`start-indent` += `padding-left` первой ячейки), внутри — штатный `FORendererApacheFOP` | +| 4.25 | `LayoutPostRenderer.register(foSettings)` | Кастомный `FORenderer`: post-FO padding-компенсация таблиц (`start-indent` += `padding-left` первой ячейки) + justify-пара блокам с якорем `pj-distribute-` (правило 9), внутри — штатный `FORendererApacheFOP` | | 4.5 | `foSettings.setCustomXsltTemplates(VendoredXslt.TEMPLATES)` | Стилист — вендорный `xslt/docx2fo.xslt` (копия docx4j-export-fo + AUDIT-FIX-патчи: `w:rPr/w:position`→`baseline-shift` и AUDIT-FIX-2 `moveFrom`/`moveTo`/`bdo`/`dir`); `Templates` компилируется один раз — `getTemplates` кастит значение в `Templates` | | 5 | `FORendererApacheFOP.getFopFactoryBuilder` + `getFOUserAgent` | Непустой `title` → заголовок PDF | | 6 | `Docx4J.toFO(foSettings, os, FLAG_EXPORT_PREFER_XSL)` | XSL-FO → PDF | @@ -26,9 +26,9 @@ - Страницы в валидаторе = `max(кэш docProps/app.xml, явные разрывы, lastRenderedPageBreak+1)`; explicit = межсекционные `w:sectPr` в body + `w:br type="page"` + `pageBreakBefore` (включая таблицы и `w:sdt`). Единственный путь — lightweight (StAX по zip, secure-ридер без DTD/external entities; `WordPdfValidator` не зависит от docx4j): атрибуты — по локальному имени (`attrLocal`, не по transitional-URI: иначе в strict-документе `w:br type="page"` не засчитываются); `sectPr` внутри `pPr` не считает, последнюю body-direct секцию не считает, `continuous`-секции не считает, в колонтитуках — только `w:br type="page"`, `pageBreakBefore` — только внутри `pPr` вне `sectPr` (truthy `val`: `null|true|1|on`). На не-zip молчит — подпись проверяет вызывающий. `checkPageCount` — один стриминговый проход `ZipInputStream` без буферизации частей (хелпер `noClose` глушит `close()` сканеров): потребление O(одной части) вместо O(суммы XML-частей). -### Нормализаторы: контракт и правила 1–9 (детали) +### Нормализаторы: контракт и правила 1–10 (детали) -Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame` в тестах). Восемь rewrite-нормализаторов цепляются в фиксированном порядке Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby; константу `STEP` (`public static final DocxNormalizer`) выставляют семь из восьми (нет только у `RubyNormalizer` — он цепочный, подключается внутри пайплайна), у `OleObjectNormalizer` STEP **нет** — он подключается лямбдой в `WordPdfConverter.normalizers()`. Правила 1–8 применяет `internal/DocxRewritePipeline` — **один zip-проход**: к каждой записи `word/*.xml` рерайты применяются последовательно (каждое правило работает только содержимым одной части — по-частная цепочка эквивалентна последовательным полным проходам); до прохода из `word/document.xml` извлекается полоса набора (`TableIndentNormalizer.bandOf`, −1 — полосы нет), и `word/headerN.xml`/`footerN.xml` дополнительно прогоняются через `TableIndentNormalizer.rewritePart` с этой полосой, и из `word/styles.xml` читается множество vanish-стилей (`HiddenTextNormalizer.vanishStyles`, цепочка `w:basedOn`) — контекст правила 7; неизменённые записи переносятся raw-копией сжатых байтов (без inflate/deflate); нигде не поменялось → тот же массив. `OleObjectNormalizer` — второй условный проход (меняет части, а не XML). Индивидуальные `normalize()` восьми нормализаторов сохранены (контракт юнит-тестов), но `WordPdfConverter` их не вызывает — его `normalizers(options)` = `DocxRewritePipeline.STEP` + лямбда OLE. Порядок правил значим: +Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame` в тестах). Девять rewrite-нормализаторов цепляются в фиксированном порядке Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby→Distribute; константу `STEP` (`public static final DocxNormalizer`) выставляют восемь из девяти (нет только у `RubyNormalizer` — он цепочный, подключается внутри пайплайна), у `OleObjectNormalizer` STEP **нет** — он подключается лямбдой в `WordPdfConverter.normalizers()`. Правила 1–9 применяет `internal/DocxRewritePipeline` — **один zip-проход**: к каждой записи `word/*.xml` рерайты применяются последовательно (каждое правило работает только содержимым одной части — по-частная цепочка эквивалентна последовательным полным проходам); до прохода из `word/document.xml` извлекается полоса набора (`TableIndentNormalizer.bandOf`, −1 — полосы нет), и `word/headerN.xml`/`footerN.xml` дополнительно прогоняются через `TableIndentNormalizer.rewritePart` с этой полосой, и из `word/styles.xml` читается множество vanish-стилей (`HiddenTextNormalizer.vanishStyles`, цепочка `w:basedOn`) — контекст правила 7; неизменённые записи переносятся raw-копией сжатых байтов (без inflate/deflate); нигде не поменялось → тот же массив. `OleObjectNormalizer` — второй условный проход (меняет части, а не XML). Индивидуальные `normalize()` девяти нормализаторов сохранены (контракт юнит-тестов), но `WordPdfConverter` их не вызывает — его `normalizers(options)` = `DocxRewritePipeline.STEP` + лямбда OLE. Порядок правил значим: 1. `StrictOoxmlNormalizer` — strict-OOXML → transitional: `a:`-проценты и `w14:fillToRect` → тысячные ×1000, текст `wp14:pctWidth`/`pctHeight`; элементы `w:start`/`w:end` → `w:left`/`w:right` (кроме `w:lvl/w:start` в numbering.xml); значения `w:val="start"/"end"` у `w:jc` и `w:tab` правятся **всегда** (docx4j `Justification.setXslFO` знает только left/center/right/both, для END `fo:text-align` не пишет вовсе — `jc="end"` рендерился по левому краю; Part 1 §17.3.1.13: `jc val="end"` — правовыравнивание в LTR, ST_Jc §17.18.44; RTL вне контура — FOP без complex-script). Strict-ность части определяется наличием `http://purl.oclc.org` (не «transitional-URI в документе» — mixed-документ трактуется по каждой части). **Guard сосуществования форм**: атрибут `w:start`/`w:end` переименовывается только внутри открывающего тега `w:ind` (MS-OI29500 §2.1.174a — псевдонимы left/right; у `w:pgNumType` `w:start` — старт нумерации страниц, легален в transitional, Part 1 §17.13.7 — не трогается) и не переименовывается, если в том же открывающем теге уже есть `w:left`/`w:right` (дубль атрибута ломает well-formedness — регрессии `indCoexistLeftStartUntouched`, `indCoexistForms_convertsNotRejected`, `pgNumTypeStartAttrUntouched`); элементы `w:start`/`w:end` в strict-части переименовываются глобально, в transitional — только внутри `w:tcMar`/`w:tblCellMar` без одноимённого соседа (`maxOccurs=1` на left). Ничего не поменялось → `rewrite` вернул `null` → исходный массив (`StrictOoxmlNormalizerTest#transitionalCoexistReturnsOriginalArray`). 2. `DocxOnOffNormalizer` — `w:val="off"/"on"` → `"false"/"true"`; якорь по тегу, правится только атрибут `w:val`, текст между тегами не трогается. @@ -41,6 +41,7 @@ 6. `NumberingSuffixNormalizer` — `w:suff w:val="space"` → дописанный обычный пробел в конце следующего `w:lvlText` того же уровня (порядок CT_Lvl suff→lvlText, wml.xsd; Part 1 §17.3.1.28): docx4j разделитель не эмитит вовсе (дамп n4.fo); уже пробельный lvlText не дублируется; suff=tab — отдельный Class C-остаток (нужна per-item ширина), nothing совпадает с docx4j. Регрессия — WordPdfConverterTest#suffSpace_labelGetsSpace. 7. `HiddenTextNormalizer` — вырезание скрытых ранов (Part 1 §17.3.2.30): truthy `w:vanish` в собственном `w:rPr` ранa (обе OnOff-формы; вал опущен — default true) **или** `w:rStyle` ∈ vanish-стили из `word/styles.xml` (транзитивно по `w:basedOn`, капа цепочки 16, цикл — обрыв); ран с защищённым содержимым (`fldChar`/`instrText`/`footnoteReference`/`endnoteReference`/`drawing`/`pict`/`object`/`txbxContent`) не трогается — удаление спаренных `begin…separate…end` сломало бы поле. Word скрытое не печатает, стилист docx4j `vanish` не читает вовсе → без правила скрытое утекало в PDF. Индивидуальный `normalize()` — свой pass styles.xml. Регрессия — WordPdfConverterTest#hiddenText_notPrinted, юниты — HiddenTextNormalizerTest. 8. `RubyNormalizer` — разбор руби-разметки (Part 1 §17.3.3.18/.19/.20/.21): `w:rubyBase`/`w:rubyBaseText` разворачиваются в обычные раны, `w:rt`/`w:rubyPr`/`w:rubyAlign` вырезаются с содержимым (надстрочница — принятая деградация, ruby-разметки в FOP нет; потеря текста хуже потери аннотации). Чинится **в байтах**, а не в XSLT: схема docx4j 17.3.6 не биндит `w:rubyBase`/`w:rt` в `w:r` — unmarshaller теряет их до стилиста (в отличие от `moveFrom`/`moveTo`/`bdo`/`dir`, которых схема знает — тех ловит AUDIT-FIX-2). Регрессия — WordPdfConverterTest#rubyBase_textPrinted, юниты — RubyNormalizerTest. -9. `OleObjectNormalizer` — принимает флаг `errorOnOle`. Два этапа: дешёвый детект по центральному каталогу zip (`ZipFile`; читаются только `[Content_Types].xml` и `word/*.xml` до первого `` из `word/*.xml` не выбрасываются, а заменяются статичным представлением — картинкой-плейсхолдером (ECMA-376 §15.2.10): `w:drawing` переиспользуется дословно, `v:imagedata r:id` → inline-DrawingML на ту же image-часть (размер из `style` `v:shape`, иначе `w:dxaOrig`/`w:dyaOrig` ×635), блоки с `w:control` и без плейсхолдера удаляются. OLE-бинарники никогда не читаются. При `errorOnOle=true` вместо вычистки — `DrawingFoundException(OLE)`. Лечит оба механизма падения docx4j: JAXB-разбор бинарника под ложным XML-типом («Content is not allowed in prolog» → NPE) и NPE `chunkType is null` в VML-сериализации `w:object`. Многочастный: публичный член только `normalize(byte[], boolean)`, `rewrite`-хука нет. +9. `DistributeStampNormalizer` — `w:pPr/w:jc w:val="distribute"` → невидимая закладка-якорь `w:bookmarkStart w:name="pj-distribute-<часть>-"` сразу после `` (Part 1 §17.18.44): docx4j для DISTRIBUTE не эмитит в FO ничего, канонический эквивалент — пара `text-align`/`text-align-last="justify"`, но стилист править нельзя (дрейф-гейт), а `LayoutPostRenderer` опознаёт абзац только по якорю — `BookmarkStartWriter` делает из закладки `` первым инлайн-ребёнком блока, фильтр дописывает блоку justify-пару (сериализация без префикса `fo:` учтена паттерном). Штампуются только content-части (document/footnotes/endnotes; в numbering у `CT_Lvl` закладок не бывает, `w:jc` в `trPr`/`tblPr` не читается — разбор только внутри `w:pPr`); счётчик id от max существующих +1, идемпотентность по метке `pj-distribute-`. Идёт после Hidden, чтобы не штамповать вырезанный абзац. Регрессия — WordPdfConverterTest#distribute_allLinesReachRightMargin, юниты — DistributeStampNormalizerTest, пин форка — DistributeLineTestCase. +10. `OleObjectNormalizer` — принимает флаг `errorOnOle`. Два этапа: дешёвый детект по центральному каталогу zip (`ZipFile`; читаются только `[Content_Types].xml` и `word/*.xml` до первого `` из `word/*.xml` не выбрасываются, а заменяются статичным представлением — картинкой-плейсхолдером (ECMA-376 §15.2.10): `w:drawing` переиспользуется дословно, `v:imagedata r:id` → inline-DrawingML на ту же image-часть (размер из `style` `v:shape`, иначе `w:dxaOrig`/`w:dyaOrig` ×635), блоки с `w:control` и без плейсхолдера удаляются. OLE-бинарники никогда не читаются. При `errorOnOle=true` вместо вычистки — `DrawingFoundException(OLE)`. Лечит оба механизма падения docx4j: JAXB-разбор бинарника под ложным XML-типом («Content is not allowed in prolog» → NPE) и NPE `chunkType is null` в VML-сериализации `w:object`. Многочастный: публичный член только `normalize(byte[], boolean)`, `rewrite`-хука нет. `mc-preprocessor.xslt` docx4j (в jar `docx4j-core`) перебивает strict-namespace'ы в transitional и конвертит `pt` в twips/half-points, но ветку перевода процентов в тысячные для namespace'ных атрибутов содержит с закомментированным `` (для атрибутов без namespace — она активна), а `w:start`/`w:end` в `w:left`/`w:right` не маппит вовсе. Поэтому собственный рерайт URI ломать нельзя — он сломал бы pt-конверсию preprocessor'а (FOP получил бы «10pt»). diff --git a/docs/agent/render-limitations.md b/docs/agent/render-limitations.md index 8029366..4f03e89 100644 --- a/docs/agent/render-limitations.md +++ b/docs/agent/render-limitations.md @@ -4,6 +4,6 @@ - Известный остаток эталона: U+2188/U+218A — глифов нет в OFL-шрифтах бандла, остаются `.notdef` (GNU FreeSerif GPL — не добавляем намеренно). -- Аудит раскладки по ECMA-376 Part 1 (2026-10, реаудит на docx4j 17.3.6 + форке FOP 2.12 — 2026-11) — известные нечинимые ограничения FOP/docx4j (Java-слой): `w:jc="distribute"` рендерится как left — межсимвольного распределения в FOP нет (ST_Jc §17.18.44: distribute — межсимвольный разнос, justify только межсловный), последняя строка блока не растягивается; в форке 2.12 свойство `text-align-last` **есть** (классы `TextAlignLast*`, `Block`/`FoProperties`), но маппинг docx4j `Justification.setXslFO` для `DISTRIBUTE` не эмитит его и ничего не эмитит вовсе (значение не попадает в `fo:text-align*` — замер: край строки 184 pt при полосе до 540 pt); `w:lvlJc` игнорируется (numbering-лейбл всегда у number position: `lvlJc="right"`/`"center"` рендерятся идентично `left` — лейблы по общему левому краю; suff=space чинит правило 6, suff=nothing совпадает с docx4j — разделителя нет); абзац без `w:line` рендерится natural-высотой FOP 15.44pt@11pt, явный `lineRule="auto"` — 13.4277pt, два «single» в конвертере (13.4277 — канонический single по метрикам Carlito/Calibri 2500/2048 em; обе величины считаются по метрикам шрифта); кернинг не применяется ни для одного бандл-семейства (замер на 17.3.6/форке 2.12: dx пары = сумма advance без поправки — Carlito «Wa»/«AV», DejaVu Sans «Ta»; GPOS-only у 22 TTF, а legacy `kern`-таблица DejaVu Sans/Serif ключована glyph id, не совпадающими с cmap (2568/2727 пар без Unicode-маппинга, пары A→V нет) — латинский путь FOP (`TextLayoutManager`→`Font.hasKerning`) читает только legacy `kern` и такие пары отбрасывает; GPOS-путь в форке тоже не применяется); свойства `kerning` в форке нет, порог `w:kern` через FO не выражается. Word кернит только при явно заданном `w:kern` в иерархии стилей и при sz ≥ val (Part 1 §17.3.2.19; при отсутствии `w:kern` Office не кернит — MS-OI29500 §21.1.2.3.9a) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 5), `w:suff="space"` (правило 6). Починено апстримом 17.3.6: `w:framePr` (фрейм позиционируется — замер: FRAME на x=252pt = левое поле 72pt + `w:x=180pt`; до апгрейда текст шёл в общем потоке), symbol-шрифты и complex-поля PAGE/NUMPAGES (экспорт сам маппит PUA-маркеры и пересчитывает page-поля). +- Аудит раскладки по ECMA-376 Part 1 (2026-10, реаудит на docx4j 17.3.6 + форке FOP 2.12 — 2026-11) — известные нечинимые ограничения FOP/docx4j (Java-слой): `w:lvlJc` игнорируется (numbering-лейбл всегда у number position: `lvlJc="right"`/`"center"` рендерятся идентично `left` — лейблы по общему левому краю; suff=space чинит правило 6, suff=nothing совпадает с docx4j — разделителя нет); абзац без `w:line` рендерится natural-высотой FOP 15.44pt@11pt, явный `lineRule="auto"` — 13.4277pt, два «single» в конвертере (13.4277 — канонический single по метрикам Carlito/Calibri 2500/2048 em; обе величины считаются по метрикам шрифта); кернинг не применяется ни для одного бандл-семейства (замер на 17.3.6/форке 2.12: dx пары = сумма advance без поправки — Carlito «Wa»/«AV», DejaVu Sans «Ta»; GPOS-only у 22 TTF, а legacy `kern`-таблица DejaVu Sans/Serif ключована glyph id, не совпадающими с cmap (2568/2727 пар без Unicode-маппинга, пары A→V нет) — латинский путь FOP (`TextLayoutManager`→`Font.hasKerning`) читает только legacy `kern` и такие пары отбрасывает; GPOS-путь в форке тоже не применяется); свойства `kerning` в форке нет, порог `w:kern` через FO не выражается. Word кернит только при явно заданном `w:kern` в иерархии стилей и при sz ≥ val (Part 1 §17.3.2.19; при отсутствии `w:kern` Office не кернит — MS-OI29500 §21.1.2.3.9a) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 5), `w:suff="space"` (правило 6). Починено на 17.3.6+форке: `w:jc="distribute"` (правило 9 `DistributeStampNormalizer` ставит закладку-якорь, `LayoutPostRenderer` дописывает блоку пару `text-align`/`text-align-last="justify"` — межсловный разнос всех строк, включая последнюю; пин в форке `DistributeLineTestCase`, в конвертере `distribute_allLinesReachRightMargin`; межсимвольный kashida-разнос §17.18.44 не реализован — для латиницы Word разносит межсловные пробелы, однословная строка не растягивается, потому что растягивать нечем). Починено апстримом 17.3.6: `w:framePr` (фрейм позиционируется — замер: FRAME на x=252pt = левое поле 72pt + `w:x=180pt`; до апгрейда текст шёл в общем потоке), symbol-шрифты и complex-поля PAGE/NUMPAGES (экспорт сам маппит PUA-маркеры и пересчитывает page-поля). - Аудит .docx-путей по ECMA-376 (2026-11) — запинено синтетикой (без фикстур): сноски/концевые сноски с номерами (§17.11), внешние гиперссылки с `/URI`-аннотацией (§17.12.23), `PAGEREF` (complex и вложенный в результат `TOC`) и `DATE` подменяют кэш живым значением, `titlePg` → first/default колонтитуки (§17.13.1.35), `vMerge` restart/continue (§17.4.70), block-level `w:sdt` (§17.5.2), `wps:txbx`-текст (§17.3.3.23), OMML-формулы рисуются вектором jeuclid-fop (§22.1 — текст из PDF не извлекается, пинь пикселями), фон `w:highlight`/`w:shd` рисуется (§17.3.2.16/.29). Скрытый текст `w:vanish` не печатается (правило 7); текст руби-базы и `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir` не теряется (правило 8 + AUDIT-FIX-2). Остаток (не чиним): `REF`/`SEQ`/литеральные записи `TOC` печатают устаревший кэш из docx (движка пересчёта нет; инстринции полей не печатаются); надстрочница руби не выводится (правило 8 печатает только базу — ruby-разметки в FOP нет); `w:ptab` без `@w:alignment`, `bar`, `list` теряются catch-all'ом; `w:bdo`/`w:dir` печатаются LTR (bidi вне контура). diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizer.java new file mode 100644 index 0000000..6c6d82e --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizer.java @@ -0,0 +1,187 @@ +package ru.pjandro.wordpdf.internal; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; +import java.util.zip.ZipOutputStream; + +/** + * {@code w:pPr/w:jc w:val="distribute"} → невидимая закладка-штамп в начале + * абзаца — до загрузки docx4j (Part 1 §17.18.44). + * + *

Word при {@code distribute} растягивает межсловные пробелы каждой строки + * абзаца, включая последнюю. docx4j для DISTRIBUTE не эмитит в FO ничего + * ({@code Justification.setXslFO} не знает этого значения): абзац приходит в + * FOP без {@code text-align} и печатается по левому краю. Канонический FO + * эквивалент — {@code text-align="justify" text-align-last="justify"} (пин в + * форке: DistributeLineTestCase), но в XSLT-стилиста дописать атрибутику jc + * нельзя (дрейф-гейт {@code vendoredXsltTracksJarCopy}), а рендер-фильтр + * {@code LayoutPostRenderer} видит только FO и опознал бы distribute-абзац + * лишь по якорю. Штамп — этот якорь: {@code w:bookmarkStart + * w:name="pj-distribute-<часть>-"} сразу после {@code }; экспорт + * docx4j ({@code BookmarkStartWriter}) превращает её в {@code } первым инлайн-ребёнком блока, и фильтр дописывает + * блоку пару justify-свойств. Имена закладок уникальны в пределах конвертации + * (docx4j дубликаты выбрасывает с warn), поэтому счётчик per-part с меткой + * части в имени.

+ * + *

Штампуются только content-части (document/footnotes/endnotes): в + * {@code numbering.xml} у {@code CT_Lvl} закладки быть не может (не входит в + * EG_PPrGeneralContent, WML XSD), а {@code w:jc} в {@code trPr}/{@code tblPr} + * (выравнивание таблицы/строки) не читается — разбор идёт только содержимым + * {@code w:pPr}. Диапазон абзаца плоский: {@code w:p} не вложен в {@code w:p}. + * Уже проштампованный абзац не дублируется (идемпотентность). Нечего менять → + * {@code null} (контракт rewrite-хуков).

+ * + *

Регрессии — DistributeStampNormalizerTest (юнит), + * WordPdfConverterTest#distribute_allLinesReachRightMargin (конвейер), + * фикстура samples/distribute.docx.

+ */ +final class DistributeStampNormalizer { + + /** Начало абзаца: {@code } или {@code }; {@code w:pPr}-подобные не матчатся. */ + private static final Pattern PARA_START = Pattern.compile("/])"); + + /** justify-раскладка абзаца; ищем только внутри w:pPr. */ + private static final Pattern JC_DISTRIBUTE = + Pattern.compile("]*w:val=\"distribute\""); + + /** Существующие id закладок — штампуете от max+1 (Part 1: id уникален в части). */ + private static final Pattern BOOKMARK_ID = + Pattern.compile("]*w:id=\"(\\d+)\""); + + /** Собственные штампы — защита от повторного штампа (идемпотентность). */ + private static final String STAMP_MARK = "pj-distribute-"; + + /** Закрывающий слэш открывающего тега: {@code } — абзац без содержимого. */ + private static final char SELF_CLOSE_SLASH = '/'; + + private DistributeStampNormalizer() { + } + + /** Шаг конвейера WordPdfConverter#normalizers: этот нормализатор как DocxNormalizer. */ + static final DocxNormalizer STEP = DistributeStampNormalizer::normalize; + + /** + * Штампует distribute-абзацы content-части. + * + * @param part имя zip-записи ({@code word/document.xml} и т. п.) + * @param xml разметка части + * @return размеченная разметка либо {@code null}, если менять нечего + * (не content-часть / нет distribute-абзацев) + */ + static String rewrite(String part, String xml) { + String tag = contentTag(part); + if (tag == null) { + return null; + } + Matcher starts = PARA_START.matcher(xml); + StringBuilder sb = null; + int mark = 0; + int nextId = maxBookmarkId(xml) + 1; + int seq = 0; + while (starts.find()) { + int body = starts.end(); + int gt = xml.indexOf('>', body); + if (gt < 0) { + break; + } + if (xml.charAt(gt - 1) == SELF_CLOSE_SLASH) { + continue; // самозакрывающийся — pPr нет в помине + } + int end = xml.indexOf("", gt); + if (end < 0) { + break; + } + int pprOpen = xml.indexOf("= end) { + continue; + } + int pprClose = xml.indexOf("", pprOpen); + if (pprClose < 0 || pprClose >= end) { + continue; + } + CharSequence ppr = xml.subSequence(pprOpen, pprClose); + if (!JC_DISTRIBUTE.matcher(ppr).find()) { + continue; + } + int stamped = xml.indexOf(STAMP_MARK, gt); + if (stamped >= 0 && stamped < end) { + continue; // уже проштампован + } + seq++; + if (sb == null) { + sb = new StringBuilder(xml.length() + 64); + } + sb.append(xml, mark, pprClose + "".length()); + sb.append("") + .append(""); + mark = pprClose + "".length(); + } + return sb == null ? null : sb.append(xml, mark, xml.length()).toString(); + } + + /** + * Метка части для имён закладок; {@code null} — часть не content + * (в numbering/styles закладок быть не может, прочие не рендерятся). + */ + private static String contentTag(String part) { + switch (part) { + case "word/document.xml": + return "document"; + case "word/footnotes.xml": + return "footnotes"; + case "word/endnotes.xml": + return "endnotes"; + default: + return null; + } + } + + private static int maxBookmarkId(String xml) { + int max = 0; + Matcher m = BOOKMARK_ID.matcher(xml); + while (m.find()) { + try { + max = Math.max(max, Integer.parseInt(m.group(1))); + } catch (NumberFormatException ignored) { + // нечисловой id — не конкурент нашим id + } + } + return max; + } + + /** + * Самостоятельный zip-проход (тот же контракт, что у остальных; в + * конвейере вызывается {@link #rewrite} через {@link DocxRewritePipeline}). + * + * @param docx байты .docx (zip) + * @return те же или переупакованные байты + */ + static byte[] normalize(byte[] docx) throws IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(docx.length); + boolean changed = false; + try (ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(docx)); + ZipOutputStream zos = new ZipOutputStream(out)) { + ZipEntry entry; + while ((entry = zis.getNextEntry()) != null) { + byte[] data = zis.readAllBytes(); + String name = entry.getName(); + String fixed = name.startsWith("word/") && name.endsWith(".xml") + ? rewrite(name, new String(data, StandardCharsets.UTF_8)) + : null; + zos.putNextEntry(new ZipEntry(name)); + zos.write(fixed != null ? fixed.getBytes(StandardCharsets.UTF_8) : data); + zos.closeEntry(); + changed |= fixed != null; + } + } + return changed ? out.toByteArray() : docx; + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DocxRewritePipeline.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DocxRewritePipeline.java index 032a098..8333fc2 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DocxRewritePipeline.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DocxRewritePipeline.java @@ -15,13 +15,16 @@ import org.apache.commons.compress.utils.SeekableInMemoryByteChannel; /** * Единый zip-проход переписывания XML-частей (.docx) вместо отдельных * проходов нормализаторов: к каждой записи {@code word/*.xml} применяются - * все восемь рерайтов в фиксированном порядке - * Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby. + * все девять рерайтов в фиксированном порядке + * Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby→Distribute. * Порядок значим: Strict первым — дальше части в transitional-виде * (TableIndent читает transitional-атрибуты {@code w:}); GlyphCoverage * режет раны по финальному тексту рана (после Invisible); Hidden - * последним — вырезает уже финальные раны (после GLYPH-разбиений), - * а его OnOff-форма vanish читается после правила 2. Каждый + * идёт после GlyphCoverage — вырезает уже финальные раны (после GLYPH-разбиений), + * а его OnOff-форма vanish читается после правила 2; Distribute (штамп + * {@code w:jc="distribute"} закладкой-якорем) — последним, он вставляет узел + * после {@code } и не трогает текст, но обязан видеть финальную + * разметку, чтобы не штамповать абзац, вырезанный Hidden. Каждый * рерайт работает только содержимым одной части, поэтому по-частная * цепочка эквивалентна последовательным полным проходам. Исключения из * «по-частности» — контексты, читаемые один раз до цикла: правило 5 @@ -59,7 +62,7 @@ public final class DocxRewritePipeline { public static final DocxNormalizer STEP = DocxRewritePipeline::normalize; /** - * Применяет восемь рерайтов к каждой записи {@code word/*.xml} за один + * Применяет девять рерайтов к каждой записи {@code word/*.xml} за один * проход zip. * * @param docx байты .docx (валидный zip) @@ -132,6 +135,10 @@ public final class DocxRewritePipeline { if (next != null) { cur = next; } + next = DistributeStampNormalizer.rewrite(name, cur); + if (next != null) { + cur = next; + } if (cur != xml) { changed = true; rewritten = cur.getBytes(StandardCharsets.UTF_8); diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/LayoutPostRenderer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/LayoutPostRenderer.java index 583a021..2ba7d1e 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/LayoutPostRenderer.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/LayoutPostRenderer.java @@ -27,6 +27,13 @@ import java.util.regex.Pattern; * обратно к {@code start-indent}. Вложенные таблицы: первой считается ячейка * внешней — принятая аппроксимация (компенсация всё равно от default * cellMar). Регрессия — WordPdfConverterTest#tableCellPadding_textInsetLikeWord. + *
  • distribute → justify-пара. docx4j для {@code w:jc="distribute"} + * не эмитит в FO ничего; по якорю-закладке {@code pj-distribute-…} + * (DistributeStampNormalizer, правило 12) блоку дописывается + * {@code text-align="justify" text-align-last="justify"} — Word растягивает + * пробелы всех строк, включая последнюю (Part 1 §17.18.44). Регрессия — + * LayoutPostRendererTest (фильтр), + * WordPdfConverterTest#distribute_allLinesReachRightMargin (конвейер).
  • * * *

    {@code lineRule="auto"} НЕ правится: высота «single» 13.4277pt@11pt, @@ -56,6 +63,14 @@ public final class LayoutPostRenderer implements FORenderer { private static final double IN_TO_PT = 72.0; private static final Pattern TABLE = Pattern.compile("]*>"); + /** + * Якорь distribute-абзаца: fo:inline с id закладки-штампа. docx4j пишет + * его DOM-поддеревом ({@code XsltCommonFunctions.toNode}), на сериализации + * префикс может не унаследоваться — форма {@code }, + * поэтому префикс факультативен. + */ + private static final Pattern DISTRIBUTE_STAMP = + Pattern.compile("<(?:fo:)?inline\\b[^>]*\\bid=\"pj-distribute-[^\"]*\"[^>]*/>"); private static final Pattern START_INDENT = Pattern.compile("start-indent=\"(-?[0-9.]+)pt\""); private static final Pattern FIRST_CELL = Pattern.compile("]*>"); private static final Pattern PADDING_LEFT = @@ -84,7 +99,59 @@ public final class LayoutPostRenderer implements FORenderer { * возвращает ту же строку. */ static String fix(String fo) { - return compensateTablePadding(fo); + return compensateTablePadding(justifyDistributed(fo)); + } + + /** + * Абзац со штампом {@code w:jc="distribute"} (якорь-закладка + * {@code pj-distribute-…} от {@link DistributeStampNormalizer}) получает + * пару {@code text-align="justify" text-align-last="justify"} — + * канонический FO-эквивалент Word-раскладки (Part 1 §17.18.44; пин + * поведения — форк DistributeLineTestCase). Атрибут дописывается в тег + * ближайшего открывающего {@code fo:block} перед якорем; уже заданное + * {@code text-align} не перетирается. + */ + private static String justifyDistributed(String fo) { + Matcher stamp = DISTRIBUTE_STAMP.matcher(fo); + StringBuilder sb = null; + int mark = 0; + int search = 0; + while (stamp.find(search)) { + search = stamp.end(); + int block = fo.lastIndexOf("", block); + if (block < mark || block < 0 || (blockClose >= 0 && blockClose < stamp.start())) { + continue; // якорь вне блока/после закрытия — править нечего + } + int blockEnd = fo.indexOf('>', block + "") ? blockTag.length() - 2 : blockTag.length() - 1; + return blockTag.substring(0, close) + attrs + blockTag.substring(close); } /** diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java index 0410380..9148ab7 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java @@ -22,6 +22,7 @@ import org.apache.poi.xwpf.usermodel.XWPFAbstractNum; import org.apache.poi.xwpf.usermodel.XWPFNumbering; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPr; +import org.openxmlformats.schemas.wordprocessingml.x2006.main.STJc; import javax.imageio.ImageIO; import java.awt.Color; @@ -76,6 +77,7 @@ public final class SampleDocxGenerator { exoticGlyphs(dir.resolve("exotic-glyphs.docx")); tooManyPages(dir.resolve("too-many-pages.docx")); staleCache(dir.resolve("stale-cache.docx")); + distribute(dir.resolve("distribute.docx")); System.out.println("Готово: " + dir.toAbsolutePath()); } @@ -439,6 +441,35 @@ public final class SampleDocxGenerator { /** Сколько {@code w:t} в фикстуре stale-cache остаются без маркера. */ private static final int STALE_CACHE_UNMARKED_RUNS = 1; + /** + * w:jc="distribute" (+ контроль {@code both} и левый): Word растягивает + * пробелы всех строк, включая последнюю (Part 1 §17.18.44); docx4j для + * DISTRIBUTE не эмитит ничего, без правила 12 абзац печатается влево. + * Регрессия — WordPdfConverterTest#distribute_allLinesReachRightMargin. + */ + private static void distribute(Path out) throws Exception { + try (XWPFDocument doc = new XWPFDocument()) { + heading(doc, "Distribute justification", "Calibri"); + String text = "alpha bravo charlie delta echo foxtrot golf hotel " + + "india juliett kilo lima mike november oscar papa quebec romeo sierra"; + XWPFParagraph p = doc.createParagraph(); + setJc(p, STJc.DISTRIBUTE); + run(p, text, "Calibri", false, false); + p = doc.createParagraph(); + run(p, text, "Calibri", false, false); + p = doc.createParagraph(); + setJc(p, STJc.BOTH); + run(p, text, "Calibri", false, false); + save(doc, out); + } + } + + /** w:jc прямо в pPr: POI-перечисление Alignment не знает DISTRIBUTE. */ + private static void setJc(XWPFParagraph p, STJc.Enum val) { + CTPPr pPr = p.getCTP().isSetPPr() ? p.getCTP().getPPr() : p.getCTP().addNewPPr(); + pPr.addNewJc().setVal(val); + } + // ================== Вспомогательные ================== /** Абзац-заголовок: POI 5.5 не имеет createHeading, поэтому diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java index 467bc9f..59f4851 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java @@ -2932,4 +2932,61 @@ class WordPdfConverterTest { } } + /** + * w:jc="distribute" (Part 1 §17.18.44): Word растягивает пробелы всех строк, + * включая последнюю. docx4j для DISTRIBUTE не эмитит в FO ничего — без + * правила 12 (DistributeStampNormalizer) и justify-пары (LayoutPostRenderer) + * абзац печатается по левому краю. Фикстура — samples/distribute.docx: + * один и тот же текст абзацами distribute / left / both; правое поле + * A4 72pt → 523.28pt; хвостовая строка трёхсловная («quebec romeo sierra») — + * одно слово растягивать нечем (нет склейки), такие строки Word тоже оставляет + * на месте. last-line justify пинут в форке (DistributeLineTestCase). + */ + @Test + void distribute_allLinesReachRightMargin() throws Exception { + Path pdf = convertPdf(sampleBytes("distribute.docx"), "distribute"); + Map ends = new LinkedHashMap<>(); + Map lineTexts = new LinkedHashMap<>(); + try (PDDocument doc = Loader.loadPDF(pdf.toFile())) { + PDFTextStripper stripper = new PDFTextStripper() { + @Override + protected void processTextPosition(org.apache.pdfbox.text.TextPosition tp) { + String u = tp.getUnicode(); + if (!u.trim().isEmpty()) { + long y = Math.round(tp.getYDirAdj()); + double right = tp.getXDirAdj() + tp.getWidthDirAdj(); + double[] max = ends.computeIfAbsent(y, k -> new double[1]); + max[0] = Math.max(max[0], right); + lineTexts.computeIfAbsent(y, k -> new StringBuilder()).append(u); + } + super.processTextPosition(tp); + } + }; + String text = stripper.getText(doc); + assertEquals(3, count(text, "quebec"), "все три абзаца напечатаны"); + } + List tails = new ArrayList<>(); + for (Map.Entry e : lineTexts.entrySet()) { + if (e.getValue().toString().trim().endsWith("sierra")) { + tails.add(Math.round(ends.get(e.getKey())[0] * 10) / 10.0); + } + } + assertEquals(3, tails.size(), "найдены концы трёх абзацев"); + double right = 595.276 - 72.0; + assertTrue(Math.abs(tails.get(0) - right) < 1.5, + "distribute: последняя строка дотянута до правого поля, конец=" + tails.get(0)); + assertTrue(tails.get(1) < right - 20.0, + "левый абзац остаётся рваным: конец=" + tails.get(1)); + assertTrue(tails.get(2) < right - 20.0, + "both не растягивает последнюю строку: конец=" + tails.get(2)); + } + + private static int count(String hay, String needle) { + int n = 0; + for (int i = hay.indexOf(needle); i >= 0; i = hay.indexOf(needle, i + 1)) { + n++; + } + return n; + } + } diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizerTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizerTest.java new file mode 100644 index 0000000..fd36b9d --- /dev/null +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizerTest.java @@ -0,0 +1,165 @@ +package ru.pjandro.wordpdf.internal; + +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.zip.ZipEntry; +import java.util.zip.ZipOutputStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Юниты {@link DistributeStampNormalizer}: штамп {@code w:jc="distribute"} + * закладкой-якорем после {@code } (Part 1 §17.18.44, правило 12). + */ +class DistributeStampNormalizerTest { + + private static String document(String body) { + return "" + + "" + body + ""; + } + + /** Абзац с pPr (или без, если pPrInner пуст) и одним раном. */ + private static String para(String pPrInner, String text) { + return "" + (pPrInner.isEmpty() + ? "" : "" + pPrInner + "") + + "" + text + ""; + } + + private static final String JC_DISTRIBUTE = ""; + + /** distribute-абзац: штамп сразу после , id=1 (закладок нет). */ + @Test + void distribute_paragraphStampedAfterPPr() { + String xml = document(para(JC_DISTRIBUTE, "раз")); + String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml); + assertEquals(document(para(JC_DISTRIBUTE, "раз") + .replace("", "" + + "")), + fixed); + } + + /** Несколько абзацев: имена per-part по счёту, id за max существующих. */ + @Test + void multipleParagraphs_namesAndIdsUnique() { + String xml = document( + para(JC_DISTRIBUTE, "раз") + + "" + + "" + + "два" + + para(JC_DISTRIBUTE, "три")); + String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml); + assertTrue(fixed.contains("w:name=\"pj-distribute-document-1\""), fixed); + assertTrue(fixed.contains("w:name=\"pj-distribute-document-2\""), fixed); + assertFalse(fixed.contains("w:name=\"pj-distribute-document-3\""), fixed); + assertTrue(fixed.contains("") + countOf(fixed, ""), + "каждому start — свой end"); + } + + private static int countOf(String s, String sub) { + return (s.length() - s.replace(sub, "").length()) / sub.length(); + } + + /** Повторный вызов на проштампованном — null (идемпотентность). */ + @Test + void alreadyStamped_returnsNull() { + String xml = document(para(JC_DISTRIBUTE, "раз")); + String once = DistributeStampNormalizer.rewrite("word/document.xml", xml); + assertNull(DistributeStampNormalizer.rewrite("word/document.xml", once)); + } + + /** jc=center/both/нет — не our case: null. */ + @Test + void otherJustification_returnsNull() { + String xml = document(para("", "раз") + para("", "два")); + assertNull(DistributeStampNormalizer.rewrite("word/document.xml", xml)); + } + + /** jc вне w:pPr (например, w:jc строки таблицы в trPr) — не штампуется. */ + @Test + void jcOutsidePPr_returnsNull() { + String xml = document("" + + para("", "раз") + ""); + assertNull(DistributeStampNormalizer.rewrite("word/document.xml", xml)); + } + + /** numbering.xml (уровни списков с pPrGeneral) — часть не штампуется вовсе. */ + @Test + void nonContentPart_returnsNull() { + String xml = "" + JC_DISTRIBUTE + ""; + assertNull(DistributeStampNormalizer.rewrite("word/numbering.xml", xml)); + } + + /** footnotes.xml — штампуется с меткой части (имена не коллизируют с document). */ + @Test + void footnotes_partTagInName() { + String xml = document(para(JC_DISTRIBUTE, "сноска")); + String fixed = DistributeStampNormalizer.rewrite("word/footnotes.xml", xml); + assertTrue(fixed.contains("w:name=\"pj-distribute-footnotes-1\""), fixed); + } + + /** Самозакрывающийся абзац — не ломает разбор. */ + @Test + void selfClosingParagraph_survives() { + String xml = document("" + JC_DISTRIBUTE + + "тут"); + String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml); + assertTrue(fixed.contains("pj-distribute-document-1"), fixed); + } + + /** Контракт zip-пути: нечего менять → тот же массив; есть штамп → новые байты со штампом. */ + @Test + void normalize_identityWhenNothing_stampWhenDistribute() throws IOException { + byte[] clean = docx("чисто"); + assertSame(clean, DistributeStampNormalizer.normalize(clean)); + + byte[] dirty = docx("" + JC_DISTRIBUTE + "" + + "тяни"); + byte[] fixed = DistributeStampNormalizer.normalize(dirty); + assertNotSame(dirty, fixed); + String part = new String(entry(fixed, "word/document.xml"), StandardCharsets.UTF_8); + assertTrue(part.contains("w:name=\"pj-distribute-document-1\""), part); + } + + // ================== Синтетический .docx ================== + + private static byte[] docx(String body) throws IOException { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + try (ZipOutputStream zos = new ZipOutputStream(bos)) { + zos.putNextEntry(new ZipEntry("[Content_Types].xml")); + zos.write("".getBytes(StandardCharsets.UTF_8)); + zos.closeEntry(); + zos.putNextEntry(new ZipEntry("word/document.xml")); + zos.write(document(body).getBytes(StandardCharsets.UTF_8)); + zos.closeEntry(); + zos.putNextEntry(new ZipEntry("word/numbering.xml")); + zos.write("".getBytes(StandardCharsets.UTF_8)); + zos.closeEntry(); + } + return bos.toByteArray(); + } + + private static byte[] entry(byte[] zip, String name) throws IOException { + try (java.util.zip.ZipInputStream zis = + new java.util.zip.ZipInputStream(new java.io.ByteArrayInputStream(zip))) { + ZipEntry e; + while ((e = zis.getNextEntry()) != null) { + if (e.getName().equals(name)) { + return zis.readAllBytes(); + } + } + } + throw new IllegalArgumentException("нет записи " + name); + } +} diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/LayoutPostRendererTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/LayoutPostRendererTest.java index d898b0f..c865dca 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/LayoutPostRendererTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/LayoutPostRendererTest.java @@ -3,6 +3,7 @@ package ru.pjandro.wordpdf.internal; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -125,4 +126,57 @@ class LayoutPostRendererTest { String fo = "text"; assertSame(fo, LayoutPostRenderer.fix(fo)); } + + // ================== distribute-штамп ================== + + /** Якорь-закладка: блок получает пару justify-свойств (Part 1 §17.18.44). */ + @Test + void distributeStamp_justifyPairAdded() { + String fo = "" + + "alpha bravo"; + String fixed = LayoutPostRenderer.fix(fo); + assertTrue(fixed.contains(""), fixed); + } + + /** Реальная форма сериализации docx4j: DOM-поддерево без префикса fo. */ + @Test + void distributeStamp_unprefixedInline_stillStamped() { + String fo = "" + + "" + + "alpha"; + String fixed = LayoutPostRenderer.fix(fo); + assertTrue(fixed.contains(""), fixed); + } + + /** Текст уже выровнен (both + наш штамп) — дописывается только align-last. */ + @Test + void distributeStamp_existingTextAlignPreserved() { + String fo = "x"; + String fixed = LayoutPostRenderer.fix(fo); + assertTrue(fixed.contains("text-align=\"justify\" text-align-last=\"justify\""), fixed); + assertFalse(fixed.contains("text-align-last=\"justify\" text-align-last"), fixed); + } + + /** text-align-last уже задан — блок не трогается, чужая закладка молча живёт. */ + @Test + void distributeStamp_alignLastAlreadySet_untouched() { + String fo = "x"; + assertSame(fo, LayoutPostRenderer.fix(fo)); + } + + /** Закладка вне fo:block (после закрытия) — правки нет, FO не ломается. */ + @Test + void distributeStamp_outsideBlock_untouched() { + String fo = "до"; + assertSame(fo, LayoutPostRenderer.fix(fo)); + } + + /** Обычная закладка пользователя (не pj-distribute) — игнор. */ + @Test + void userBookmark_ignored() { + String fo = "x"; + assertSame(fo, LayoutPostRenderer.fix(fo)); + } } diff --git a/wordpdf-core/src/test/resources/samples/distribute.docx b/wordpdf-core/src/test/resources/samples/distribute.docx new file mode 100644 index 0000000000000000000000000000000000000000..626fe7a6d499c4e1d5a1df1a7fdbfde7c7e96b9c GIT binary patch literal 2447 zcma)7dpy&7A0IOtQDjKg(p<+}ik3R5+?gr2nhG0Pt6>-==b$VcinZY!B2E{Sho$zM z=Hx!Nh!zSJayf)@tBF?V`RzQHmgk&a=kt4gf3M#k-_Q5=`Mf{x@B8iM0+xY;U@#b{ z;{FL=kVL2e-$!jjX^~`FB+)B6j2z)>awa7Bo<}9E!AxOE)i%h#ZQ2c^* zmPz3y9$A-+&smB+sV^A9pc%C5GiRc7yg3WBmeZ^bS>nY{*WnsxHl@DzHLk(ViZWVQ znLDU3BsClaFDZI~K#`iOkwKj*O%$~I;t*VI3xiUi*oq$6c50j9GG`ZS9a&^>YECAf zzHz&qXSGcU4@@?F@Y%gW&9IqIwMV$jR2@!!rO!w4&BE`LE6-+Yam%er5D)y}iBWCH-41db~dk^R=hA+EN#!kno`Z(Ui*A|c6*0i#UAyZzM($3|TACB$w zV(Sm*G+z09G>M5ryLpek*mwQdfJpU5u7>two3ox3D;R8gz`mvfuM=5TpCGyG#L$>l zJ;@mX8plh23mPS0M_}kNH+pDTgsFd6n3#30Oul@*nUdXXoPA66z-w!}u1p3jf698V zRzV-OBiM$E+dFvW>F@1kmu^-(DjP{dSMKBV_ol&}u&K;fhxTmleXa9dwWqDTvdVYu z*AWKgbblu0T(J7QUN5wvE{(}>q#q1wsS0$P8RnQ!s^5|nkm_z)g7(Q zD{3Okg{Zr$$uvQXE`)B;=nKeA(0MUXyMq%1d2ifm6_MRfk3vA-#S0c42$_W%y0;45 zt7%3bpG{>L>+XSZ8c7z1<`eQ~UV9udNozQ7uI4+@nK99s?{c)$M5axuYAOuACoO?F zToQf*_V)FWJ2o{bYFi$26;n4PthcVi;HRhsl*06qu9`}JWdk|Oq2yg>Na*vMu~#*h zYr!tubjQK6rxvc0UKpSLWWI1|p5aCE|TUp?` z+y&ORL5vEe2bu!JI28gYk{HA>FaCb*tqRpb)k8Bb@=hlXZncLsUIu@X%1^y{%xR?b zcOHg#;6>LA4x@hCCwOd3)cTlCKee2WDs?t;ndyH%*)BDv1s*4l$63An{9*F8x;`OS zq~-sUf#$CapYdFQ>v8f-tfGo;=}ixV@=AA$Yxi!LEIULR7{*gWzDIu)KA-B+ADvQj z~*^F z=?2$$=C>Sr?KZ~EgWHiiuWlC}O`k5V^k(M$6g%l@Id6v0ec3dq@wwcL`H3k4zay{P z(3a3)bQ@Biu<IoQJFW%h`-$X)(Cpf2~!jKzshnp?VQ<&0h6`K(X0~3U^LOUtm za=W9o5!*2N*)5Q=tA;qG3D-MyhszgGF*QYqIYg2feFA>l9DA^Nj_{NGni4aA!a2 z_tjp>*pS56*bNnWcL*<$MB&!hd;Lq@RZ`-v_pyv8N`an`e~*0;etd5U`duOYSB@1 zahzU#jF3z{RNQ0IJs;nVg*tMcqo|e!(VKKs78ls*G1K0sgFSdYIxH&jNy=h)4Cx(P zYJ9J_+-tU%kzqi&KLE?kMM@eD`r_S^z9aVTuj5ageDwj6>MXXWFX0EEBVksn6D4&} zEZ$!t8W8%`QocG{QUJtS`6ZkH2mN36f0c7}x+HJEPEP}v{C}FUI$e?gVsd{8RoQP- kef3F_v-!G^HPHW@BuO7P7YOhJ5C{r9wE(^qz$OsrUl|ppw*UYD literal 0 HcmV?d00001 -- 2.56.1 From 4a6cf85f20eceb3b6c73fbb374d4f8df7d19229f Mon Sep 17 00:00:00 2001 From: Pjandro Date: Sun, 8 Nov 2026 23:50:25 +0000 Subject: [PATCH 7/9] =?UTF-8?q?refactor(core):=20=D1=80=D0=B5=D1=84=D1=8C?= =?UTF-8?q?=D1=8E=20PR-2=20-=20=D0=B6=D1=91=D1=81=D1=82=D0=BA=D0=B8=D0=B9?= =?UTF-8?q?=20=D1=80=D0=B0=D0=B7=D0=B1=D0=BE=D1=80=20=D0=B0=D0=B1=D0=B7?= =?UTF-8?q?=D0=B0=D1=86=D0=B0,=20header/footer-=D1=88=D1=82=D0=B0=D0=BC?= =?UTF-8?q?=D0=BF,=20=D1=81=D0=B2=D0=B5=D0=B4=D0=B5=D0=BD=D0=B8=D0=B5=20?= =?UTF-8?q?=D0=BD=D1=83=D0=BC=D0=B5=D1=80=D0=B0=D1=86=D0=B8=D0=B8=20=D0=BF?= =?UTF-8?q?=D1=80=D0=B0=D0=B2=D0=B8=D0=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - DistributeStampNormalizer: pPr ищется как первый ребёнок w:p (S17.3.1.23, O(1) вместо неограниченного indexOf по хвосту части); окно jc режется началом w:pPrChange - старое значение реvision больше не штампуется и не маскируется; вставка - после НАРУЖНОГО (lastIndexOf от конца абзаца), идемпотентность позиционная (чужая закладка Word сразу после pPr больше не считается штампом); - штампуется word/headerN.xml / word/footerN.xml (якорь работает и в колонтитулах; .rels отсекаются); - юниты: реvision-only jc, вложенный pPr в реvision, чужая закладка, header/footer, pretty-print; LayoutPostRendererTest: якорь внутри fo:static-content; - проба опровергла двойной разделитель suff=space (TP-поток «1.·ITEM») - зафиксировано в javadoc правила 6; - нумерация правил сведена к docs (Distribute=9, OLE=10): код/тесты 12->9, README 8/9->9/10, doc-bridge 9->7, xslt-комментарий внутри AUDIT-FIX-2 10->8 (гейт побайтной копии не затронут); - GITEA-vars.md: MAVEN_MIRROR_URL = group maven-public (иначе CI не резолвит ru.pjandro-оверлей через mirrorOf=*); render-limitations: замер framePr - 180pt от КРАЯ страницы при hAnchor=page; счётчики 58/906. mvn clean verify зелёные (core 858 + app 48; артефакт форка докачан через maven-public при пустом кэше). --- GITEA-vars.md | 2 +- README.md | 4 +- docs/agent/doc-bridge.md | 2 +- docs/agent/pipeline.md | 2 +- docs/agent/render-limitations.md | 2 +- .../internal/DistributeStampNormalizer.java | 93 ++++++++++++++----- .../wordpdf/internal/LayoutPostRenderer.java | 2 +- .../internal/NumberingSuffixNormalizer.java | 5 + .../src/main/resources/xslt/docx2fo.xslt | 2 +- .../pjandro/wordpdf/SampleDocxGenerator.java | 2 +- .../pjandro/wordpdf/WordPdfConverterTest.java | 2 +- .../DistributeStampNormalizerTest.java | 54 ++++++++++- .../internal/LayoutPostRendererTest.java | 12 +++ 13 files changed, 148 insertions(+), 36 deletions(-) diff --git a/GITEA-vars.md b/GITEA-vars.md index cf3d5ca..cec6b4b 100644 --- a/GITEA-vars.md +++ b/GITEA-vars.md @@ -31,7 +31,7 @@ job'ах `images-app`/`images-web` (проверка `REGISTRY`/`REGISTRY_USER`/ |`WORDPDF_MAX_MB`|Лимит размера входного .docx, МБ (сейчас `5`)| |`REGISTRY`|Адрес docker-реестра `host:port` без схемы (Nexus docker-registry на прод-сервере, коннектор `:5000`)| |`PIP_INDEX_URL`|Полный URL pypi-proxy индекса Nexus без кредов, вида `http://:/repository/pypi-proxy/simple` (репозиторий заводится по разделу «Nexus: анонимный доступ CI» ниже; HTTP-порт Nexus — не docker-коннектор `:5000`)| -|`MAVEN_MIRROR_URL`|Полный URL зеркала Nexus maven-central со слэшем на конце: `http://:/repository/maven-central/` (репозиторий `maven-central` — штатный proxy на Central из коробки Nexus 3, создавать не надо; заводка доступа — раздел «Nexus: анонимный доступ CI» ниже)| +|`MAVEN_MIRROR_URL`|Полный URL зеркала Nexus **maven-public** (group) со слэшем на конце: `http://:/repository/maven-public/`. Group содержит `maven-central` (proxy на Central) **и** `maven-hosted` (наш `ru.pjandro:docx4j-fo-renderer-core`, PR-2) — mirror в `.ci/maven-settings.xml` имеет `mirrorOf=*`, поэтому при значении `…/maven-central/` форк-артефакт CI не резолвится (404, fail-closed). Group и доступ — раздел «Nexus: анонимный доступ CI» ниже| При смене лимитов прода — править `WORDPDF_MAX_PAGES`/`WORDPDF_MAX_MB` в Variables, PR не нужен: job `deploy` прокидывает их в прод-stack (app пересоздаётся с новыми лимитами), job `autotests` сверяет проверки с ними же. Без обеих Variables job'ы `deploy`/`autotests` падают на проверке — fail-closed. diff --git a/README.md b/README.md index adf3893..a09e1ce 100644 --- a/README.md +++ b/README.md @@ -41,7 +41,7 @@ java-word-pdf/ |`ru.pjandro.wordpdf.ConversionException`|ошибки конвертации; подтипы `ValidationException` (некорректный вход) и `DrawingFoundException` (`enum Kind {CHARTS, SMARTART, OLE}`)| |`ru.pjandro.wordpdf.fonts.BundledFonts`|выгрузка TTF из jar и регистрация в docx4j| |`ru.pjandro.wordpdf.fonts.BundledFontMapper`|маппинг имён шрифтов документа → TTF| -|`ru.pjandro.wordpdf.internal.DocxRewritePipeline`|правила 1–8 нормализации XML-частей одним zip-проходом (+ `OleObjectNormalizer`, правило 9)| +|`ru.pjandro.wordpdf.internal.DocxRewritePipeline`|правила 1–9 нормализации XML-частей одним zip-проходом (+ `OleObjectNormalizer`, правило 10)| |`ru.pjandro.wordpdf.internal.doc.DocToDocx`|мост бинарного `.doc` → in-memory `.docx` (`convert`/`countPages`)| |`ru.pjandro.wordpdf.internal.FopFallbackFonts`|декларация fallback-семейства в FOP-конфиге| |`ru.pjandro.wordpdf.internal.chart.DrawingPreRenderer`|диаграммы/SmartArt → PNG до XSL-FO| @@ -303,7 +303,7 @@ Dev-режим без контейнеров: бэкенд `java -jar wordpdf-ap скрытые раны (`w:vanish`), руби (надстрочница вырезается). Маркеры Symbol/Wingdings и поля `PAGE`/`NUMPAGES` не переписываем — с docx4j 17.3.x экспорт делает это сам (маркеры → Unicode, complex-поля → пересчёт вместо - кэша). Затем вычищаются OLE-объекты (правило 9, + кэша). Затем вычищаются OLE-объекты (правило 10, `OleObjectNormalizer`, картинка-плейсхолдер сохраняется). 3. Документ загружается в `WordprocessingMLPackage`, привязывается `BundledFontMapper`. diff --git a/docs/agent/doc-bridge.md b/docs/agent/doc-bridge.md index 7e33868..7828beb 100644 --- a/docs/agent/doc-bridge.md +++ b/docs/agent/doc-bridge.md @@ -23,4 +23,4 @@ ## Остаток моста -Остаток моста (осознанный, вне контура): семантика рестартов списков не переносится (`fNoRestart`/`ilvlRestartLim` → `w:lvlRestart` — docx4j-Emulator применяет свой дефолт «рестарт на старшем уровне»), как и `fLegal`/`isLgl`, `dxaIndentSav` и `LfoData.cp`; `sprmPIlvl=0x0C` — абзац без numPr (не «в списке без номера»); AUTONUM-поля трактуются как обычные списки; отрицательный `sprmPIlfo` («сохранить отступы») — обычный numPr, отступы делает прямой `w:ind` абзаца; объединённые ячейки: вертикальное слияние (`vertMerge`) не переносится, горизонтальное — переносится собственной сеткой строки (TTP-абзац каждой строки несёт свой `sprmTDefTable`, §2.9.321 → `w:gridSpan`+суммарный `w:tcW`; регрессия — WordPdfConverterTest#docMergedTableRow_fullWidthNotSplit, юниты — DocToDocxFormattingTest#mergedRow_gridSpanAndWidth, #misalignedRow_fallsBackToColumnWidths), вложенные таблицы (sprmPFInnerTtp — разделитель ячейки/строки там ¶ 0x0D, не 0x07) и бордюры уровня ячейки (TC80/sprmTCellBorders) не переносятся — только сетка и строковые границы; строки, у которых сетка задана только `sprmTInsert` (в PrcData нет `sprmTDefTable`, а PAPX-зеркало отсутствует), деградируют в плоские абзацы (`sprmTInsert` конвертер не читает); `DocFile.countPages` (`PapxIndex.countPageBreakBefore`) цепочку PrcData не следует — свойства вне FKP в подсчёт страниц не попадают, 0x0C-разрывы считаются; сноски/концевые сноски/комментарии не рендерятся (метки ссылок пропускаются); плавающие объекты (якорь 0x08) — только inline-картинкой: позиция/плавание/обтекание (PlcfSpa) не переносятся; непринятые правки рендерятся как разметка (`w:ins`/`w:del`, вид «Show Markup»), эмуляция принятия правок не делается; скрытый текст вырезается мостом сам (`.docx`-путь чистит и его — правило 9, но мост не ждёт байтового прохода), ВСЕ ПРОПИСНЫЕ/малые капители — апкейс текста (FOP без font-variant); подсветка и затенения перенесены аудитом 2026-11: `sprmCHighlight` 0x2A0C → `w:highlight` (Ico→ST_HighlightColor по RGB), `sprmCShd` 0xCA71/`sprmCShd80` 0x4866/`sprmPShd` 0xC64D/`sprmPShd80` 0x442D → `w:shd` (форма `w:val="clear"` + цвет в `w:fill` — FOP закрашивает только w:fill, проверено экспериментально: `w:val="solid" w:color=RRGGBB w:fill="auto"` не рисует ничего; ipatSolid → fill=cvFore, иначе fill=cvBack — паттерны Ipat≥2 деградируют, [MS-DOC] Ipat: «lost if converted to ECMA-376»); затенение таблицы/ячеек (`sprmTSetShd` 0xD62D/`sprmTSetShd80` 0xD60F) мостом не переносится; тип подчёркивания не переносится: KUL любой → `w:u val="single"` (double/dotted деградируют, `sprmCCvUl` не читается); границы абзацев (хранятся sprm PAPX 0xC64E–0xC652, а не PlfBdx §2.9.8) не переносятся — и конвейер `w:pBdr` не рисует (в docx4j-export-fo 17.3.2 нет getPBdr, байткод 2026-11); не переносятся и не были бы нарисованы (в docx4j-export-fo 17.3.2 нет соответствующих getters — проверено байткодовым зондом): `w:tcBorders` (границы ячеек — TC80/sprmTCellBorders), `w:trHeight` (sprmTRheight), `w:tblHeader` (sprmTfHdrTbl), `w:cantSplit` (sprmTfCantSplit), `w:widowControl` (sprmPFWidowControl); отступы в символьных единицах `sprmPDxcLeft`/`sprmPDxcRight`/`sprmPDxcLeft1` 0x4456/0x4455/0x4457 не переносятся — операнд есть 1/100 ширины символа (§2.6.1), перевод в twips требует ширины глифа «0» разрешённого шрифта, коей у моста нет (guard `fCharLineUnits` §2.6.2: в обычных документах этих Prl нет вовсе); чётные варианты колонтитуков не переносятся (переносится только odd → `type="default"`, FOP не различает чётность полос набора); first-page переносится аудитом 2026-11 — sprmSFTitlePage + `type="first"` (см. строку `Headers`); разрыв секции в абзаце со sprmPFInTable деградирует в разрыв страницы (`w:sectPr` в `w:pPr` внутри `w:tc` невалиден); error-флаги `errorOnCharts`/`errorOnSmartArt`/`errorOnOle` на `.doc` **не срабатывают** — диаграммы/SmartArt/OLE в бинарном формате существуют только как BLIP-плейсхолдеры, мост выдаёт их картинками (задокументировано в `@Operation`); `stale-cache.doc` конвертируется (кэш PageCount=5, концепта lastRenderedPageBreak в .doc нет) — семантика отличается от docx-фикстуры, запинено тестом. +Остаток моста (осознанный, вне контура): семантика рестартов списков не переносится (`fNoRestart`/`ilvlRestartLim` → `w:lvlRestart` — docx4j-Emulator применяет свой дефолт «рестарт на старшем уровне»), как и `fLegal`/`isLgl`, `dxaIndentSav` и `LfoData.cp`; `sprmPIlvl=0x0C` — абзац без numPr (не «в списке без номера»); AUTONUM-поля трактуются как обычные списки; отрицательный `sprmPIlfo` («сохранить отступы») — обычный numPr, отступы делает прямой `w:ind` абзаца; объединённые ячейки: вертикальное слияние (`vertMerge`) не переносится, горизонтальное — переносится собственной сеткой строки (TTP-абзац каждой строки несёт свой `sprmTDefTable`, §2.9.321 → `w:gridSpan`+суммарный `w:tcW`; регрессия — WordPdfConverterTest#docMergedTableRow_fullWidthNotSplit, юниты — DocToDocxFormattingTest#mergedRow_gridSpanAndWidth, #misalignedRow_fallsBackToColumnWidths), вложенные таблицы (sprmPFInnerTtp — разделитель ячейки/строки там ¶ 0x0D, не 0x07) и бордюры уровня ячейки (TC80/sprmTCellBorders) не переносятся — только сетка и строковые границы; строки, у которых сетка задана только `sprmTInsert` (в PrcData нет `sprmTDefTable`, а PAPX-зеркало отсутствует), деградируют в плоские абзацы (`sprmTInsert` конвертер не читает); `DocFile.countPages` (`PapxIndex.countPageBreakBefore`) цепочку PrcData не следует — свойства вне FKP в подсчёт страниц не попадают, 0x0C-разрывы считаются; сноски/концевые сноски/комментарии не рендерятся (метки ссылок пропускаются); плавающие объекты (якорь 0x08) — только inline-картинкой: позиция/плавание/обтекание (PlcfSpa) не переносятся; непринятые правки рендерятся как разметка (`w:ins`/`w:del`, вид «Show Markup»), эмуляция принятия правок не делается; скрытый текст вырезается мостом сам (`.docx`-путь чистит и его — правило 7, но мост не ждёт байтового прохода), ВСЕ ПРОПИСНЫЕ/малые капители — апкейс текста (FOP без font-variant); подсветка и затенения перенесены аудитом 2026-11: `sprmCHighlight` 0x2A0C → `w:highlight` (Ico→ST_HighlightColor по RGB), `sprmCShd` 0xCA71/`sprmCShd80` 0x4866/`sprmPShd` 0xC64D/`sprmPShd80` 0x442D → `w:shd` (форма `w:val="clear"` + цвет в `w:fill` — FOP закрашивает только w:fill, проверено экспериментально: `w:val="solid" w:color=RRGGBB w:fill="auto"` не рисует ничего; ipatSolid → fill=cvFore, иначе fill=cvBack — паттерны Ipat≥2 деградируют, [MS-DOC] Ipat: «lost if converted to ECMA-376»); затенение таблицы/ячеек (`sprmTSetShd` 0xD62D/`sprmTSetShd80` 0xD60F) мостом не переносится; тип подчёркивания не переносится: KUL любой → `w:u val="single"` (double/dotted деградируют, `sprmCCvUl` не читается); границы абзацев (хранятся sprm PAPX 0xC64E–0xC652, а не PlfBdx §2.9.8) не переносятся — и конвейер `w:pBdr` не рисует (в docx4j-export-fo 17.3.2 нет getPBdr, байткод 2026-11); не переносятся и не были бы нарисованы (в docx4j-export-fo 17.3.2 нет соответствующих getters — проверено байткодовым зондом): `w:tcBorders` (границы ячеек — TC80/sprmTCellBorders), `w:trHeight` (sprmTRheight), `w:tblHeader` (sprmTfHdrTbl), `w:cantSplit` (sprmTfCantSplit), `w:widowControl` (sprmPFWidowControl); отступы в символьных единицах `sprmPDxcLeft`/`sprmPDxcRight`/`sprmPDxcLeft1` 0x4456/0x4455/0x4457 не переносятся — операнд есть 1/100 ширины символа (§2.6.1), перевод в twips требует ширины глифа «0» разрешённого шрифта, коей у моста нет (guard `fCharLineUnits` §2.6.2: в обычных документах этих Prl нет вовсе); чётные варианты колонтитуков не переносятся (переносится только odd → `type="default"`, FOP не различает чётность полос набора); first-page переносится аудитом 2026-11 — sprmSFTitlePage + `type="first"` (см. строку `Headers`); разрыв секции в абзаце со sprmPFInTable деградирует в разрыв страницы (`w:sectPr` в `w:pPr` внутри `w:tc` невалиден); error-флаги `errorOnCharts`/`errorOnSmartArt`/`errorOnOle` на `.doc` **не срабатывают** — диаграммы/SmartArt/OLE в бинарном формате существуют только как BLIP-плейсхолдеры, мост выдаёт их картинками (задокументировано в `@Operation`); `stale-cache.doc` конвертируется (кэш PageCount=5, концепта lastRenderedPageBreak в .doc нет) — семантика отличается от docx-фикстуры, запинено тестом. diff --git a/docs/agent/pipeline.md b/docs/agent/pipeline.md index a1a6c91..249041b 100644 --- a/docs/agent/pipeline.md +++ b/docs/agent/pipeline.md @@ -41,7 +41,7 @@ 6. `NumberingSuffixNormalizer` — `w:suff w:val="space"` → дописанный обычный пробел в конце следующего `w:lvlText` того же уровня (порядок CT_Lvl suff→lvlText, wml.xsd; Part 1 §17.3.1.28): docx4j разделитель не эмитит вовсе (дамп n4.fo); уже пробельный lvlText не дублируется; suff=tab — отдельный Class C-остаток (нужна per-item ширина), nothing совпадает с docx4j. Регрессия — WordPdfConverterTest#suffSpace_labelGetsSpace. 7. `HiddenTextNormalizer` — вырезание скрытых ранов (Part 1 §17.3.2.30): truthy `w:vanish` в собственном `w:rPr` ранa (обе OnOff-формы; вал опущен — default true) **или** `w:rStyle` ∈ vanish-стили из `word/styles.xml` (транзитивно по `w:basedOn`, капа цепочки 16, цикл — обрыв); ран с защищённым содержимым (`fldChar`/`instrText`/`footnoteReference`/`endnoteReference`/`drawing`/`pict`/`object`/`txbxContent`) не трогается — удаление спаренных `begin…separate…end` сломало бы поле. Word скрытое не печатает, стилист docx4j `vanish` не читает вовсе → без правила скрытое утекало в PDF. Индивидуальный `normalize()` — свой pass styles.xml. Регрессия — WordPdfConverterTest#hiddenText_notPrinted, юниты — HiddenTextNormalizerTest. 8. `RubyNormalizer` — разбор руби-разметки (Part 1 §17.3.3.18/.19/.20/.21): `w:rubyBase`/`w:rubyBaseText` разворачиваются в обычные раны, `w:rt`/`w:rubyPr`/`w:rubyAlign` вырезаются с содержимым (надстрочница — принятая деградация, ruby-разметки в FOP нет; потеря текста хуже потери аннотации). Чинится **в байтах**, а не в XSLT: схема docx4j 17.3.6 не биндит `w:rubyBase`/`w:rt` в `w:r` — unmarshaller теряет их до стилиста (в отличие от `moveFrom`/`moveTo`/`bdo`/`dir`, которых схема знает — тех ловит AUDIT-FIX-2). Регрессия — WordPdfConverterTest#rubyBase_textPrinted, юниты — RubyNormalizerTest. -9. `DistributeStampNormalizer` — `w:pPr/w:jc w:val="distribute"` → невидимая закладка-якорь `w:bookmarkStart w:name="pj-distribute-<часть>-"` сразу после `` (Part 1 §17.18.44): docx4j для DISTRIBUTE не эмитит в FO ничего, канонический эквивалент — пара `text-align`/`text-align-last="justify"`, но стилист править нельзя (дрейф-гейт), а `LayoutPostRenderer` опознаёт абзац только по якорю — `BookmarkStartWriter` делает из закладки `` первым инлайн-ребёнком блока, фильтр дописывает блоку justify-пару (сериализация без префикса `fo:` учтена паттерном). Штампуются только content-части (document/footnotes/endnotes; в numbering у `CT_Lvl` закладок не бывает, `w:jc` в `trPr`/`tblPr` не читается — разбор только внутри `w:pPr`); счётчик id от max существующих +1, идемпотентность по метке `pj-distribute-`. Идёт после Hidden, чтобы не штамповать вырезанный абзац. Регрессия — WordPdfConverterTest#distribute_allLinesReachRightMargin, юниты — DistributeStampNormalizerTest, пин форка — DistributeLineTestCase. +9. `DistributeStampNormalizer` — `w:pPr/w:jc w:val="distribute"` → невидимая закладка-якорь `w:bookmarkStart w:name="pj-distribute-<часть>-"` сразу после `` (Part 1 §17.18.44): docx4j для DISTRIBUTE не эмитит в FO ничего, канонический эквивалент — пара `text-align`/`text-align-last="justify"`, но стилист править нельзя (дрейф-гейт), а `LayoutPostRenderer` опознаёт абзац только по якорю — `BookmarkStartWriter` делает из закладки `` первым инлайн-ребёнком блока, фильтр дописывает блоку justify-пару (сериализация без префикса `fo:` учтена паттерном). Штампуются контентные части (document/footnotes/endnotes, `headerN`/`footerN` — якорь работает и в колонтитулах; в numbering у `CT_Lvl` закладок не бывает, `w:jc` в `trPr`/`tblPr` не читается — разбор только внутри `w:pPr`, первого ребёнка `w:p`, §17.3.1.23); старое `jc` внутри `w:pPrChange` (реvision) — не текущее выравнивание: окно поиска режется началом реvision, штамп ставится после наружного ``; счётчик id от max существующих +1, идемпотентность позиционная (штамп всегда сразу за закрытием pPr). Идёт после Hidden, чтобы не штамповать вырезанный абзац. Регрессия — WordPdfConverterTest#distribute_allLinesReachRightMargin, юниты — DistributeStampNormalizerTest, пин форка — DistributeLineTestCase. 10. `OleObjectNormalizer` — принимает флаг `errorOnOle`. Два этапа: дешёвый детект по центральному каталогу zip (`ZipFile`; читаются только `[Content_Types].xml` и `word/*.xml` до первого `` из `word/*.xml` не выбрасываются, а заменяются статичным представлением — картинкой-плейсхолдером (ECMA-376 §15.2.10): `w:drawing` переиспользуется дословно, `v:imagedata r:id` → inline-DrawingML на ту же image-часть (размер из `style` `v:shape`, иначе `w:dxaOrig`/`w:dyaOrig` ×635), блоки с `w:control` и без плейсхолдера удаляются. OLE-бинарники никогда не читаются. При `errorOnOle=true` вместо вычистки — `DrawingFoundException(OLE)`. Лечит оба механизма падения docx4j: JAXB-разбор бинарника под ложным XML-типом («Content is not allowed in prolog» → NPE) и NPE `chunkType is null` в VML-сериализации `w:object`. Многочастный: публичный член только `normalize(byte[], boolean)`, `rewrite`-хука нет. `mc-preprocessor.xslt` docx4j (в jar `docx4j-core`) перебивает strict-namespace'ы в transitional и конвертит `pt` в twips/half-points, но ветку перевода процентов в тысячные для namespace'ных атрибутов содержит с закомментированным `` (для атрибутов без namespace — она активна), а `w:start`/`w:end` в `w:left`/`w:right` не маппит вовсе. Поэтому собственный рерайт URI ломать нельзя — он сломал бы pt-конверсию preprocessor'а (FOP получил бы «10pt»). diff --git a/docs/agent/render-limitations.md b/docs/agent/render-limitations.md index 4f03e89..87a261d 100644 --- a/docs/agent/render-limitations.md +++ b/docs/agent/render-limitations.md @@ -4,6 +4,6 @@ - Известный остаток эталона: U+2188/U+218A — глифов нет в OFL-шрифтах бандла, остаются `.notdef` (GNU FreeSerif GPL — не добавляем намеренно). -- Аудит раскладки по ECMA-376 Part 1 (2026-10, реаудит на docx4j 17.3.6 + форке FOP 2.12 — 2026-11) — известные нечинимые ограничения FOP/docx4j (Java-слой): `w:lvlJc` игнорируется (numbering-лейбл всегда у number position: `lvlJc="right"`/`"center"` рендерятся идентично `left` — лейблы по общему левому краю; suff=space чинит правило 6, suff=nothing совпадает с docx4j — разделителя нет); абзац без `w:line` рендерится natural-высотой FOP 15.44pt@11pt, явный `lineRule="auto"` — 13.4277pt, два «single» в конвертере (13.4277 — канонический single по метрикам Carlito/Calibri 2500/2048 em; обе величины считаются по метрикам шрифта); кернинг не применяется ни для одного бандл-семейства (замер на 17.3.6/форке 2.12: dx пары = сумма advance без поправки — Carlito «Wa»/«AV», DejaVu Sans «Ta»; GPOS-only у 22 TTF, а legacy `kern`-таблица DejaVu Sans/Serif ключована glyph id, не совпадающими с cmap (2568/2727 пар без Unicode-маппинга, пары A→V нет) — латинский путь FOP (`TextLayoutManager`→`Font.hasKerning`) читает только legacy `kern` и такие пары отбрасывает; GPOS-путь в форке тоже не применяется); свойства `kerning` в форке нет, порог `w:kern` через FO не выражается. Word кернит только при явно заданном `w:kern` в иерархии стилей и при sz ≥ val (Part 1 §17.3.2.19; при отсутствии `w:kern` Office не кернит — MS-OI29500 §21.1.2.3.9a) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 5), `w:suff="space"` (правило 6). Починено на 17.3.6+форке: `w:jc="distribute"` (правило 9 `DistributeStampNormalizer` ставит закладку-якорь, `LayoutPostRenderer` дописывает блоку пару `text-align`/`text-align-last="justify"` — межсловный разнос всех строк, включая последнюю; пин в форке `DistributeLineTestCase`, в конвертере `distribute_allLinesReachRightMargin`; межсимвольный kashida-разнос §17.18.44 не реализован — для латиницы Word разносит межсловные пробелы, однословная строка не растягивается, потому что растягивать нечем). Починено апстримом 17.3.6: `w:framePr` (фрейм позиционируется — замер: FRAME на x=252pt = левое поле 72pt + `w:x=180pt`; до апгрейда текст шёл в общем потоке), symbol-шрифты и complex-поля PAGE/NUMPAGES (экспорт сам маппит PUA-маркеры и пересчитывает page-поля). +- Аудит раскладки по ECMA-376 Part 1 (2026-10, реаудит на docx4j 17.3.6 + форке FOP 2.12 — 2026-11) — известные нечинимые ограничения FOP/docx4j (Java-слой): `w:lvlJc` игнорируется (numbering-лейбл всегда у number position: `lvlJc="right"`/`"center"` рендерятся идентично `left` — лейблы по общему левому краю; suff=space чинит правило 6, suff=nothing совпадает с docx4j — разделителя нет); абзац без `w:line` рендерится natural-высотой FOP 15.44pt@11pt, явный `lineRule="auto"` — 13.4277pt, два «single» в конвертере (13.4277 — канонический single по метрикам Carlito/Calibri 2500/2048 em; обе величины считаются по метрикам шрифта); кернинг не применяется ни для одного бандл-семейства (замер на 17.3.6/форке 2.12: dx пары = сумма advance без поправки — Carlito «Wa»/«AV», DejaVu Sans «Ta»; GPOS-only у 22 TTF, а legacy `kern`-таблица DejaVu Sans/Serif ключована glyph id, не совпадающими с cmap (2568/2727 пар без Unicode-маппинга, пары A→V нет) — латинский путь FOP (`TextLayoutManager`→`Font.hasKerning`) читает только legacy `kern` и такие пары отбрасывает; GPOS-путь в форке тоже не применяется); свойства `kerning` в форке нет, порог `w:kern` через FO не выражается. Word кернит только при явно заданном `w:kern` в иерархии стилей и при sz ≥ val (Part 1 §17.3.2.19; при отсутствии `w:kern` Office не кернит — MS-OI29500 §21.1.2.3.9a) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 5), `w:suff="space"` (правило 6). Починено на 17.3.6+форке: `w:jc="distribute"` (правило 9 `DistributeStampNormalizer` ставит закладку-якорь, `LayoutPostRenderer` дописывает блоку пару `text-align`/`text-align-last="justify"` — межсловный разнос всех строк, включая последнюю; пин в форке `DistributeLineTestCase`, в конвертере `distribute_allLinesReachRightMargin`; межсимвольный kashida-разнос §17.18.44 не реализован — для латиницы Word разносит межсловные пробелы, однословная строка не растягивается, потому что растягивать нечем). Починено апстримом 17.3.6: `w:framePr` (фрейм `hAnchor="page"` позиционируется: текст на x=180pt от края страницы — `w:x=3600` twips при `hAnchor="page"` отсчитывается от края страницы, не от поля, §17.4.31; пин — фикстура frame-pr.docx и WordPdfConverterTest#framePr_positionedLikeWord; до апгрейда текст шёл в общем потоке), symbol-шрифты и complex-поля PAGE/NUMPAGES (экспорт сам маппит PUA-маркеры и пересчитывает page-поля). - Аудит .docx-путей по ECMA-376 (2026-11) — запинено синтетикой (без фикстур): сноски/концевые сноски с номерами (§17.11), внешние гиперссылки с `/URI`-аннотацией (§17.12.23), `PAGEREF` (complex и вложенный в результат `TOC`) и `DATE` подменяют кэш живым значением, `titlePg` → first/default колонтитуки (§17.13.1.35), `vMerge` restart/continue (§17.4.70), block-level `w:sdt` (§17.5.2), `wps:txbx`-текст (§17.3.3.23), OMML-формулы рисуются вектором jeuclid-fop (§22.1 — текст из PDF не извлекается, пинь пикселями), фон `w:highlight`/`w:shd` рисуется (§17.3.2.16/.29). Скрытый текст `w:vanish` не печатается (правило 7); текст руби-базы и `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir` не теряется (правило 8 + AUDIT-FIX-2). Остаток (не чиним): `REF`/`SEQ`/литеральные записи `TOC` печатают устаревший кэш из docx (движка пересчёта нет; инстринции полей не печатаются); надстрочница руби не выводится (правило 8 печатает только базу — ruby-разметки в FOP нет); `w:ptab` без `@w:alignment`, `bar`, `list` теряются catch-all'ом; `w:bdo`/`w:dir` печатаются LTR (bidi вне контура). diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizer.java index 6c6d82e..5397467 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizer.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizer.java @@ -23,20 +23,26 @@ import java.util.zip.ZipOutputStream; * нельзя (дрейф-гейт {@code vendoredXsltTracksJarCopy}), а рендер-фильтр * {@code LayoutPostRenderer} видит только FO и опознал бы distribute-абзац * лишь по якорю. Штамп — этот якорь: {@code w:bookmarkStart - * w:name="pj-distribute-<часть>-"} сразу после {@code }; экспорт - * docx4j ({@code BookmarkStartWriter}) превращает её в {@code } первым инлайн-ребёнком блока, и фильтр дописывает - * блоку пару justify-свойств. Имена закладок уникальны в пределах конвертации - * (docx4j дубликаты выбрасывает с warn), поэтому счётчик per-part с меткой - * части в имени.

    + * w:name="pj-distribute-<часть>-"} сразу после закрывающего {@code } + * абзаца; экспорт docx4j ({@code BookmarkStartWriter}) превращает её в + * {@code } первым инлайн-ребёнком блока, и + * фильтр дописывает блоку пару justify-свойств. Имена закладок уникальны в + * пределах конвертации (docx4j дубликаты выбрасывает с warn), поэтому + * счётчик per-part с меткой части в имени.

    * - *

    Штампуются только content-части (document/footnotes/endnotes): в - * {@code numbering.xml} у {@code CT_Lvl} закладки быть не может (не входит в - * EG_PPrGeneralContent, WML XSD), а {@code w:jc} в {@code trPr}/{@code tblPr} - * (выравнивание таблицы/строки) не читается — разбор идёт только содержимым - * {@code w:pPr}. Диапазон абзаца плоский: {@code w:p} не вложен в {@code w:p}. - * Уже проштампованный абзац не дублируется (идемпотентность). Нечего менять → - * {@code null} (контракт rewrite-хуков).

    + *

    Штампуются контентные части ({@code document}, {@code footnotes}, + * {@code endnotes}, {@code headerN}/{@code footerN} — закладка-якорь работает + * и в колонтитулах): в {@code numbering.xml} у {@code CT_Lvl} закладки быть + * не может (не входит в EG_PPrGeneralContent, WML XSD), а {@code w:jc} в + * {@code trPr}/{@code tblPr} (выравнивание таблицы/строки) не читается — + * разбор идёт только содержимым {@code w:pPr} (первый ребёнок {@code w:p}, + * Part 1 §17.3.1.23). Старое значение {@code w:jc} внутри {@code w:pPrChange} + * (реvision) — не текущее выравнивание: окно поиска огранивается началом + * реvision, а штамп вставляется после наружного {@code }. Диапазон + * абзаца плоский: {@code w:p} не вложен в {@code w:p}. Уже проштампованный + * абзац не дублируется (идемпотентность проверяется позиционно — штамп + * всегда стоит сразу после закрытия pPr). Нечего менять → {@code null} + * (контракт rewrite-хуков).

    * *

    Регрессии — DistributeStampNormalizerTest (юнит), * WordPdfConverterTest#distribute_allLinesReachRightMargin (конвейер), @@ -61,6 +67,15 @@ final class DistributeStampNormalizer { /** Закрывающий слэш открывающего тега: {@code } — абзац без содержимого. */ private static final char SELF_CLOSE_SLASH = '/'; + /** Закрытие w:pPr; наружное ищем от конца абзаца (внутри — w:pPrChange). */ + private static final String PPR_CLOSE = ""; + + /** Начало реvision абзаца — старое значение jc внутри неё не текущее. */ + private static final Pattern PPR_CHANGE = Pattern.compile("} — проверка позиционная. */ + private static final String BOOKMARK_OPEN = "= end) { + // pPr — первый ребёнок w:p (Part 1 §17.3.1.23): проверка на месте, + // без поиска по хвосту части (O(1) на абзац без pPr). + int pos = gt + 1; + while (pos < end && xml.charAt(pos) <= ' ') { + pos++; + } + if (!xml.startsWith("", pprOpen); - if (pprClose < 0 || pprClose >= end) { + // Наружное закрытие — последнее до конца абзаца: внутри pPr может + // стоять w:pPrChange (реvision), чей контент содержит . + int pprClose = xml.lastIndexOf(PPR_CLOSE, end - 1); + if (pprClose <= pos) { continue; } - CharSequence ppr = xml.subSequence(pprOpen, pprClose); - if (!JC_DISTRIBUTE.matcher(ppr).find()) { + CharSequence ppr = xml.subSequence(pos, pprClose); + // Старое значение jc из реvision — не текущее выравнивание: + // окно jc-поиска ограниваем началом w:pPrChange. + Matcher rev = PPR_CHANGE.matcher(ppr); + int jcWindow = rev.find() ? rev.start() : ppr.length(); + if (!JC_DISTRIBUTE.matcher(ppr.subSequence(0, jcWindow)).find()) { continue; } - int stamped = xml.indexOf(STAMP_MARK, gt); - if (stamped >= 0 && stamped < end) { - continue; // уже проштампован + // Идемпотентность: наш штамп стоит сразу после наружного закрытия, + // проверяем позицию, а не сканируем абзац в поисках метки. + int after = pprClose + PPR_CLOSE.length(); + int probe = after; + while (probe < end && xml.charAt(probe) <= ' ') { + probe++; + } + if (xml.startsWith(BOOKMARK_OPEN, probe)) { + int tagEnd = xml.indexOf('>', probe); + int stampAt = tagEnd > 0 ? xml.indexOf(STAMP_MARK, probe) : -1; + if (stampAt >= probe && stampAt < tagEnd) { + continue; // уже проштампован + } } seq++; if (sb == null) { sb = new StringBuilder(xml.length() + 64); } - sb.append(xml, mark, pprClose + "".length()); + sb.append(xml, mark, after); sb.append("") .append(""); - mark = pprClose + "".length(); + mark = after; } return sb == null ? null : sb.append(xml, mark, xml.length()).toString(); } @@ -140,8 +176,15 @@ final class DistributeStampNormalizer { case "word/endnotes.xml": return "endnotes"; default: - return null; + break; } + // word/header1.xml, word/footer2.xml, … — метка = имя файла без расширения; + // точка в основании отсекает .rels и вложенные пути. + if (part.startsWith("word/header") || part.startsWith("word/footer")) { + String base = part.substring("word/".length(), part.length() - ".xml".length()); + return base.indexOf('.') < 0 ? base : null; + } + return null; } private static int maxBookmarkId(String xml) { diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/LayoutPostRenderer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/LayoutPostRenderer.java index 2ba7d1e..4cbbab4 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/LayoutPostRenderer.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/LayoutPostRenderer.java @@ -29,7 +29,7 @@ import java.util.regex.Pattern; * cellMar). Регрессия — WordPdfConverterTest#tableCellPadding_textInsetLikeWord. *

  • distribute → justify-пара. docx4j для {@code w:jc="distribute"} * не эмитит в FO ничего; по якорю-закладке {@code pj-distribute-…} - * (DistributeStampNormalizer, правило 12) блоку дописывается + * (DistributeStampNormalizer, правило 9) блоку дописывается * {@code text-align="justify" text-align-last="justify"} — Word растягивает * пробелы всех строк, включая последнюю (Part 1 §17.18.44). Регрессия — * LayoutPostRendererTest (фильтр), diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/NumberingSuffixNormalizer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/NumberingSuffixNormalizer.java index 77ad413..3cee973 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/NumberingSuffixNormalizer.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/NumberingSuffixNormalizer.java @@ -28,6 +28,11 @@ import java.util.zip.ZipOutputStream; * wml.xsd: suff → lvlText; между ними нет {@code }); уже * заканчивающийся пробелом lvlText не дублируется. suff=tab/absent/nothing — * не трогаем. Нечего менять → тот же массив. + * + *

    Двойного пробела правило с форком не даёт: TP-поток PDF на suff=space — + * «1.·ITEM» (один разделитель): word-layout путь форка + * ({@code labelSuffixSpace}) разделитель не дописывает — эмитится только наш + * lvlText-пробел.

    */ final class NumberingSuffixNormalizer { diff --git a/wordpdf-core/src/main/resources/xslt/docx2fo.xslt b/wordpdf-core/src/main/resources/xslt/docx2fo.xslt index 2277583..c800398 100644 --- a/wordpdf-core/src/main/resources/xslt/docx2fo.xslt +++ b/wordpdf-core/src/main/resources/xslt/docx2fo.xslt @@ -1191,7 +1191,7 @@ bidi-направление — принятая деградация (complex-script в FOP-форке нет). Руби (w:rubyBase/w:rt, §17.3.3.19/.20/.21) тут не чинится: схема docx4j не биндит эти элементы, unmarshaller выбрасывает их до XSLT — разбор - делает RubyNormalizer (правило 10) в байтах. + делает RubyNormalizer (правило 8) в байтах. Регрессии — WordPdfConverterTest#movedRevision_textPrinted, #bdoDir_textPrinted. --> diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java index 9148ab7..e0b1240 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java @@ -444,7 +444,7 @@ public final class SampleDocxGenerator { /** * w:jc="distribute" (+ контроль {@code both} и левый): Word растягивает * пробелы всех строк, включая последнюю (Part 1 §17.18.44); docx4j для - * DISTRIBUTE не эмитит ничего, без правила 12 абзац печатается влево. + * DISTRIBUTE не эмитит ничего, без правила 9 абзац печатается влево. * Регрессия — WordPdfConverterTest#distribute_allLinesReachRightMargin. */ private static void distribute(Path out) throws Exception { diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java index 59f4851..f795241 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java @@ -2935,7 +2935,7 @@ class WordPdfConverterTest { /** * w:jc="distribute" (Part 1 §17.18.44): Word растягивает пробелы всех строк, * включая последнюю. docx4j для DISTRIBUTE не эмитит в FO ничего — без - * правила 12 (DistributeStampNormalizer) и justify-пары (LayoutPostRenderer) + * правила 9 (DistributeStampNormalizer) и justify-пары (LayoutPostRenderer) * абзац печатается по левому краю. Фикстура — samples/distribute.docx: * один и тот же текст абзацами distribute / left / both; правое поле * A4 72pt → 523.28pt; хвостовая строка трёхсловная («quebec romeo sierra») — diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizerTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizerTest.java index fd36b9d..9570021 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizerTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/DistributeStampNormalizerTest.java @@ -17,7 +17,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue; /** * Юниты {@link DistributeStampNormalizer}: штамп {@code w:jc="distribute"} - * закладкой-якорем после {@code } (Part 1 §17.18.44, правило 12). + * закладкой-якорем после {@code } (Part 1 §17.18.44, правило 9). */ class DistributeStampNormalizerTest { @@ -118,6 +118,58 @@ class DistributeStampNormalizerTest { assertTrue(fixed.contains("pj-distribute-document-1"), fixed); } + /** distribute только в w:pPrChange (старое значение) — не текущий jc, не штампуем. */ + @Test + void revisionJcOnly_returnsNull() { + String xml = document("" + + "" + JC_DISTRIBUTE + "" + + "правка"); + assertNull(DistributeStampNormalizer.rewrite("word/document.xml", xml)); + } + + /** Реvision с собственным w:pPr внутри: штамп — после наружного . */ + @Test + void revisionNestedPPr_stampAfterOuterClose() { + String xml = document("" + JC_DISTRIBUTE + + "" + + "правки"); + String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml); + int stamp = fixed.indexOf("pj-distribute-document-1"); + assertTrue(stamp > fixed.indexOf(""), fixed); + assertTrue(stamp < fixed.indexOf(""), fixed); + } + + /** Колонтитулы — контентные части: штамп с меткой файла. */ + @Test + void headerAndFooter_partStamped() { + String xml = document(para(JC_DISTRIBUTE, "шапка")); + String header = DistributeStampNormalizer.rewrite("word/header1.xml", xml); + assertTrue(header.contains("w:name=\"pj-distribute-header1-1\""), header); + String footer = DistributeStampNormalizer.rewrite("word/footer2.xml", xml); + assertTrue(footer.contains("w:name=\"pj-distribute-footer2-1\""), footer); + assertNull(DistributeStampNormalizer.rewrite("word/header1.xml.rels", xml)); + } + + /** Отступы между тегами (pretty-printed часть) — pPr остаётся первым ребёнком. */ + @Test + void whitespaceBeforePPr_stillStamped() { + String xml = document("\n " + JC_DISTRIBUTE + "\n" + + "отступ"); + String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml); + assertTrue(fixed.contains(""), fixed); + } + + /** Чужая Word-закладка сразу после — не штамп, штампуем свой. */ + @Test + void foreignBookmarkAfterPPr_stillStamped() { + String xml = document("" + JC_DISTRIBUTE + "" + + "" + + "оглав"); + String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml); + assertTrue(fixed.contains("w:name=\"pj-distribute-document-1\""), fixed); + } + /** Контракт zip-пути: нечего менять → тот же массив; есть штамп → новые байты со штампом. */ @Test void normalize_identityWhenNothing_stampWhenDistribute() throws IOException { diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/LayoutPostRendererTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/LayoutPostRendererTest.java index c865dca..1ea340d 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/LayoutPostRendererTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/LayoutPostRendererTest.java @@ -139,6 +139,18 @@ class LayoutPostRendererTest { + " text-align=\"justify\" text-align-last=\"justify\">"), fixed); } + /** Якорь в колонтитуле (fo:static-content) — justify-пара так же дописывается. */ + @Test + void distributeStamp_inStaticContent_justifyPairAdded() { + String fo = "" + + "" + + "шапка строки" + + ""; + String fixed = LayoutPostRenderer.fix(fo); + assertTrue(fixed.contains(""), fixed); + } + /** Реальная форма сериализации docx4j: DOM-поддерево без префикса fo. */ @Test void distributeStamp_unprefixedInline_stillStamped() { -- 2.56.1 From 19300ac640eae162cf90bdd5f8a4f3dfec4eb821 Mon Sep 17 00:00:00 2001 From: Pjandro Date: Sun, 8 Nov 2026 23:51:29 +0000 Subject: [PATCH 8/9] =?UTF-8?q?docs:=20=D1=81=D1=87=D1=91=D1=82=D1=87?= =?UTF-8?q?=D0=B8=D0=BA=D0=B8=2058/906=20(core=2052/858,=20WordPdfConverte?= =?UTF-8?q?rTest=2083)=20-=20=D0=B4=D0=BE=D0=B3=D0=BD=D0=B0=D0=BD=D1=8B=20?= =?UTF-8?q?=D0=BF=D0=BE=D1=81=D0=BB=D0=B5=20=D1=80=D0=B5=D0=B2=D1=8C=D1=8E?= =?UTF-8?q?-=D1=8E=D0=BD=D0=B8=D1=82=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/agent/testing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/agent/testing.md b/docs/agent/testing.md index 72ad428..50ca9b4 100644 --- a/docs/agent/testing.md +++ b/docs/agent/testing.md @@ -2,7 +2,7 @@ ### Счётчики (2026-11) -- 57 тестовых классов / 881 тест: core 51/833 (`internal/doc/` 17/232, `internal/chart/` 17/277, `WordPdfConverterTest` 82), app 6/48 (ConvertController 26, ApiKeyFilter 8, ConversionService 5, ApiExceptionHandler 5, ConvertLimits 3, ConversionTimeout 1). Обновлять при изменении набора. +- 58 тестовых классов / 906 тестов: core 52/858 (`internal/doc/` 17/232, `internal/chart/` 17/277, `WordPdfConverterTest` 83), app 6/48 (ConvertController 26, ApiKeyFilter 8, ConversionService 5, ApiExceptionHandler 5, ConvertLimits 3, ConversionTimeout 1). Обновлять при изменении набора. ### Пиксели, метрики шрифтов, стенд без fontconfig -- 2.56.1 From 7b9fdf783dfc702daa5aa69a0b31e8290a196201 Mon Sep 17 00:00:00 2001 From: Pjandro Date: Sun, 8 Nov 2026 23:51:46 +0000 Subject: [PATCH 9/9] =?UTF-8?q?docs:=20=D1=81=D1=87=D1=91=D1=82=D1=87?= =?UTF-8?q?=D0=B8=D0=BA=20=D1=84=D0=B8=D0=BA=D1=81=D1=82=D1=83=D1=80=2014?= =?UTF-8?q?=20docx=20(+distribute.docx)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- AGENTS.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/AGENTS.md b/AGENTS.md index 5b12099..e7a0305 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -131,7 +131,7 @@ python3 docs/standards/docx/validate-fixtures.py wordpdf-core/src/test/resources - Стек: JUnit 6 (`org.junit.jupiter`), только `Assertions` — Mockito/AssertJ не использовать; в app-тестах допустим inline-Hamcrest `containsString` в `andExpect`; тестовые классы package-private, зеркалят main-пакеты. Счётчики — `docs/agent/testing.md`. - **PDF сравнивается текстом, не растеризацией**: PDFBox 3, `PDFTextStripper`; негативные маркеры — `.notdef` (`#`) и `Helvetica`; текст нормализуется по пробелам (`norm`). Пиксельные проверки — только в юнитах chart-пейнтеров (допуски `assertRatio` < 0.06 / < 0.10). Детали — `docs/agent/repo-map.md`. - Регрессивная конвенция: фикс = нормализатор/рендерер + юнит + конвертер-тест; в javadoc фикса — ссылка «Регрессия — Test#имя, фикстура samples/…». Пары `XxxNormalizerTest`↔`тест-в-конвейере` воспроизводятся грепом по этим ссылкам; исключения — `docs/agent/testing.md`. -- Фикстуры — только закоммиченные `samples/*.docx` (13) + `samples/*.doc` (12), в тестах не генерировать; контракт нормализаторов «нечего менять → тот же массив» (`assertSame`) + неприкосновенность частей вне `word/*.xml`. +- Фикстуры — только закоммиченные `samples/*.docx` (14) + `samples/*.doc` (12), в тестах не генерировать; контракт нормализаторов «нечего менять → тот же массив» (`assertSame`) + неприкосновенность частей вне `word/*.xml`. - App-тесты: `@SpringBootTest` + `@AutoConfigureMockMvc` (Boot 4: `org.springframework.boot.webmvc.test.autoconfigure`); четыре набора свойств = четыре контекста (отдельные классы, не `@Nested`); `ConversionServiceTest`/`ApiExceptionHandlerTest` — без Spring. Core-юниты Spring **не поднимают**; app-тесты проверяют только HTTP-код/заголовки/текст ошибки. Детали — `docs/agent/testing.md`. - Жизненный цикл: только `@Test`; исключения — два `@BeforeAll` (прогрев шрифтов) и `@AfterEach drainWorker` в `ConversionTimeoutTest`. Ни `@Nested`, ни `@ParameterizedTest`, ни `@Disabled`, ни `assertAll`. - Идиомы загрузки фикстур: **core** — classloader без ведущего слэша, **app** — class-relative со слэшем (core test-jar). Синтетика: docx — `ZipOutputStream`, `.doc` — крафт `POIFSFileSystem`. -- 2.56.1