FOP-оверлей ru.pjandro + правило 9: w:jc=distribute растягивает все строки #101

Closed
ai wants to merge 9 commits from fop-overlay-integration into main
13 changed files with 92 additions and 1347 deletions
Showing only changes of commit ab41d9d09b - Show all commits
+3 -3
View File
@@ -22,8 +22,8 @@
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!-- docx4j: последняя стабильная версия на Maven Central --> <!-- docx4j: последняя стабильная версия на Maven Central -->
<docx4j.version>17.3.2</docx4j.version> <docx4j.version>17.3.6</docx4j.version>
<!-- commons-compress: версию декларирует docx4j-core 17.3.2 (1.28.0); <!-- commons-compress: версию декларирует docx4j-core 17.3.6 (1.28.0);
не завышать — версия привязана к docx4j, а не к свежести --> не завышать — версия привязана к docx4j, а не к свежести -->
<commons-compress.version>1.28.0</commons-compress.version> <commons-compress.version>1.28.0</commons-compress.version>
<slf4j.version>2.0.20</slf4j.version> <slf4j.version>2.0.20</slf4j.version>
@@ -78,7 +78,7 @@
<version>${docx4j.version}</version> <version>${docx4j.version}</version>
</dependency> </dependency>
<!-- Прямая зависимость ядра (DependencyGuard) + нижний порог <!-- Прямая зависимость ядра (DependencyGuard) + нижний порог
docx4j 17.3.2 — 1.25.0; в Boot-BOM 4.1.1 не управляется --> docx4j 17.3.6 — 1.28.0; в Boot-BOM 4.1.1 не управляется -->
<dependency> <dependency>
<groupId>org.apache.commons</groupId> <groupId>org.apache.commons</groupId>
<artifactId>commons-compress</artifactId> <artifactId>commons-compress</artifactId>
@@ -77,12 +77,18 @@ public final class WordPdfConverter {
// classpath'а за шрифтами — всё найденное выбрасывает // classpath'а за шрифтами — всё найденное выбрасывает
// BundledFonts.restrictToBundled() перед каждой конвертацией. // BundledFonts.restrictToBundled() перед каждой конвертацией.
// Реестр обязан оставаться бандл + встроенные в docx. Свойства читает // Реестр обязан оставаться бандл + встроенные в docx. Свойства читает
// тот же static-блок BestMatchingMapper (docx4j-core 17.3.2); наша // тот же static-блок BestMatchingMapper (docx4j-core 17.3.6); наша
// инициализация предшествует первому new BundledFontMapper(). // инициализация предшествует первому new BundledFontMapper().
// discoverJarFonts("fonts-symbol") свойством не гейтится — символ- // discoverJarFonts("fonts-symbol") свойством не гейтится — символ-
// шрифт регистрируется как раньше и снимается restrict'ом как раньше. // шрифт регистрируется как раньше и снимается restrict'ом как раньше.
Docx4jProperties.setProperty("docx4j.fonts.discoverPhysicalFonts.enabled", "false"); Docx4jProperties.setProperty("docx4j.fonts.discoverPhysicalFonts.enabled", "false");
Docx4jProperties.setProperty("docx4j.fonts.discoverJarFonts.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() { private WordPdfConverter() {
@@ -156,8 +162,8 @@ public final class WordPdfConverter {
* считаются ровно раз по сырому входу, до аллокаций docx4j: для .docx — * считаются ровно раз по сырому входу, до аллокаций docx4j: для .docx —
* lightweight-скан по zip, для .doc — по чистому бинарному документу до * lightweight-скан по zip, для .doc — по чистому бинарному документу до
* конвертации. Повторного скана по нормализованным байтам нет: правила * конвертации. Повторного скана по нормализованным байтам нет: правила
* 1–10 {@code DocxRewritePipeline} число учитываемых разрывов не * 1–8 {@code DocxRewritePipeline} число учитываемых разрывов не
* увеличивают (правило 9 способно только убрать разрыв внутри скрытого * увеличивают (правило 7 способно только убрать разрыв внутри скрытого
* рана — счёт по сырому входу остаётся верхней оценкой лимита), а скан * рана — счёт по сырому входу остаётся верхней оценкой лимита), а скан
* внутри живой JAXB-модели удваивал бы пиковую память. * внутри живой JAXB-модели удваивал бы пиковую память.
* *
@@ -435,7 +441,7 @@ public final class WordPdfConverter {
} }
/** /**
* Нормализация входных байтов (цепочка {@link #normalizers}: правила 1–10 * Нормализация входных байтов (цепочка {@link #normalizers}: правила 1–8
* одним zip-проходом {@code DocxRewritePipeline} + условная OLE-вычистка) * одним zip-проходом {@code DocxRewritePipeline} + условная OLE-вычистка)
* и {@code WordprocessingMLPackage.load} полученного transitional-байта. * и {@code WordprocessingMLPackage.load} полученного transitional-байта.
* Нормализация переиспользует слот {@code bytes}: каждая замена массива * Нормализация переиспользует слот {@code bytes}: каждая замена массива
@@ -453,7 +459,7 @@ public final class WordPdfConverter {
/** /**
* Конвейер байтовой нормализации docx. Порядок фиксирован: сначала один * Конвейер байтовой нормализации docx. Порядок фиксирован: сначала один
* zip-проход переписывания XML-частей (внутри части порядок рерайтов * zip-проход переписывания XML-частей (внутри части порядок рерайтов
* Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→ * Strict→OnOff→Invisible→GlyphCoverage→TableIndent→
* NumberingSuffix→Hidden→Ruby значим: Strict первым — дальше transitional-байт; * NumberingSuffix→Hidden→Ruby значим: Strict первым — дальше transitional-байт;
* GlyphCoverage — по финальному тексту рана; Hidden — вырезает скрытые * GlyphCoverage — по финальному тексту рана; Hidden — вырезает скрытые
* раны по финальному содержимому; Ruby — разворачивает руби-разметку, * раны по финальному содержимому; Ruby — разворачивает руби-разметку,
@@ -463,10 +469,11 @@ public final class WordPdfConverter {
*/ */
private static List<DocxNormalizer> normalizers(ConvertOptions options) { private static List<DocxNormalizer> normalizers(ConvertOptions options) {
return List.of( return List.of(
// один zip-проход: strict→transitional, on/off, Symbol-PUA, // один zip-проход: strict→transitional, on/off, невидимки,
// поля PAGE/NUMPAGES, невидимки, покрытие глифов, tblInd при // покрытие глифов, tblInd при jc≠left, suff=space, скрытый
// jc≠left, suff=space, скрытый текст (vanish) — порядок // текст (vanish) — порядок рерайтов внутри части фиксирован
// рерайтов внутри части фиксирован (DocxRewritePipeline) // (DocxRewritePipeline); символьные шрифты и complex-поля
// PAGE/NUMPAGES с docx4j 17.3.x обрабатывает сам экспорт
DocxRewritePipeline.STEP, DocxRewritePipeline.STEP,
// OLE-объекты: при выключенном errorOnOle тихо удаляем // OLE-объекты: при выключенном errorOnOle тихо удаляем
// (часть/rels/w:object), при включённом — DrawingFoundException // (часть/rels/w:object), при включённом — DrawingFoundException
@@ -15,21 +15,28 @@ import org.apache.commons.compress.utils.SeekableInMemoryByteChannel;
/** /**
* Единый zip-проход переписывания XML-частей (.docx) вместо отдельных * Единый zip-проход переписывания XML-частей (.docx) вместо отдельных
* проходов нормализаторов: к каждой записи {@code word/*.xml} применяются * проходов нормализаторов: к каждой записи {@code word/*.xml} применяются
* все десять рерайтов в фиксированном порядке * все восемь рерайтов в фиксированном порядке
* Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby. * Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby.
* Порядок значим: Strict первым — дальше части в transitional-виде * Порядок значим: Strict первым — дальше части в transitional-виде
* (TableIndent читает transitional-атрибуты {@code w:}); GlyphCoverage * (TableIndent читает transitional-атрибуты {@code w:}); GlyphCoverage
* режет раны по финальному тексту рана (после Symbol/Invisible); Hidden * режет раны по финальному тексту рана (после Invisible); Hidden
* последним — вырезает уже финальные раны (после Symbol/GLYPH-разбиений), * последним — вырезает уже финальные раны (после GLYPH-разбиений),
* а его OnOff-форма vanish читается после правила 2. Каждый * а его OnOff-форма vanish читается после правила 2. Каждый
* рерайт работает только содержимым одной части, поэтому по-частная * рерайт работает только содержимым одной части, поэтому по-частная
* цепочка эквивалентна последовательным полным проходам. Исключения из * цепочка эквивалентна последовательным полным проходам. Исключения из
* «по-частности» — контексты, читаемые один раз до цикла: правило 7 * «по-частности» — контексты, читаемые один раз до цикла: правило 5
* (TableIndent) — у header/footer-частей своей sectPr нет, ширина полосы * (TableIndent) — у header/footer-частей своей sectPr нет, ширина полосы
* передаётся из document.xml (многосекционный документ — полоса * передаётся из document.xml (многосекционный документ — полоса
* неоднозначна, header/footer пропускаются); правило 9 (Hidden) — * неоднозначна, header/footer пропускаются); правило 7 (Hidden) —
* стилевые vanish читаются из word/styles.xml (цепочка w:basedOn). * стилевые vanish читаются из word/styles.xml (цепочка w:basedOn).
* *
* <p>Правил 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.
*
* <p>Неизменённые записи (медиа, rels, прочее) переносятся raw-копией * <p>Неизменённые записи (медиа, rels, прочее) переносятся raw-копией
* сжатых байтов — без inflate/deflate; прочие (редкие методы сжатия, * сжатых байтов — без inflate/deflate; прочие (редкие методы сжатия,
* шифрованные) — обычный перенос. Ни одна часть не изменилась → * шифрованные) — обычный перенос. Ни одна часть не изменилась →
@@ -52,7 +59,7 @@ public final class DocxRewritePipeline {
public static final DocxNormalizer STEP = DocxRewritePipeline::normalize; public static final DocxNormalizer STEP = DocxRewritePipeline::normalize;
/** /**
* Применяет десять рерайтов к каждой записи {@code word/*.xml} за один * Применяет восемь рерайтов к каждой записи {@code word/*.xml} за один
* проход zip. * проход zip.
* *
* @param docx байты .docx (валидный zip) * @param docx байты .docx (валидный zip)
@@ -63,7 +70,7 @@ public final class DocxRewritePipeline {
boolean changed = false; boolean changed = false;
try (ZipFile zf = new ZipFile(new SeekableInMemoryByteChannel(docx)); try (ZipFile zf = new ZipFile(new SeekableInMemoryByteChannel(docx));
ZipArchiveOutputStream zos = new ZipArchiveOutputStream(out)) { ZipArchiveOutputStream zos = new ZipArchiveOutputStream(out)) {
// Ширина полосы набора для правила 7 (таблицы в header/footer- // Ширина полосы набора для правила 5 (таблицы в header/footer-
// частях своей sectPr не содержат): из сырого document.xml — // частях своей sectPr не содержат): из сырого document.xml —
// геометрия инвариантна к рерайтам цепочки (Strict не трогает // геометрия инвариантна к рерайтам цепочки (Strict не трогает
// w:pgSz/@w:w, а pgMar-чередование left|start покрывает strict). // w:pgSz/@w:w, а pgMar-чередование left|start покрывает strict).
@@ -76,7 +83,7 @@ public final class DocxRewritePipeline {
new String(zf.getInputStream(docEntry).readAllBytes(), new String(zf.getInputStream(docEntry).readAllBytes(),
StandardCharsets.UTF_8)); StandardCharsets.UTF_8));
} }
// Стилевые vanish для правила 9 (скрытый текст): часть стилевой // Стилевые vanish для правила 7 (скрытый текст): часть стилевой
// цепочки w:basedOn вычисляется один раз до цикла. Записи нет → // цепочки w:basedOn вычисляется один раз до цикла. Записи нет →
// пустое множество, рерайт работает по прямому vanish. // пустое множество, рерайт работает по прямому vanish.
Set<String> hiddenStyles = Set.of(); Set<String> hiddenStyles = Set.of();
@@ -101,14 +108,6 @@ public final class DocxRewritePipeline {
if (next != null) { if (next != null) {
cur = next; cur = next;
} }
next = SymbolFontNormalizer.rewrite(cur);
if (next != null) {
cur = next;
}
next = FieldNormalizer.rewrite(cur);
if (next != null) {
cur = next;
}
next = InvisibleCharNormalizer.rewrite(cur); next = InvisibleCharNormalizer.rewrite(cur);
if (next != null) { if (next != null) {
cur = next; cur = next;
@@ -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 = "</w:r>";
/**
* Результат поля: ран-маркер {@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("<w:instrText", pos);
if (open < 0) {
break;
}
int gt = block.indexOf('>', open);
int close = block.indexOf("</w:instrText>", gt);
if (gt < 0 || close < 0) {
break;
}
instr.append(unescape(block.substring(gt + 1, close)));
pos = close + "</w:instrText>".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 "<w:fldSimple w:instr=\"" + escapeAttr(instr) + "\">"
+ cached + "</w:fldSimple>";
}
/** Начало рана, содержащего позицию {@code idx} (раны не вложены). */
private static int runStart(String xml, int idx) {
for (int i = xml.lastIndexOf("<w:r", idx); i >= 0; i = xml.lastIndexOf("<w:r", i - 1)) {
if (i + 4 >= 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 </w:r>} рана, содержащего {@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("&", "&amp;")
.replace("<", "&lt;")
.replace(">", "&gt;")
.replace("\"", "&quot;");
}
private static String unescape(String value) {
String v = value;
if (v.indexOf('&') < 0) {
return v;
}
v = v.replace("&lt;", "<").replace("&gt;", ">").replace("&quot;", "\"");
return v.replace("&amp;", "&");
}
}
@@ -52,7 +52,8 @@ import java.util.concurrent.ConcurrentHashMap;
* честнее оставить, чем подменять случайным шрифтом.</li> * честнее оставить, чем подменять случайным шрифтом.</li>
* </ul> * </ul>
* *
* Как и {@link SymbolFontNormalizer}, правим байты zip до JAXB-разбора. * Как и прочие рерайты {@link DocxRewritePipeline}, правим байты zip до
* JAXB-разбора.
*/ */
final class GlyphCoverageNormalizer { final class GlyphCoverageNormalizer {
@@ -128,8 +129,7 @@ final class GlyphCoverageNormalizer {
* Проходит блоки {@code <w:r>} ... {@code </w:r>} и заменяет каждый через * Проходит блоки {@code <w:r>} ... {@code </w:r>} и заменяет каждый через
* {@link #rewriteBlock}. Вложенные раны текстбоксов (w:r → w:drawing → * {@link #rewriteBlock}. Вложенные раны текстбоксов (w:r → w:drawing →
* txbxContent → w:r) переписываются рекурсивно по телу внешнего блока — * txbxContent → w:r) переписываются рекурсивно по телу внешнего блока —
* каркас внешнего рана остаётся нетронутым. Приём общий с * каркас внешнего рана остаётся нетронутым.
* {@link SymbolFontNormalizer}.
*/ */
private static String rewriteBlocks(String xml, String tag) { private static String rewriteBlocks(String xml, String tag) {
String open = "<" + tag; String open = "<" + tag;
@@ -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 <w:lvlText w:val="&#xF0A7;"/>} + {@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).
*
* Обрабатываются оба места, где встречается символный шрифт:
* <ul>
* <li>{@code w:lvl} (numbering.xml): {@code w:lvlText/@w:val} +
* {@code w:lvl/w:rPr/w:rFonts} — маркеры списков;</li>
* <li>{@code w:r}: текст в {@code w:t} и элементы {@code w:sym}
* ({@code w:sym} имеет собственный {@code w:font}, поэтому ран с ним
* разрезается на части — иначе соседнему тексту поменялся бы шрифт).</li>
* </ul>
*
* Как и {@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<String, String> 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(
"<w:sym\\b[^>]*?/>");
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("<w:sym") < 0) {
return null;
}
String result = rewriteBlocks(xml, "w:lvl");
result = rewriteBlocks(result, "w:r");
return result.equals(xml) ? null : result;
}
/**
* Проходит блоки {@code <tag ...>} ... {@code </tag>} и заменяет каждый через
* {@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;
}
// самозакрывающийся <w:r ... /> — блока нет
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("<w:sym") >= 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("<w:rFonts");
if (rFonts < 0) {
return null;
}
int end = 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("</w:r>")) {
return block;
}
int tagEnd = block.indexOf('>');
String openTag = block.substring(0, tagEnd + 1);
String body = block.substring(tagEnd + 1, block.length() - "</w:r>".length());
String rPr = "";
if (body.startsWith("<w:rPr>")) {
int rPrEnd = body.indexOf("</w:rPr>");
if (rPrEnd < 0) {
return block;
}
rPr = body.substring(0, rPrEnd + "</w:rPr>".length());
body = body.substring(rPrEnd + "</w:rPr>".length());
}
String fallbackRPr = rPr.isEmpty()
? "<w:rPr><w:rFonts w:ascii=\"" + REPLACEMENT_FAMILY
+ "\" w:hAnsi=\"" + REPLACEMENT_FAMILY + "\"/></w:rPr>"
: 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("</w:r>");
}
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("<w:t xml:space=\"preserve\">").append(mapped)
.append("</w:t></w:r>");
}
pos = m.end();
}
if (pos == 0) {
return block;
}
String tail = body.substring(pos);
if (!tail.isEmpty()) {
sb.append(openTag).append(rPr).append(tail).append("</w:r>");
}
return sb.toString();
}
/**
* Принудительно ставит семейство в {@code w:rPr}: заменяет значения
* атрибутов {@code w:rFonts}, а если {@code w:rFonts} нет — вставляет
* его первым ребёнком (так делает Word).
*/
private static String forceFont(String rPr, String family) {
if (rPr.indexOf("<w:rFonts") < 0) {
return rPr.replaceFirst("<w:rPr>", "<w:rPr><w:rFonts w:ascii=\"" + family
+ "\" w:hAnsi=\"" + family + "\" w:cs=\"" + family + "\"/>");
}
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<String, String> buildMaps() {
Map<String, String> 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";
}
@@ -401,7 +401,10 @@
<xsl:apply-templates/> <xsl:apply-templates/>
</xsl:variable> </xsl:variable>
<xsl:variable name="pPrNode" select="../w:pPr" /> <!-- the run's own paragraph, also for a run in a w:hyperlink, w:smartTag, w:ins or an
inline sdt (until 17.3.3 ../w:pPr, which found none there, so such a run was
resolved without its paragraph style) -->
<xsl:variable name="pPrNode" select="ancestor::w:p[1]/w:pPr" />
<xsl:variable name="rPrNode" select="w:rPr" /> <xsl:variable name="rPrNode" select="w:rPr" />
<!-- AUDIT-FIX position: docx4j createBlockForRPr игнорирует <!-- AUDIT-FIX position: docx4j createBlockForRPr игнорирует
@@ -523,9 +526,11 @@
<xsl:when test="starts-with(./w:sdtPr/w:tag/@w:val, 'XSLT_Cols')"> <xsl:when test="starts-with(./w:sdtPr/w:tag/@w:val, 'XSLT_Cols')">
<!-- a part of a merged page-sequence with fewer columns than the sequence <!-- a part of a merged page-sequence with fewer columns than the sequence
(ConversionSectionWrapperFactory): a block spanning them all --> (ConversionSectionWrapperFactory): a block spanning them all -->
<fo:block span="all"> <xsl:variable name="childResults">
<xsl:apply-templates select="w:sdtContent/*"/> <xsl:apply-templates select="w:sdtContent/*"/>
</fo:block> </xsl:variable>
<xsl:copy-of select="java:org.docx4j.convert.out.fo.XsltFOFunctions.spanAllBlock(
string(./w:sdtPr/w:tag/@w:val), $childResults)"/>
</xsl:when> </xsl:when>
<xsl:when test="starts-with(./w:sdtPr/w:tag/@w:val, 'XSLT_Ind')"> <xsl:when test="starts-with(./w:sdtPr/w:tag/@w:val, 'XSLT_Ind')">
<!-- a part of a merged page-sequence with other page margins <!-- a part of a merged page-sequence with other page margins
@@ -626,6 +631,12 @@
<xsl:copy-of select="java:org.docx4j.convert.out.fo.XsltFOFunctions.createShapeTextBox( <xsl:copy-of select="java:org.docx4j.convert.out.fo.XsltFOFunctions.createShapeTextBox(
$conversionContext, $wpinline, $childResults)" /> $conversionContext, $wpinline, $childResults)" />
</xsl:when> </xsl:when>
<xsl:when test="./a:graphic/a:graphicData[@uri='http://schemas.openxmlformats.org/drawingml/2006/chart' or @uri='http://schemas.microsoft.com/office/drawing/2014/chartex']">
<!-- a chart: its box, a space of the drawing's extent, holding the chart drawn
where docx4j-chart-render draws it (17.3.3, CR-035, CR-037) -->
<xsl:copy-of select="java:org.docx4j.model.chart.ChartBox.createXslFo(
$conversionContext, $wpinline)" />
</xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:copy-of <xsl:copy-of
@@ -833,6 +844,14 @@
</xsl:if> </xsl:if>
<xsl:choose> <xsl:choose>
<xsl:when test="ancestor::w:footnote and not(@w:type='page') and not(@w:type='column')">
<!-- in a footnote the block-in-inline idiom below is forbidden (XSL 1.1 6.6.7: an fo:inline
descending from fo:footnote may not have block-level children; FOP throws a
ValidationException and the whole export is lost, measured on a manual whose
footnote held two URLs on a w:br); U+2028 LINE SEPARATOR is an explicit break
for FOP's line breaker (CharUtilities.isExplicitBreak), no glyph drawn -->
<xsl:text>&#x2028;</xsl:text>
</xsl:when>
<xsl:when test="$predecessor='br' and not(@w:type='page') and not(@w:type='column')"> <xsl:when test="$predecessor='br' and not(@w:type='page') and not(@w:type='column')">
<!-- special case; see discussion in BrWriter --> <!-- special case; see discussion in BrWriter -->
<fo:block white-space-treatment="preserve" linefeed-treatment="preserve"><xsl:text> <!-- one carriage return --> <fo:block white-space-treatment="preserve" linefeed-treatment="preserve"><xsl:text> <!-- one carriage return -->
@@ -867,7 +886,15 @@
</xsl:template> </xsl:template>
<xsl:template match="w:cr"> <xsl:template match="w:cr">
<fo:block white-space-treatment="preserve"> </fo:block> <xsl:choose>
<xsl:when test="ancestor::w:footnote">
<!-- as w:br above: no block inside a footnote's inline -->
<xsl:text>&#x2028;</xsl:text>
</xsl:when>
<xsl:otherwise>
<fo:block white-space-treatment="preserve"> </fo:block>
</xsl:otherwise>
</xsl:choose>
</xsl:template> </xsl:template>
<!-- <w:sym w:font="Wingdings" w:char="F04A"/> --> <!-- <w:sym w:font="Wingdings" w:char="F04A"/> -->
@@ -1116,7 +1143,8 @@
AbstractVisitorExporterGenerator.walkJAXBElements. @since 17.1.0 --> AbstractVisitorExporterGenerator.walkJAXBElements. @since 17.1.0 -->
<xsl:template match="mc:AlternateContent" > <xsl:template match="mc:AlternateContent" >
<xsl:variable name="preferred" <xsl:variable name="preferred"
select="mc:Choice[java:org.docx4j.utils.XSLTUtils.mcPrefersChoice(string(@Requires))][1]"/> select="mc:Choice[java:org.docx4j.utils.XSLTUtils.mcPrefersChoice(string(@Requires))
or java:org.docx4j.utils.XSLTUtils.mcSelectsChoice($conversionContext, .)][1]"/>
<xsl:choose> <xsl:choose>
<xsl:when test="$preferred"> <xsl:when test="$preferred">
<xsl:variable name="info" <xsl:variable name="info"
@@ -211,8 +211,8 @@ public final class SampleDocxGenerator {
/** /**
* Маркеры списков из символьных шрифтов: {@code w:lvlText} кодами из * Маркеры списков из символьных шрифтов: {@code w:lvlText} кодами из
* PUA (U+F0xx) + {@code w:rFonts} = Symbol/Wingdings, символьный шрифт * PUA (U+F0xx) + {@code w:rFonts} = Symbol/Wingdings, символьный шрифт
* прямо в ране и отдельный {@code w:sym}. Без SymbolFontNormalizer все * прямо в ране и отдельный {@code w:sym}. Без Unicode-маппинга (его с
* они превращаются в «#». * docx4j 17.3.3/#701 делает сам экспорт) все они превращаются в «#».
*/ */
private static void symbolBullets(Path out) throws Exception { private static void symbolBullets(Path out) throws Exception {
try (XWPFDocument doc = new XWPFDocument()) { try (XWPFDocument doc = new XWPFDocument()) {
@@ -268,8 +268,9 @@ public final class SampleDocxGenerator {
/** /**
* Нумерация страниц: {@code PAGE} в колонтитуле — сложным полем * Нумерация страниц: {@code PAGE} в колонтитуле — сложным полем
* ({@code fldChar} + {@code instrText} + кэш), как его пишет Word. * ({@code fldChar} + {@code instrText} + кэш), как его пишет Word.
* Экспорт docx4j в FO {@code instrText} в таком поле игнорирует и печатает * С docx4j 17.3.5 (CR-067) {@code FieldsCombiner} сворачивает такое поле
* кэш, поэтому без FieldNormalizers все страницы получают одно число. * в {@code w:fldSimple}; без этого все страницы получили бы одно число
* из кэша.
*/ */
private static void pageNumbers(Path out) throws Exception { private static void pageNumbers(Path out) throws Exception {
try (XWPFDocument doc = new XWPFDocument()) { try (XWPFDocument doc = new XWPFDocument()) {
@@ -372,9 +372,10 @@ class WordPdfConverterTest {
/** /**
* Маркеры списков из символьных шрифтов (Symbol/Wingdings, коды из * Маркеры списков из символьных шрифтов (Symbol/Wingdings, коды из
* PUA U+F0xx) экспорт в FO не понимает и рисует .notdef — решётку «#». * PUA U+F0xx) исторически рисовались .notdef — решёткой «#»; их
* SymbolFontNormalizer заменяет их Unicode-эквивалентами, поэтому * Unicode-маппинг делал SymbolFontNormalizer. С docx4j 17.3.3 (#701)
* маркеры остаются маркерами. * маркеры маппит сам экспорт в FO — правило удалено, тест пинит
* отсутствие регрессии на апстримном поведении.
*/ */
@Test @Test
void symbolFonts_bulletsAreNotHash() throws Exception { void symbolFonts_bulletsAreNotHash() throws Exception {
@@ -428,10 +429,11 @@ class WordPdfConverterTest {
/** /**
* Поля PAGE/NUMPAGES Word пишет как {@code fldChar} + {@code instrText} * Поля PAGE/NUMPAGES Word пишет как {@code fldChar} + {@code instrText}
* + закэшированный результат. Экспорт docx4j в FO инструкцию игнорирует * + закэшированный результат; docx4j 11.x печатал кэш — все страницы
* и печатает кэш — все страницы получают одно и то же число. * получали одно число, его разворачивал FieldNormalizer. С docx4j 17.3.5
* FieldNormalizer разворачивает поле в {@code w:fldSimple}, и FOP * (CR-067) {@code FieldsCombiner} сворачивает complex-поля в
* считает номер заново на каждой странице. * {@code w:fldSimple} и внутри {@code w:sdt}, FOP считает номер заново
* на каждой странице — правило удалено, тест пинит апстримное поведение.
*/ */
@Test @Test
void pageNumbers_recomputedNotCached() throws Exception { void pageNumbers_recomputedNotCached() throws Exception {
@@ -1442,8 +1444,8 @@ class WordPdfConverterTest {
* Синтетический .doc со списками (ни одна фикстура заказчика списков не * Синтетический .doc со списками (ни одна фикстура заказчика списков не
* содержит — крафт POIFS, дубль хелперов DocToDocxFormattingTest): * содержит — крафт POIFS, дубль хелперов DocToDocxFormattingTest):
* PlfLst/PlfLfo → numbering.xml + w:numPr — decimal «1.»/«2.», буквенный * PlfLst/PlfLfo → numbering.xml + w:numPr — decimal «1.»/«2.», буквенный
* подуровень «a)»/«b)», Symbol-буллет (PUA в w:lvl чинит * подуровень «a)»/«b)», Symbol-буллет (PUA в w:lvl маппит экспорт
* SymbolFontNormalizer — та же цепочка, что symbol-bullets.docx). * docx4j 17.3.x — та же цепочка, что symbol-bullets.docx).
* Регрессия — internal.doc.Lists + DocxBody#numPrXml. * Регрессия — internal.doc.Lists + DocxBody#numPrXml.
*/ */
@Test @Test
@@ -2344,7 +2346,7 @@ class WordPdfConverterTest {
} }
/** /**
* Скрытый текст не выводится: правило 9 (HiddenTextNormalizer) вырезает * Скрытый текст не выводится: правило 7 (HiddenTextNormalizer) вырезает
* раны с прямым truthy vanish и с rStyle на vanish-стиль; falsy vanish * раны с прямым truthy vanish и с rStyle на vanish-стиль; falsy vanish
* остаётся. Word при печати/PDF-export скрытое не печатает. * остаётся. Word при печати/PDF-export скрытое не печатает.
* Регрессия — аудит ECMA-376 2026-11 (Part 1 §17.3.2.30). * Регрессия — аудит ECMA-376 2026-11 (Part 1 §17.3.2.30).
@@ -2369,7 +2371,7 @@ class WordPdfConverterTest {
} }
/** /**
* База руби печатается (правило 10, RubyNormalizer): схема docx4j не * База руби печатается (правило 8, RubyNormalizer): схема docx4j не
* биндит {@code w:rubyBase}/{@code w:rt} — unmarshaller терял их до * биндит {@code w:rubyBase}/{@code w:rt} — unmarshaller терял их до
* XSLT. Надстрочница удаляется (принятая деградация, §17.3.3.19/.20 — * XSLT. Надстрочница удаляется (принятая деградация, §17.3.3.19/.20 —
* ruby-разметки в FOP нет) и пинится негативом. * ruby-разметки в FOP нет) и пинится негативом.
@@ -1,233 +0,0 @@
package ru.pjandro.wordpdf.internal;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
class FieldNormalizerTest {
/** Сложное поле Word: begin / instrText / separate / кэш / end. */
private static String field(String instr, String cached) {
return "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText xml:space=\"preserve\">" + instr
+ "</w:instrText></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>"
+ "<w:r><w:rPr><w:sz w:val=\"20\"/></w:rPr><w:t>" + cached + "</w:t></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>";
}
@Test
void pageFieldBecomesFldSimple() {
String xml = "<w:p>" + field(" PAGE \\* MERGEFORMAT ", "2") + "</w:p>";
String out = FieldNormalizer.rewrite(xml);
assertTrue(out.startsWith("<w:p><w:fldSimple w:instr=\" PAGE \\* MERGEFORMAT \">"),
out);
// кэш остаётся внутри — он даёт оформление (шрифт, размер)
assertTrue(out.contains("<w:rPr><w:sz w:val=\"20\"/></w:rPr><w:t>2</w:t>"), out);
assertTrue(out.endsWith("</w:fldSimple></w:p>"), out);
assertTrue(!out.contains("fldChar"), "fldChar не удалён: " + out);
}
@Test
void numpagesAndSectionpagesAreSupported() {
for (String instr : new String[]{" NUMPAGES \\* ARABIC ", " SECTIONPAGES "}) {
String out = FieldNormalizer.rewrite("<w:p>" + field(instr, "11") + "</w:p>");
assertTrue(out.contains("<w:fldSimple w:instr=\"" + instr + "\">"), instr + ": " + out);
}
}
/** Инструкцию Word дробит на несколько w:instrText — их нужно склеить. */
@Test
void instructionSplitAcrossRuns() {
String xml = "<w:p><w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText xml:space=\"preserve\"> NUM</w:instrText></w:r>"
+ "<w:r><w:instrText xml:space=\"preserve\">PAGES </w:instrText></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>"
+ "<w:r><w:t>11</w:t></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r></w:p>";
String out = FieldNormalizer.rewrite(xml);
assertTrue(out.contains("<w:fldSimple w:instr=\" NUMPAGES \">"), out);
}
@Test
void otherFieldsUntouched() {
String xml = "<w:p>" + field(" HYPERLINK \"https://example.com\" ", "ссылка")
+ "</w:p>";
assertNull(FieldNormalizer.rewrite(xml), "чужое поле переписано");
}
/** Вложенное поле: разбирать его не берёмся, но и ломать не должны. */
@Test
void nestedFieldUntouched() {
String xml = "<w:p>"
+ "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText>= PAGE </w:instrText></w:r>"
+ field(" PAGE ", "2")
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r></w:p>";
assertNull(FieldNormalizer.rewrite(xml), "вложенное поле переписано");
}
/** Соседние ран-свойства и остальной документ остаются без изменений. */
@Test
void surroundingContentPreserved() {
String xml = "<w:hdr><w:p><w:pPr><w:jc w:val=\"center\"/></w:pPr>"
+ "<w:r><w:t>до</w:t></w:r>" + field(" PAGE ", "2")
+ "<w:r><w:t>после</w:t></w:r></w:p></w:hdr>";
String out = FieldNormalizer.rewrite(xml);
assertTrue(out.startsWith("<w:hdr><w:p><w:pPr><w:jc w:val=\"center\"/></w:pPr>"
+ "<w:r><w:t>до</w:t></w:r>"), out);
assertTrue(out.endsWith("<w:r><w:t>после</w:t></w:r></w:p></w:hdr>"), out);
}
/** Поле внутри w:sdt — так Word пишет нумерацию «Page Numbers (Top of Page)». */
@Test
void fieldInsideSdt() {
String xml = "<w:sdt><w:sdtPr/><w:sdtEndPr/><w:sdtContent>"
+ field(" PAGE ", "2") + "</w:sdtContent></w:sdt>";
String out = FieldNormalizer.rewrite(xml);
assertTrue(out.startsWith("<w:sdt><w:sdtPr/><w:sdtEndPr/><w:sdtContent>"
+ "<w:fldSimple"), out);
assertTrue(out.endsWith("</w:fldSimple></w:sdtContent></w:sdt>"), out);
}
@Test
void nothingToChangeReturnsNull() {
assertNull(FieldNormalizer.rewrite("<w:p><w:r><w:t>текст</w:t></w:r></w:p>"));
}
/** Поле без separate/end — битое, пропускаем, остальное не трогаем. */
@Test
void unterminatedFieldSkipped() {
String xml = "<w:p><w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText> PAGE </w:instrText></w:r></w:p>";
assertNull(FieldNormalizer.rewrite(xml));
}
/** Кавычка и ampersand в инструкции не должны сломать атрибут. */
@Test
void instructionEscapedIntoAttribute() {
String out = FieldNormalizer.rewrite(
"<w:p>" + field(" STYLEREF \"Раздел &amp; номер\" ", "1") + "</w:p>");
// STYLEREF не поддерживается — поле должно остаться как было
assertNull(out);
String page = FieldNormalizer.rewrite(
"<w:p>" + field(" PAGE ", "1") + "</w:p>");
assertEquals("<w:p><w:fldSimple w:instr=\" PAGE \">"
+ "<w:r><w:rPr><w:sz w:val=\"20\"/></w:rPr><w:t>1</w:t></w:r>"
+ "</w:fldSimple></w:p>", page);
}
/** Маркер begin без единого <w:r> до него — поле-контейнер не найти, пропускаем. */
@Test
void beginWithoutAnyRun_skipped() {
assertNull(FieldNormalizer.rewrite("fldCharType=\"begin\""));
}
/** begin после закрытого рана: ран-контейнер не найден — пропускаем. */
@Test
void beginOutsideRun_skipped() {
assertNull(FieldNormalizer.rewrite(
"<w:r><w:t>до</w:t></w:r>fldCharType=\"begin\""));
}
/** Ран с begin не закрыт — битое поле, пропускаем. */
@Test
void beginRunUnclosed_skipped() {
assertNull(FieldNormalizer.rewrite(
"<w:r><w:fldChar w:fldCharType=\"begin\""));
}
/** Поле без instrText: инструкция пуста — не поддерживаем, оставляем как есть. */
@Test
void fieldWithoutInstruction_skipped() {
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>";
assertNull(FieldNormalizer.rewrite(xml));
}
/** PAGE без separate: кэша нет — fldSimple пустой, число нарисует обработчик. */
@Test
void fieldWithoutSeparate_emptyFldSimple() {
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>";
assertEquals("<w:fldSimple w:instr=\" PAGE \"></w:fldSimple>",
FieldNormalizer.rewrite(xml));
}
/** separate другого поля после end: кэшем этого поля оно быть не может. */
@Test
void separateAfterFieldEnd_notCapturedAsCache() {
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>";
String out = FieldNormalizer.rewrite(xml);
assertTrue(out.startsWith("<w:fldSimple w:instr=\" PAGE \"></w:fldSimple>"), out);
assertTrue(out.endsWith("<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>"), out);
}
/** end вне рана: начало его рана не найти — кэш не берём, поле переписываем пустым. */
@Test
void endMarkerOutsideRun_noCacheCaptured() {
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>"
+ "<w:r><w:t>2</w:t></w:r>"
+ "fldCharType=\"end\""
+ "<w:r><w:t>после</w:t></w:r>";
assertEquals("<w:fldSimple w:instr=\" PAGE \"></w:fldSimple>",
FieldNormalizer.rewrite(xml));
}
/** separate и end в одном ране: «кэш» лежал бы раньше маркера — не берём. */
@Test
void separateAndEndInOneRun_noCacheCaptured() {
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"separate\"/>"
+ "<w:fldChar w:fldCharType=\"end\"/></w:r>";
assertEquals("<w:fldSimple w:instr=\" PAGE \"></w:fldSimple>",
FieldNormalizer.rewrite(xml));
}
/** instrText без закрывающего тега: инструкцию не собрать — поле остаётся. */
@Test
void unclosedInstrText_fieldSkipped() {
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText> PAGE </w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>";
assertNull(FieldNormalizer.rewrite(xml));
}
/** Ран с атрибутами (<w:r w:rsidR=...>) — корректное открытие рана, поле переписывается. */
@Test
void runWithAttributes_fieldRewritten() {
String xml = "<w:r w:rsidR=\"001E\"><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>"
+ "<w:r><w:t>2</w:t></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>";
String out = FieldNormalizer.rewrite(xml);
assertTrue(out.startsWith("<w:fldSimple w:instr=\" PAGE \">"), out);
assertTrue(out.contains("<w:r><w:t>2</w:t></w:r>"), "кэш потерян: " + out);
}
/** Ран с end не закрыт — поле битое, пропускаем. */
@Test
void endRunUnclosed_fieldSkipped() {
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
+ "<w:r><w:fldChar w:fldCharType=\"end\"";
assertNull(FieldNormalizer.rewrite(xml));
}
}
@@ -17,7 +17,7 @@ import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
/** /**
* Юниты правила 10: разворот {@code w:rubyBase}/{@code w:rubyBaseText}, * Юниты правила 8: разворот {@code w:rubyBase}/{@code w:rubyBaseText},
* вырезание {@code w:rt}/{@code w:rubyPr}/{@code w:rubyAlign} * вырезание {@code w:rt}/{@code w:rubyPr}/{@code w:rubyAlign}
* (Part 1 §17.3.3.18/.19/.20/.21). * (Part 1 §17.3.3.18/.19/.20/.21).
*/ */
@@ -1,342 +0,0 @@
package ru.pjandro.wordpdf.internal;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import static org.junit.jupiter.api.Assertions.*;
/**
* Замена символьных шрифтов Symbol/Wingdings на Unicode + бандл-шрифт
* (см. SymbolFontNormalizer). Коды берутся из SymbolMapper docx4j 17.x и
* сверяются с экспортом Word (develop/, вне git).
*/
class SymbolFontNormalizerTest {
/** Маркеры списков: Wingdings F0A7 -> ▪, Symbol F0B7 -> •, F02D -> −. */
private static final String NUMBERING_XML =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+ "<w:numbering xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">"
+ "<w:abstractNum w:abstractNumId=\"1\">"
+ "<w:lvl w:ilvl=\"0\"><w:numFmt w:val=\"bullet\"/>"
+ "<w:lvlText w:val=\"\uF0A7\"/>"
+ "<w:rPr><w:rFonts w:ascii=\"Wingdings\" w:hAnsi=\"Wingdings\" w:hint=\"default\"/></w:rPr></w:lvl>"
+ "<w:lvl w:ilvl=\"1\"><w:numFmt w:val=\"bullet\"/>"
+ "<w:lvlText w:val=\"\uF0B7\"/>"
+ "<w:rPr><w:rFonts w:ascii=\"Symbol\" w:hAnsi=\"Symbol\"/></w:rPr></w:lvl>"
+ "<w:lvl w:ilvl=\"2\"><w:numFmt w:val=\"bullet\"/>"
+ "<w:lvlText w:val=\"%1.\"/>"
+ "<w:rPr><w:rFonts w:ascii=\"Times New Roman\"/></w:rPr></w:lvl>"
+ "</w:abstractNum></w:numbering>";
/** Символьный шрифт в ране + w:sym с собственным w:font. */
private static final String DOCUMENT_XML =
"<w:document xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:body>"
+ "<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\" w:hAnsi=\"Symbol\"/></w:rPr>"
+ "<w:t>\uF0B7 хвостик</w:t></w:r>"
+ "<w:r><w:rPr><w:rFonts w:ascii=\"Times New Roman\"/><w:sz w:val=\"28\"/></w:rPr>"
+ "<w:t xml:space=\"preserve\">до </w:t><w:sym w:font=\"Symbol\" w:char=\"F0A9\"/>"
+ "<w:t xml:space=\"preserve\"> после</w:t></w:r>"
+ "<w:r><w:rPr><w:rFonts w:ascii=\"Times New Roman\"/></w:rPr>"
+ "<w:t>обычный текст</w:t></w:r>"
+ "</w:body></w:document>";
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("<w:document/>", NUMBERING_XML));
String numbering = readEntry(result, "word/numbering.xml");
assertTrue(numbering.contains("<w:lvlText w:val=\"▪\"/>"),
"Wingdings F0A7 не стал ▪: " + numbering);
assertTrue(numbering.contains("<w:lvlText w:val=\"•\"/>"),
"Symbol F0B7 не стал •: " + numbering);
assertTrue(numbering.contains("<w:lvlText w:val=\"%1.\"/>"),
"уровень без символьного шрифта изменён: " + 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("<w:t>• хвостик</w:t>"),
"PUA в ране не заменён: " + document);
assertFalse(document.contains("=\"Symbol\""),
"Symbol остался в w:rFonts: " + document);
assertTrue(document.contains("<w:t>обычный текст</w:t>"),
"чужой ран изменён: " + 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"), "w:sym не заменён: " + document);
assertTrue(document.contains("<w:t xml:space=\"preserve\">до </w:t>"),
"текст до w:sym потерян: " + document);
assertTrue(document.contains("<w:t xml:space=\"preserve\"> после</w:t>"),
"текст после 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("<w:document><w:t>обычный текст</w:t></w:document>", null);
assertSame(docx, SymbolFontNormalizer.normalize(docx));
}
/** Часть вне word/*.xml не трогаем (та же политика, что у DocxOnOffNormalizer). */
@Test
void nonWordPartsNotTouched() throws Exception {
byte[] result = SymbolFontNormalizer.normalize(makeDocx("<w:document/>", NUMBERING_XML));
assertEquals("\uF0A7", readEntry(result, "[Content_Types].xml"));
}
@Test
void rewriteWithoutMatchesIsNull() {
assertNull(SymbolFontNormalizer.rewrite("<w:document><w:t>текст</w:t></w:document>"));
assertNull(SymbolFontNormalizer.rewrite("<w:r><w:t>нет символных шрифтов</w:t></w:r>"));
}
/** Символьный шрифт без кодов из PUA и коды из PUA без шрифта — не трогаем. */
@Test
void fontWithoutPuaAndPuaWithoutFontUntouched() {
assertNull(SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:rFonts w:ascii=\"Wingdings\"/></w:rPr><w:t>текст</w:t></w:r>"));
assertNull(SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:rFonts w:ascii=\"Arial\"/></w:rPr><w:t>\uF0A7</w:t></w:r>"));
}
/**
* Ран внутри текстбокса (вложенный w:r): внутренний ран с Wingdings
* переписывается, каркас внешнего остаётся целым.
* Регрессия — SymbolFontNormalizerTest#nestedRunInTextBox_innerNormalized.
*/
@Test
void nestedRunInTextBox_innerNormalized() {
String xml = "<w:document><w:r><w:rPr><w:rFonts w:ascii=\"Calibri\"/></w:rPr>"
+ "<w:drawing><wp:inline><wp:txbx><w:txbxContent><w:p>"
+ "<w:r><w:rPr><w:rFonts w:ascii=\"Wingdings\"/></w:rPr><w:t>\uF0A7 хвостик</w:t></w:r>"
+ "</w:p></w:txbxContent></wp:txbx></wp:inline></w:drawing></w:r></w:document>";
String out = SymbolFontNormalizer.rewrite(xml);
assertNotNull(out, "внутренний ран не переписан");
assertTrue(out.contains("<w:t>▪ хвостик</w:t>"), "PUA не стал Unicode: " + out);
assertFalse(out.contains("Wingdings"), "имя шрифта не заменено: " + out);
assertTrue(out.contains("w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY + "\""),
"нет fallback-семейства: " + out);
assertTrue(out.contains("<w:r><w:rPr><w:rFonts w:ascii=\"Calibri\"/></w:rPr><w:drawing>"),
"каркас внешнего рана повреждён: " + out);
}
/** Нет кодов из PUA, но есть w:sym — быстрый путь не отсекает, символ заменяется. */
@Test
void symWithoutPuaStillRewritten() {
String out = SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr>"
+ "<w:t>a</w:t><w:sym w:char=\"F0A9\"/></w:r>");
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("<w:t>a</w:t>"), "текст до w:sym потерян: " + out);
}
/** Битые/незакрытые конструкции не правим (контракт: null = не трогать). */
@Test
void malformedRunsUntouched() {
// открывающий <w:r> есть, закрывающего нет
assertNull(SymbolFontNormalizer.rewrite("<w:r><w:t>\uF0B7</w:t>"));
// открывающий тег без '>'
assertNull(SymbolFontNormalizer.rewrite("<w:r \uF0B7"));
// префикс <w:r на самом конце строки
assertNull(SymbolFontNormalizer.rewrite("<w:t>\uF0B7</w:t><w:r"));
}
/** Граница имени тега — любой XML-разделитель, не только пробел. */
@Test
void runTagDelimiterVariantsAccepted() {
String out = SymbolFontNormalizer.rewrite(
"<w:r\t><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF0B7</w:t></w:r>"
+ "<w:r\n><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF0B7</w:t></w:r>"
+ "<w:r\r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF0B7</w:t></w:r>");
assertNotNull(out, "ран с табуляцией/переносом в теге пропущен");
assertTrue(out.contains("<w:t>•</w:t>"), "PUA не стал Unicode: " + out);
assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out);
}
/** Самозакрывающийся <w:r/> — не блок, поиск продолжается со следующего рана. */
@Test
void selfClosingRunSkipped() {
String out = SymbolFontNormalizer.rewrite(
"<w:r w:rsidR=\"0001\"/><w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr>"
+ "<w:t>\uF0B7</w:t></w:r>");
assertNotNull(out, "ран после <w:r/> не переписан");
assertTrue(out.contains("<w:r w:rsidR=\"0001\"/>"), "самозакрывающийся ран повреждён: " + out);
assertTrue(out.contains("<w:t>•</w:t>"), "PUA не стал Unicode: " + out);
}
/** Два открывающих, один закрывающий: блок берётся до единственного </w:r>. */
@Test
void unbalancedNestedRuns_blockUpToSoleClose() {
String out = SymbolFontNormalizer.rewrite(
"<w:r><w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr>"
+ "<w:t>\uF0B7</w:t></w:r>");
assertNotNull(out, "несбалансированный блок не переписан");
assertTrue(out.contains("<w:t>•</w:t>"), "PUA не стал Unicode: " + out);
assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out);
}
/** Хвост после единственного </w:r> без собственного рана — не трогаем. */
@Test
void danglingTailAfterCloseUntouched() {
assertNull(SymbolFontNormalizer.rewrite("<w:r><w:r></w:r>\uF0B7"));
}
/** Коды вне U+F000–U+F0FF — обычная часть символьного шрифта, не переписываются. */
@Test
void puaAboveBlockKept() {
assertNull(SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF100</w:t></w:r>"));
String out = SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF0B7\uF100</w:t></w:r>");
assertNotNull(out);
assertTrue(out.contains("•\uF100"), "F0B7/F100 обработаны неверно: " + out);
}
/** PUA-код без соответствия в таблице остаётся как был, шрифт всё равно меняется. */
@Test
void unmappedPuaSlotKeepsCode() {
String out = SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF000</w:t></w:r>");
assertNotNull(out);
assertTrue(out.contains("\uF000"), "код без маппинга потерян: " + out);
assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out);
}
/** w:sym в блоке w:lvl (не ран) — не разрезаем. */
@Test
void symInLevelBlockNotSplit() {
assertNull(SymbolFontNormalizer.rewrite(
"<w:lvl><w:sym w:font=\"Wingdings\" w:char=\"F0A7\"/></w:lvl>"));
}
/** Открытый <w:rPr> без </w:rPr> перед w:sym — битый ран не правим. */
@Test
void unclosedRPrBeforeSymUntouched() {
assertNull(SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:sym w:font=\"Symbol\" w:char=\"F0A9\"/></w:r>"));
}
/** w:sym без w:char / без w:font в ране без символьного шрифта / код вне PUA /
* слот без маппинга — элемент удаляется, соседний текст сохраняется. */
@Test
void unresolvableSymElementDropped() {
String noChar = SymbolFontNormalizer.rewrite(
"<w:r><w:t>a</w:t><w:sym w:font=\"Symbol\"/></w:r>");
assertNotNull(noChar);
assertFalse(noChar.contains("<w:sym"), "неразрешимый w:sym остался: " + noChar);
assertTrue(noChar.contains("<w:t>a</w:t>"), "текст потерян: " + noChar);
String noFontNoMap = SymbolFontNormalizer.rewrite(
"<w:r><w:t>a</w:t><w:sym w:char=\"F0A9\"/></w:r>");
assertNotNull(noFontNoMap);
assertFalse(noFontNoMap.contains("<w:sym"), "w:sym без шрифта остался: " + noFontNoMap);
String asciiChar = SymbolFontNormalizer.rewrite(
"<w:r><w:t>a</w:t><w:sym w:font=\"Symbol\" w:char=\"0041\"/></w:r>");
assertNotNull(asciiChar);
assertFalse(asciiChar.contains("<w:sym"), "w:sym с кодом вне PUA остался: " + asciiChar);
String unmappedChar = SymbolFontNormalizer.rewrite(
"<w:r><w:t>a</w:t><w:sym w:font=\"Symbol\" w:char=\"F000\"/></w:r>");
assertNotNull(unmappedChar);
assertFalse(unmappedChar.contains("<w:sym"), "w:sym без маппинга остался: " + unmappedChar);
}
/** w:sym не самозакрывающийся — под regex не попадает, ран не трогаем. */
@Test
void nonSelfClosingSymUntouched() {
assertNull(SymbolFontNormalizer.rewrite(
"<w:r><w:t>a</w:t><w:sym w:font=\"Symbol\" w:char=\"F0A9\"></w:sym></w:r>"));
}
/** rPr без w:rFonts: fallback-семейство вставляется первым ребёнком. */
@Test
void forceFontInsertsRFontsWhenAbsent() {
String out = SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:sz w:val=\"28\"/></w:rPr>"
+ "<w:sym w:font=\"Symbol\" w:char=\"F0A9\"/></w:r>");
assertNotNull(out);
assertTrue(out.contains("<w:rPr><w:rFonts w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY
+ "\" w:hAnsi=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY
+ "\" w:cs=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY
+ "\"/><w:sz w:val=\"28\"/></w:rPr>"),
"w:rFonts не вставлен в rPr: " + out);
assertTrue(out.contains("♥"), "символ потерян: " + out);
}
/** В обработанном блоке несимвольные имена шрифтов остаются как были. */
@Test
void nonSymbolFontAttrKept() {
String out = SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\" w:eastAsia=\"Arial\"/></w:rPr>"
+ "<w:t>\uF0B7</w:t></w:r>");
assertNotNull(out);
assertTrue(out.contains("w:eastAsia=\"Arial\""), "несимвольный шрифт изменён: " + out);
assertTrue(out.contains("w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY + "\""),
"символьный шрифт не заменён: " + out);
assertTrue(out.contains("<w:t>•</w:t>"), "PUA не стал Unicode: " + out);
}
}
@@ -156,7 +156,7 @@ class ListsTest {
assertTrue(xml.contains("<w:suff w:val=\"space\"/>"), xml); assertTrue(xml.contains("<w:suff w:val=\"space\"/>"), xml);
assertTrue(xml.contains("<w:rFonts w:ascii=\"Symbol\" w:hAnsi=\"Symbol\"/>"), xml); assertTrue(xml.contains("<w:rFonts w:ascii=\"Symbol\" w:hAnsi=\"Symbol\"/>"), xml);
assertTrue(xml.contains("<w:lvlText w:val=\"\uF0B7\"/>"), assertTrue(xml.contains("<w:lvlText w:val=\"\uF0B7\"/>"),
"PUA-символ дословно (чинит SymbolFontNormalizer): " + xml); "PUA-символ дословно (маппит экспорт docx4j 17.3.x): " + xml);
} }
@Test @Test