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 = "" + tag + ">";
- 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