From ab41d9d09b9d0a3318fe8a9940166c8ac2a1aaf9 Mon Sep 17 00:00:00 2001 From: Pjandro Date: Sun, 8 Nov 2026 21:26:32 +0000 Subject: [PATCH] =?UTF-8?q?build(core):=20docx4j=2017.3.2=20=E2=86=92=2017?= =?UTF-8?q?.3.6=20=E2=80=94=20=D0=BF=D0=B5=D1=80=D0=B5=D0=B2=D0=B5=D0=BD?= =?UTF-8?q?=D0=B4=D0=BE=D1=80=D0=BA=D0=B0=20docx2fo.xslt=20(AUDIT-FIX-1/2?= =?UTF-8?q?=20=D0=BF=D0=B5=D1=80=D0=B5=D0=BD=D0=B5=D1=81=D0=B5=D0=BD=D1=8B?= =?UTF-8?q?),=20repair=3Dword,=20=D1=83=D0=B4=D0=B0=D0=BB=D0=B5=D0=BD?= =?UTF-8?q?=D0=B8=D0=B5=20=D0=BF=D1=80=D0=B0=D0=B2=D0=B8=D0=BB=20Symbol/Fi?= =?UTF-8?q?eld=20(=D0=B4=D0=B5=D0=BB=D0=B0=D0=B5=D1=82=20=D1=81=D0=B0?= =?UTF-8?q?=D0=BC=20=D1=8D=D0=BA=D1=81=D0=BF=D0=BE=D1=80=D1=82=2017.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