diff --git a/AGENTS.md b/AGENTS.md index 92cd5f5..36eb835 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -25,15 +25,19 @@ ## Шрифты (важно при изменениях) -- 28 TTF в `wordpdf-core/src/main/resources/fonts/` — бинарные фикстуры, часть jar; не удалять/переименовывать без обновления маппинга. +- 30 TTF в `wordpdf-core/src/main/resources/fonts/` — бинарные фикстуры, часть jar; не удалять/переименовывать без обновления маппинга. - Алиасы MS→open-source: Calibri→Carlito, Cambria→Caladea, Arial→Arimo, Times New Roman→Tinos, Courier New→Cousine; fallback — DejaVu Sans. +- Noto Naskh Arabic и Noto Sans Armenian (OFL, 278 КБ) добавлены ради глифов, которых нет больше ни в одном шрифте бандла (арабские дополнения U+07B1–U+08FF, армянские U+058D/U+058E). Регистрировать их в `BundledFontMapper` не требуется: `FontFallback.selectCovering` перебирает **весь** реестр `PhysicalFonts` и находит их сам — достаточно `BundledFonts.ENTRIES`. У них только regular-начертание (`BundledFonts.families()` это учитывает, `allFamiliesHaveAllVariants` их не проверяет). +- `FopFallbackFonts.declare` декларирует в FOP-конфиге **все** бандл-семейства, а не один fallback: FOP умеет встраивать только задекларированные, а `font-family` в FO может запросить любой из них. - `slf4j-simple` обязателен: без него docx4j печатает предупреждение прямо в выходной PDF (регрессионный тест `noLoggingWarningInPdf`). - Символы U+2000–U+2EFF (em-dash, кавычки, многоточие): `RunFontSelector.symbolBlockFont` оставляет шрифт ранa, если в нём есть этот глиф, и только иначе подставляет виртуальный «Segoe UI Symbol» (маппится на fallback DejaVu Sans, см. `BundledFontMapper`). Так же делает Word: в `references/word.pdf` em-dash нарисован Calibri/Times, DejaVu там нет вообще. Регрессия — `ruPlain_emDashEmbeddedNotHelvetica` (проверяет, что глиф рисует **вшитый** шрифт, а не базовый Helvetica). ## Архитектура (неочевидное) -- Пайплайн: байты docx → `DocxOnOffNormalizer` → `SymbolFontNormalizer` → `FieldNormalizer` → docx4j → XSL-FO (XSLT) → FOP → PDF. +- Пайплайн: байты docx → `DocxOnOffNormalizer` → `SymbolFontNormalizer` → `FieldNormalizer` → `GlyphCoverageNormalizer` → docx4j → XSL-FO (XSLT) → FOP → PDF. - Поля страниц: Word пишет `PAGE`/`NUMPAGES` сложным полем (`fldChar begin` → `instrText` → `separate` → кэш → `end`). Экспорт docx4j в FO `w:instrText` внутри такого поля игнорирует и печатает кэш docx — во всех колонтитулах одно число (в эталоне «2» вместо 1, 2, 3 …). `FieldNormalizer` разворачивает поле в `w:fldSimple` (его обрабатывает `FldSimpleWriter` из docx4j-export-fo: PAGE → `fo:page-number`, есть также NUMPAGES/SECTIONPAGES/PAGEREF), сохраняя внутри закэшированные ран — они дают шрифт/размер. Штатный `FieldsCombiner` docx4j делает то же, но не заходит внутрь `w:sdt`, а Word держит нумерацию именно в контентном контроле («Page Numbers (Top of Page)»). Трогаются только инструкции, для которых есть обработчик; вложенные поля пропускаются. Регрессия — `WordPdfConverterTest#pageNumbers_recomputedNotCached`, фикстура `samples/page-numbers.docx`. +- Покрытие глифов: знак без глифа в шрифте ранa FOP рисует `.notdef` («#»). Docx4j 17.x сам ищет покрывающий шрифт (`FontFallback.selectCovering` по реестру `PhysicalFonts`), но с двумя дырами: `needsCoverage` возвращает false для «латинской» группы (поэтому U+2150–U+218F — римские цифры и дроби — остаются на Tinos навсегда), а `RunFontSelector.fallbackByScript` кэширует фолбэк **на всю группу Юникода** (обычные армянские «ՊՌՋտ» покрываются DejaVu Serif, и найденный DejaVu Serif подставляется следующим за ними U+058D/U+058E). `GlyphCoverageNormalizer` (шаг 2.4, тоже байты до JAXB) режет ран по покрытию и пишет семейство в `w:rFonts` (имя — `BundledFontMapper.documentFontName`, обратное к `bundledFamily`). Покрытие меряется `java.awt.Font.canDisplay` через `BundledFonts.awtFont` (не `GlyphCheck` — тот логирует INFO на каждый отсутствующий глиф). Трогаются только раны с одним `w:t` и с явным `w:rFonts`; если знака нет ни в одном бандл-шрифте, ран не меняется. Регрессия — `WordPdfConverterTest#exoticGlyphs_drawnNotHash`, unit — `GlyphCoverageNormalizerTest`, фикстура `samples/exotic-glyphs.docx`. +- Известный остаток эталона: U+2188 (ↈ) и U+218A (↊) — есть только в GNU FreeSerif (GPL-3+ с Font Exception), которого в бандле нет намеренно (весь бандл — SIL OFL). В `references/word.pdf` на их месте у нас две решётки; ради них OFL не меняют. - Символьные шрифты: Word хранит маркеры списков и спецсимволы кодами из PUA (U+F0xx), глиф выбирается по имени шрифта (`Symbol`, `Wingdings`, `Webdings`). Экспорт docx4j в FO этих шрифтов не знает: код уходит в fallback, глифа нет, FOP рисует `.notdef` — в PDF решётка «#». `SymbolFontNormalizer` (шаг 1.6, тоже правит байты до JAXB) меняет код на Unicode, а имя шрифта — на `DejaVu Sans`. Таблица кодов — `SymbolMapper` из docx4j 17.x, отфильтрована по наличию глифа в DejaVu; константы сгенерированы, менять руками нельзя. Обрабатываются `w:lvl` (numbering.xml), `w:r` и `w:sym`; ран с `w:sym` разрезается, т.к. у символа собственный `w:font`. Регрессия — `WordPdfConverterTest#symbolFonts_bulletsAreNotHash`, фикстура `samples/symbol-bullets.docx`. - Порядок инициализации в `WordPdfConverter.convertToStream` важен: сначала `new BundledFontMapper()`, потом `BundledFonts.init()`, затем `BundledFonts.restrictToBundled()` (чистит реестр `PhysicalFonts` от системных шрифтов до `load()`; конструктор маппера каждый раз заново добавляет их). Не менять местами. - docx4j 17.x по-прежнему теряет атрибуты `w:val="off"/"on"` при JAXB-разборе — нормализация байтов до загрузки (`DocxOnOffNormalizer`) нужна и на 17.x (проверялось отключением: красный `ruPlain_regularRunsUseRegularFont`). diff --git a/README.md b/README.md index f78a003..e79d56e 100644 --- a/README.md +++ b/README.md @@ -71,8 +71,8 @@ WordPdfConverter.convert(Path.of("doc.docx"), Path.of("out.pdf")); // явный ## Шрифты -В `wordpdf-core/src/main/resources/fonts/` упакованы 28 TTF (по 4 начертания -на семейство): +В `wordpdf-core/src/main/resources/fonts/` упакованы 30 TTF: 7 текстовых +семейств по 4 начертания плюс два покрывающих шрифта (только regular): | Семейство | Аналог MS-шрифта | |---|---| @@ -82,11 +82,17 @@ WordPdfConverter.convert(Path.of("doc.docx"), Path.of("out.pdf")); // явный | Tinos | Times New Roman | | Cousine | Courier New | | DejaVu Sans / DejaVu Serif | fallback | +| Noto Naskh Arabic | арабские дополнения U+07B1–U+08FF | +| Noto Sans Armenian | армянские знаки Unicode 16 | `BundledFontMapper` подставляет метрически совместимые аналоги при конвертации (`Calibri → Carlito` и т.д.). Нераспознанные шрифты и символы, не найденные в шрифте ранa (em-dash «—», кавычки, U+2000–U+2EFF), падают в **DejaVu Sans** -(гарантированная кириллица). Все шрифты встраиваются в PDF как подмножества. +(гарантированная кириллица). Знак, которого нет ни в шрифте ранa, ни там, куда +его отправил docx4j, ищет себе место сам: `GlyphCoverageNormalizer` режет такой +ран и для каждой части назначает покрывающее семейство — serif-раны в +**DejaVu Serif**, sans — в **DejaVu Sans**, экзотика — в Noto. Все шрифты +встраиваются в PDF как подмножества. ### Лицензии шрифтов @@ -94,6 +100,8 @@ WordPdfConverter.convert(Path.of("doc.docx"), Path.of("out.pdf")); // явный (см. `fonts/FONT-LICENSE.txt`). - DejaVu Sans / DejaVu Serif — **SIL OFL 1.1 / Bitstream Vera** (см. `fonts/DejaVu-LICENSE.txt`). +- Noto Naskh Arabic, Noto Sans Armenian — **SIL OFL 1.1** + (см. `fonts/Noto-LICENSE.txt`). ## Как это работает @@ -107,7 +115,7 @@ docx ──> нормализация байтов ──> docx4j (Wordprocessin из-за чего regular-раны могли рендериться жирным курсивом), `SymbolFontNormalizer` (маркеры из Symbol/Wingdings вместо «#») и `FieldNormalizer` (поля `PAGE`/`NUMPAGES` пересчитываются, а не печатают - кэш из docx). + кэш из docx) и `GlyphCoverageNormalizer` (раны со знаками вне их шрифта). 2. Документ загружается в `WordprocessingMLPackage`, привязывается `BundledFontMapper`, диаграммы и SmartArt предварительно растеризуются в PNG (`DrawingPreRenderer`). @@ -120,6 +128,10 @@ docx ──> нормализация байтов ──> docx4j (Wordprocessin приближённые (ограничения FOP/docx4j, а не «мы что-то упустили»). - Символы U+2000–U+2EFF (em-dash и т.п.) берутся из шрифта ранa, если в нём есть глиф, иначе — из fallback-семейства DejaVu. +- Знаков, которых нет ни в одном шрифте бандла, это не касается: вместо них + остаётся `.notdef`. В эталонном `references/word.docx` таких два — U+2188 (ↈ) + и U+218A (↊), они есть только в GNU FreeSerif под GPL, а бандл держится + целиком на SIL OFL. - Поддержка таблиц/изображений — базовая (через docx4j/FOP). ## Тесты diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java index 89fdedb..6ee66db 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java @@ -13,6 +13,7 @@ import ru.pjandro.wordpdf.fonts.BundledFonts; import ru.pjandro.wordpdf.internal.chart.DrawingPreRenderer; import ru.pjandro.wordpdf.internal.DocxOnOffNormalizer; import ru.pjandro.wordpdf.internal.FieldNormalizer; +import ru.pjandro.wordpdf.internal.GlyphCoverageNormalizer; import ru.pjandro.wordpdf.internal.FopFallbackFonts; import ru.pjandro.wordpdf.internal.SymbolFontNormalizer; @@ -115,6 +116,10 @@ public final class WordPdfConverter { // ...и поля PAGE/NUMPAGES из fldChar делаем w:fldSimple, иначе // в колонтитулах печатается кэш docx (см. FieldNormalizer). docxBytes = FieldNormalizer.normalize(docxBytes); + // ...и раны со знаками, которых нет в их шрифте: без этого + // FOP рисует «#» (docx4j проверяет покрытие не для всех знаков + // и кэширует фолбэк на группу Юникода, см. GlyphCoverageNormalizer). + docxBytes = GlyphCoverageNormalizer.normalize(docxBytes); WordprocessingMLPackage pkg = WordprocessingMLPackage.load( new ByteArrayInputStream(docxBytes)); try { diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/fonts/BundledFontMapper.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/fonts/BundledFontMapper.java index effae85..86490f6 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/fonts/BundledFontMapper.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/fonts/BundledFontMapper.java @@ -46,6 +46,18 @@ public class BundledFontMapper extends BestMatchingMapper { /** Финальный fallback: шрифт с гарантированной кириллицей. */ private static final String FALLBACK_FAMILY = BundledFonts.FALLBACK_FAMILY; + /** + * Имя семейства для записи в {@code w:rFonts} (ключ — lowercase-семейство). + * Нужно {@code GlyphCoverageNormalizer}: он пишет в разрезанный ран + * человекочитаемое имя, а {@link #populateFontMappings} маппит его + * обратно на TTF. + */ + private static final Map DISPLAY_NAMES = Map.of( + "dejavu sans", "DejaVu Sans", + "dejavu serif", "DejaVu Serif", + "noto naskh arabic", "Noto Naskh Arabic", + "noto sans armenian", "Noto Sans Armenian"); + /** * Имя, которое docx4j {@code RunFontSelector} запрашивает у маппера для * символов диапазона U+2000–U+2EFF (em-dash «—», кавычки «„», многоточие @@ -74,6 +86,10 @@ public class BundledFontMapper extends BestMatchingMapper { m.put("cousine", "cousine"); m.put("dejavu sans", "dejavu sans"); m.put("dejavu serif", "dejavu serif"); + // Покрывающие шрифты (в документе обычно не встречаются, но если + // встречаться — маппятся на себя, а не в DejaVu-фолбэк) + m.put("noto naskh arabic", "noto naskh arabic"); + m.put("noto sans armenian", "noto sans armenian"); ALIASES = Map.copyOf(m); } @@ -89,6 +105,17 @@ public class BundledFontMapper extends BestMatchingMapper { : FALLBACK_FAMILY; } + /** + * Имя шрифта, которое можно поставить в {@code w:rFonts}, чтобы получить + * бандл-семейство {@code family}: {@link GlyphCoverageNormalizer} пишет + * его в разрезанные раны. Обратная к {@link #bundledFamily} операция — + * имена берутся из таблицы алиасов, поэтому маппинг гарантированно + * возвращается к тому же семейству. + */ + public static String documentFontName(String family) { + return DISPLAY_NAMES.getOrDefault(family, family); + } + /** * Вызывается docx4j при {@code package.setFontMapper(...)}: для каждого * имени шрифта, использованного в документе, нужно определить, каким diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/fonts/BundledFonts.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/fonts/BundledFonts.java index f71c614..274f6ca 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/fonts/BundledFonts.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/fonts/BundledFonts.java @@ -97,7 +97,14 @@ public final class BundledFonts { new Entry("DejaVuSerif-Regular.ttf", "dejavu serif", V_REGULAR), new Entry("DejaVuSerif-Bold.ttf", "dejavu serif", V_BOLD), new Entry("DejaVuSerif-Italic.ttf", "dejavu serif", V_ITALIC), - new Entry("DejaVuSerif-BoldItalic.ttf", "dejavu serif", V_BOLD_ITALIC) + new Entry("DejaVuSerif-BoldItalic.ttf", "dejavu serif", V_BOLD_ITALIC), + // Noto — покрытие письменностей, которых нет ни в одном шрифте + // выше (арабские дополнения U+07B1–U+08FF, армянские знаки + // Unicode 16). В docx4j-фолбэк они попадают сами: + // FontFallback.selectCovering перебирает весь реестр + // PhysicalFonts и берёт тот, что покрывает код (SIL OFL 1.1) + new Entry("NotoNaskhArabic-Regular.ttf", "noto naskh arabic", V_REGULAR), + new Entry("NotoSansArmenian-Regular.ttf", "noto sans armenian", V_REGULAR) ); /** Ключ семейства (lowercase) -> начертание -> зарегистрированный PhysicalFont. */ @@ -209,6 +216,16 @@ public final class BundledFonts { return null; } + /** + * Все бандл-семейства (lowercase) в порядке {@link #ENTRIES}. + * Нужны, чтобы задекларировать в FOP-конфиге каждый шрифт jar: + * FO может запросить любой из них (фолбэк docx4j по покрытию глифов), + * а FOP знает только задекларированные. + */ + public static java.util.List families() { + return ENTRIES.stream().map(Entry::family).distinct().toList(); + } + /** * Зарегистрированный шрифт: семейство (lowercase) + начертание. * diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FopFallbackFonts.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FopFallbackFonts.java index e859513..9e1b953 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FopFallbackFonts.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FopFallbackFonts.java @@ -7,20 +7,26 @@ import org.docx4j.fonts.PhysicalFont; import ru.pjandro.wordpdf.fonts.BundledFonts; /** - * Декларирует fallback-семейство (DejaVu Sans) в FOP-конфиге. + * Декларирует бандл-шрифты jar в FOP-конфиге. * * FOP-конфиг, который docx4j строит в {@code FOSettings}, содержит * только шрифты, реально использованные в документе ({@code fontsInUse}). - * Но docx4j {@code RunFontSelector} для символов диапазона U+2000–U+2EFF - * (em-dash «—», кавычки, многоточие) выставляет в FO - * {@code font-family}, маппированный с "Segoe UI Symbol" на DejaVu Sans - * (см. {@link ru.pjandro.wordpdf.fonts.BundledFontMapper}). Если семейство - * не задекларировано в FOP-конфиге, FOP не может его встроить и падает - * на базовый неembedded-шрифт (Helvetica) — символ рендерится шрифтом - * просмотрщика, а не встраиваемым подмножеством. + * Но {@code RunFontSelector} может выставить в {@code font-family} и шрифт + * извне документа: + * + * Если семейство не задекларировано в FOP-конфиге, FOP не может его + * встроить и падает на базовый неembedded-шрифт (Helvetica) — символ + * рендерится шрифтом просмотрщика либо .notdef («#»). Поэтому в конфиг + * добавляются ВСЕ шрифты бандла: стоит они в документе или нет, решает FO. * - * Метод идемпотентен: если семейство уже задекларировано (например, - * документ прямо использует DejaVu), ничего не добавляет. + * Метод идемпотентен: уже задекларированное семейство не дублируется. */ public final class FopFallbackFonts { @@ -28,7 +34,7 @@ public final class FopFallbackFonts { } /** - * Добавляет все начертания fallback-семейства в FOP-конфиг + * Добавляет все начертания всех бандл-семейств в FOP-конфиг * {@code foSettings}. Вызывать после {@code new FOSettings(pkg)} * и до передачи настроек в {@code FORendererApacheFOP}. */ @@ -37,7 +43,16 @@ public final class FopFallbackFonts { if (rendererFonts == null) { return; } - PhysicalFont regular = BundledFonts.regular(BundledFonts.FALLBACK_FAMILY); + ObjectFactory factory = new ObjectFactory(); + for (String family : BundledFonts.families()) { + declareFamily(rendererFonts, factory, family); + } + } + + /** Одно семейство: regular + существующие начертания (Noto — только regular). */ + private static void declareFamily(Fonts rendererFonts, ObjectFactory factory, + String family) { + PhysicalFont regular = BundledFonts.regular(family); if (regular == null) { return; } @@ -54,14 +69,13 @@ public final class FopFallbackFonts { } } - ObjectFactory factory = new ObjectFactory(); addFont(rendererFonts, factory, familyName, regular, "normal", "normal"); addFont(rendererFonts, factory, familyName, - BundledFonts.bold(BundledFonts.FALLBACK_FAMILY), "normal", "bold"); + BundledFonts.bold(family), "normal", "bold"); addFont(rendererFonts, factory, familyName, - BundledFonts.italic(BundledFonts.FALLBACK_FAMILY), "italic", "normal"); + BundledFonts.italic(family), "italic", "normal"); addFont(rendererFonts, factory, familyName, - BundledFonts.boldItalic(BundledFonts.FALLBACK_FAMILY), "italic", "bold"); + BundledFonts.boldItalic(family), "italic", "bold"); } /** 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 new file mode 100644 index 0000000..06ef49c --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizer.java @@ -0,0 +1,422 @@ +package ru.pjandro.wordpdf.internal; + +import ru.pjandro.wordpdf.fonts.BundledFontMapper; +import ru.pjandro.wordpdf.fonts.BundledFonts; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +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; + +/** + * Разрезание ранов по покрытию глифов — до загрузки docx4j. + * + * Если у знака нет глифа в шрифте ранa, FOP рисует {@code .notdef} — в PDF + * решётка «#». Часть таких знаков спасает сам docx4j + * ({@code FontFallback.selectCovering} ищет покрывающий шрифт по реестру), + * но у его механизма две дыры: + * + * + * Делаем то, что должен был сделать рендер: ран, в тексте которого есть + * знаки без глифа, разрезается на части, и каждой части явно назначается + * бандл-семейство, где глиф есть ({@link #targetFamily}). Имя пишется в + * {@code w:rFonts}, дальше {@link BundledFontMapper} маппит его на TTF, + * а {@link FopFallbackFonts} декларирует его в FOP-конфиге. + * + * Правила, ограничивающие вмешательство: + * + * + * Как и {@link SymbolFontNormalizer}, правим байты zip до JAXB-разбора. + */ +public final class GlyphCoverageNormalizer { + + /** Семейства с засечками: для них fallback ищется сначала среди serif. */ + private static final List SERIF_FAMILIES = + List.of("dejavu serif", "tinos", "caladea"); + + /** Без засечек — общий fallback проекта (в нём есть кириллица). */ + private static final String SANS_FALLBACK = BundledFonts.FALLBACK_FAMILY; + + /** {@code текст} — единственный текстовый узел рана. */ + private static final Pattern TEXT_ELEMENT = Pattern.compile( + "]*)>(.*?)", Pattern.DOTALL); + + /** Атрибуты w:rFonts с именем шрифта. */ + private static final Pattern FONT_ATTR = Pattern.compile( + "w:(ascii|hAnsi)=\"([^\"]+)\""); + + /** Числовые сущности XML (— / —). */ + private static final Pattern NUMERIC_ENTITY = Pattern.compile( + "&#(x?)([0-9A-Fa-f]+);"); + + /** Кэш покрытия: семейство -> множества проверенных/покрытых кодов. */ + private static final Map COVERAGE = new HashMap<>(); + + private GlyphCoverageNormalizer() { + } + + /** + * Разрезает раны с непокрытыми глифами в XML-частях docx (word/*.xml). + * + * @param docx байты .docx (zip) + * @return те же или переупакованные байты + */ + public 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) { + String result = rewriteBlocks(xml, "w:r"); + return result.equals(xml) ? null : result; + } + + /** + * Проходит невложенные блоки {@code } ... {@code } и заменяет + * каждый через {@link #rewriteBlock}. Приём тот же, что в + * {@link SymbolFontNormalizer}: полные раны не вложены друг в друга. + */ + private static String rewriteBlocks(String xml, String tag) { + String open = "<" + tag; + String close = ""; + StringBuilder sb = new StringBuilder(xml.length()); + int pos = 0; + while (true) { + int start = indexOfOpenTag(xml, open, pos); + if (start < 0) { + break; + } + int openEnd = xml.indexOf('>', start); + int end = xml.indexOf(close, openEnd); + if (openEnd < 0 || end < 0) { + break; + } + end += close.length(); + sb.append(xml, pos, start).append(rewriteBlock(xml.substring(start, end))); + pos = end; + } + if (pos == 0) { + return xml; + } + return sb.append(xml, pos, xml.length()).toString(); + } + + /** Позиция открывающего (не самозакрывающегося) тега {@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; + } + + /** + * Разрезает один {@code w:r}: части текста без глифа в шрифте ранa + * получают собственное {@code w:rFonts}. + */ + private static String rewriteBlock(String block) { + 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 runFamily = runFamily(rPr); + if (runFamily == null) { + // Шрифт не указан явно — приходит из стилей, не угадываем. + return block; + } + Matcher text = TEXT_ELEMENT.matcher(body); + if (!text.matches()) { + // Составной ран (w:tab, w:drawing, несколько w:t) не трогаем. + return block; + } + String decoded = decode(text.group(2)); + List segments = split(decoded, runFamily); + if (segments == null) { + return block; + } + + StringBuilder sb = new StringBuilder(block.length() + 64); + for (Segment s : segments) { + sb.append(openTag).append(s.family == null ? rPr : forceFont(rPr, s.family)) + .append("') + .append(encode(s.text)) + .append(""); + } + return sb.toString(); + } + + /** + * Разбивает текст на части по семейству, которое обязано его отрисовать. + * + * @return части либо null, если весь текст остаётся на шрифте ранa + * (или ни один бандл-шрифт не покрывает недостающие знаки) + */ + static List split(String text, String runFamily) { + List segments = new ArrayList<>(); + int start = 0; + String current = null; + for (int i = 0; i < text.length(); ) { + int cp = text.codePointAt(i); + int next = i + Character.charCount(cp); + String target = targetFamily(cp, runFamily); + if (start == i) { + current = target; + } else if (!java.util.Objects.equals(target, current)) { + segments.add(new Segment(text.substring(start, i), current)); + start = i; + current = target; + } + i = next; + } + if (text.isEmpty()) { + return null; + } + segments.add(new Segment(text.substring(start), current)); + boolean changed = segments.size() > 1 || segments.get(0).family != null; + return changed ? segments : null; + } + + /** + * Семейство, которым нужно рисовать знак {@code cp}, или null, если + * штатного шрифта ранa достаточно. + * + * Порядок перебора: сначала семейства того же рисунка (serif к serif), + * затем остальные бандл-семейства — так знак остаётся максимально + * близким по начертанию. + */ + static String targetFamily(int cp, String runFamily) { + if (covers(runFamily, cp)) { + return null; + } + boolean serif = SERIF_FAMILIES.contains(runFamily); + for (String family : candidates(runFamily, serif)) { + if (covers(family, cp)) { + return family; + } + } + // Одиночный знак может не найтись ни в одном семействе — решётку + // не прячем: ран остаётся как есть. + return null; + } + + /** Кандидаты на подстановку: сначала «свой» класс, потом остальные. */ + private static List candidates(String runFamily, boolean serif) { + List ordered = new ArrayList<>(); + if (serif) { + ordered.addAll(SERIF_FAMILIES); + } + ordered.add(SANS_FALLBACK); + for (String family : BundledFonts.families()) { + if (!ordered.contains(family)) { + ordered.add(family); + } + } + ordered.remove(runFamily); + return ordered; + } + + /** Есть ли у семейства глиф для кода (regular-начертание). */ + static boolean covers(String family, int cp) { + if (family == null) { + return false; + } + return coverage(family).covers(cp); + } + + private static Coverage coverage(String family) { + Coverage c = COVERAGE.get(family); + if (c == null) { + c = new Coverage(BundledFonts.awtFont(family, BundledFonts.V_REGULAR)); + COVERAGE.put(family, c); + } + return c; + } + + /** + * Покрытие одного семейства: {@code java.awt.Font.canDisplay} с кэшем + * «проверенных» кодов. AWT берётся вместо {@code GlyphCheck}, чтобы не + * плодить INFO-лог на каждый отсутствующий глиф. + */ + private static final class Coverage { + + private final java.awt.Font font; + private final java.util.BitSet checked = new java.util.BitSet(); + private final java.util.BitSet covered = new java.util.BitSet(); + + Coverage(java.awt.Font font) { + this.font = font; + } + + boolean covers(int cp) { + if (font == null || cp < 0) { + return false; + } + if (checked.get(cp)) { + return covered.get(cp); + } + checked.set(cp); + if (font.canDisplay(cp)) { + covered.set(cp); + return true; + } + return false; + } + } + + /** Часть текста рана; family == null — рисовать штатным шрифтом ранa. */ + static final class Segment { + + final String text; + /** Ключ бандл-семейства (lowercase) или null. */ + final String family; + + Segment(String text, String family) { + this.text = text; + this.family = family; + } + } + + /** + * Бандл-семейство шрифта ранa (первое из {@code w:ascii}/{@code w:hAnsi}) + * либо null, если рана шрифт не объявлен. + */ + private static String runFamily(String rPr) { + int rFonts = rPr.indexOf("', rFonts); + if (end < 0) { + return null; + } + Matcher m = FONT_ATTR.matcher(rPr.substring(rFonts, end)); + if (!m.find()) { + return null; + } + return BundledFontMapper.bundledFamily(m.group(2)); + } + + /** + * Принудительно ставит семейство в {@code w:rPr}: заменяет атрибуты + * {@code w:rFonts}, а если их нет — вставляет элемент первым ребёнком. + */ + private static String forceFont(String rPr, String family) { + String name = BundledFontMapper.documentFontName(family); + String fonts = ""; + if (rPr.isEmpty()) { + return "" + fonts + ""; + } + int start = rPr.indexOf("", "" + fonts); + } + int end = rPr.indexOf("/>", start); + int blockEnd = rPr.indexOf("", start); + if (blockEnd >= 0 && (end < 0 || blockEnd < end)) { + return rPr.substring(0, start) + fonts + rPr.substring(blockEnd + "".length()); + } + if (end < 0) { + return rPr; + } + return rPr.substring(0, start) + fonts + rPr.substring(end + 2); + } + + /** Атрибуты w:t: сохраняем исходные и добавляем preserve, если нужно. */ + private static String attrs(String original, String segmentText) { + // Пустой после strip() сегмент — это тоже пробелы, их Word бы съел. + boolean needsPreserve = !segmentText.equals(segmentText.strip()); + if (needsPreserve && !original.contains("xml:space")) { + return original + " xml:space=\"preserve\""; + } + return original; + } + + /** Разворачивает XML-сущности текста в настоящие символы. */ + private static String decode(String xmlText) { + if (xmlText.indexOf('&') < 0) { + return xmlText; + } + String result = NUMERIC_ENTITY.matcher(xmlText).replaceAll(mr -> { + int cp = Integer.parseInt(mr.group(2), mr.group(1).isEmpty() ? 10 : 16); + return Matcher.quoteReplacement(new String(Character.toChars(cp))); + }); + return result.replace("<", "<").replace(">", ">") + .replace(""", "\"").replace("'", "'") + .replace("&", "&"); + } + + /** Обратное {@link #decode}: текст снова безопасен для {@code w:t}. */ + private static String encode(String text) { + return text.replace("&", "&").replace("<", "<").replace(">", ">"); + } +} diff --git a/wordpdf-core/src/main/resources/fonts/FONT-LICENSE.txt b/wordpdf-core/src/main/resources/fonts/FONT-LICENSE.txt index 4e48755..9b860f0 100644 --- a/wordpdf-core/src/main/resources/fonts/FONT-LICENSE.txt +++ b/wordpdf-core/src/main/resources/fonts/FONT-LICENSE.txt @@ -15,4 +15,12 @@ Источник: официальный tarball dejavu-fonts-ttf-2.37 (https://dejavu-fonts.github.io), LICENSE см. DejaVu-LICENSE.txt. -Все шрифты свободно распространяемы и поддерживают кириллицу. +- Noto Naskh Arabic, Noto Sans Armenian + SIL Open Font License 1.1 (SIL OFL 1.1). + Покрывают письменности, которых нет в шрифтах выше (арабские дополнения + U+07B1–U+08FF, армянские знаки Unicode 16). + (c) The Noto Project Authors. + Источник: notofonts.github.io (hinted TTF), LICENSE см. Noto-LICENSE.txt. + +Все шрифты свободно распространяемы (SIL OFL 1.1); шрифты текста +(Carlito, Caladea, Arimo, Tinos, Cousine, DejaVu) содержат кириллицу. diff --git a/wordpdf-core/src/main/resources/fonts/Noto-LICENSE.txt b/wordpdf-core/src/main/resources/fonts/Noto-LICENSE.txt new file mode 100644 index 0000000..9651ea7 --- /dev/null +++ b/wordpdf-core/src/main/resources/fonts/Noto-LICENSE.txt @@ -0,0 +1,94 @@ +Copyright 2022 The Noto Project Authors (https://github.com/notofonts/) + +This Font Software is licensed under the SIL Open Font License, +Version 1.1. + +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font +creation efforts of academic and linguistic communities, and to +provide a free and open framework in which fonts may be shared and +improved in partnership with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply to +any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software +components as distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, +deleting, or substituting -- in part or in whole -- any of the +components of the Original Version, by changing formats or by porting +the Font Software to a new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, +modify, redistribute, and sell modified and unmodified copies of the +Font Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, in +Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the +corresponding Copyright Holder. This restriction only applies to the +primary font name as presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created using +the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/wordpdf-core/src/main/resources/fonts/NotoNaskhArabic-Regular.ttf b/wordpdf-core/src/main/resources/fonts/NotoNaskhArabic-Regular.ttf new file mode 100644 index 0000000..e81ad4e Binary files /dev/null and b/wordpdf-core/src/main/resources/fonts/NotoNaskhArabic-Regular.ttf differ diff --git a/wordpdf-core/src/main/resources/fonts/NotoSansArmenian-Regular.ttf b/wordpdf-core/src/main/resources/fonts/NotoSansArmenian-Regular.ttf new file mode 100644 index 0000000..08069ed Binary files /dev/null and b/wordpdf-core/src/main/resources/fonts/NotoSansArmenian-Regular.ttf differ diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java index 6acd203..3d662fb 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java @@ -67,6 +67,7 @@ public final class SampleDocxGenerator { ruTableImage(dir.resolve("ru-table-image.docx")); symbolBullets(dir.resolve("symbol-bullets.docx")); pageNumbers(dir.resolve("page-numbers.docx")); + exoticGlyphs(dir.resolve("exotic-glyphs.docx")); System.out.println("Готово: " + dir.toAbsolutePath()); } @@ -301,6 +302,30 @@ public final class SampleDocxGenerator { .setFldCharType(STFldCharType.END); } + /** + * Знаки без глифа в шрифте ранa: римские цифры и дроби (U+2150–U+218F, + * которые docx4j вообще не проверяет на покрытие), армянские знаки + * Unicode 16 рядом с обычными армянскими (столкновение кэша фолбэка + * docx4j на группе Юникода) и арабские дополнения. Всё в Times New Roman + * — в нём этих глифов нет. + */ + private static void exoticGlyphs(Path out) throws Exception { + try (XWPFDocument doc = new XWPFDocument()) { + heading(doc, "Экзотические глифы", "Times New Roman"); + + String[] font = {"Times New Roman"}; + run(doc.createParagraph(), "Числовые символы \u2152\u2155\u215E " + + "\u2161\u216A\u216D\u2174\u2181\u2183\u2182", font[0], false, false); + run(doc.createParagraph(), "Армянский: \u054A\u054C\u054B\u057F " + + "\u058D\u058E", font[0], false, false); + run(doc.createParagraph(), "Арабский: \u08E1\u08EC\u08ED " + + "\u076E\u0770", font[0], false, false); + run(doc.createParagraph(), "Обычный текст 123, кириллица и em-dash —", + font[0], false, false); + save(doc, out); + } + } + // ================== Вспомогательные ================== /** Абзац-заголовок: POI 5.5 не имеет createHeading, поэтому diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java index bf1853c..c9f26d9 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java @@ -159,6 +159,38 @@ class WordPdfConverterTest { "пропал текст пункта списка: " + text); } + /** + * Знаки, у которых нет глифа в шрифте ранa (римские цифры и дроби, + * армянские знаки Unicode 16, арабские дополнения), FOP рисовал + * {@code .notdef} — решётку «#». Docx4j сам ищет покрывающий шрифт, + * но не проверяет покрытие для «латинской» группы и кэширует фолбэк на + * всю группу Юникода. GlyphCoverageNormalizer разрезает такой ран и + * явно назначает семейство для каждой части. + */ + @Test + void exoticGlyphs_drawnNotHash() throws Exception { + Path in = extractSample("exotic-glyphs.docx"); + Path pdf = convert(in); + String text = norm(pdfText(pdf)); + + for (String ch : List.of("\u2152", "\u2181", "\u058D", "\u08E1")) { + assertTrue(text.contains(ch), "нет символа U+" + + Integer.toHexString(ch.charAt(0)) + ": " + text); + } + assertFalse(text.contains("#"), + "в PDF остались .notdef-решётки: " + text); + + // Римская цифра — вшитым DejaVu Serif, а не базовым Helvetica + assertTrue(fontNameOf(pdf, '\u2181').contains("DejaVuSerif"), + "римская цифра нарисована не DejaVu Serif"); + // Армянский знак Unicode 16 — Noto Sans Armenian + assertTrue(fontNameOf(pdf, '\u058D').contains("NotoSansArmenian"), + "армянский знак нарисован не Noto Sans Armenian"); + // Соседний обычный текст не уехал в подставленное семейство + assertTrue(fontNameOf(pdf, 'ы').contains("Tinos"), + "кириллица уехала с Tinos"); + } + /** * Поля PAGE/NUMPAGES Word пишет как {@code fldChar} + {@code instrText} * + закэшированный результат. Экспорт docx4j в FO инструкцию игнорирует diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizerTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizerTest.java new file mode 100644 index 0000000..9a7e48b --- /dev/null +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizerTest.java @@ -0,0 +1,181 @@ +package ru.pjandro.wordpdf.internal; + +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import ru.pjandro.wordpdf.fonts.BundledFontMapper; +import ru.pjandro.wordpdf.fonts.BundledFonts; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Разрезание ранов по покрытию глифов (см. GlyphCoverageNormalizer). + * + * Покрытие берётся из реальных TTF бандла, поэтому перед тестами + * шрифты инициализируются ровно так же, как в конвертере. + */ +class GlyphCoverageNormalizerTest { + + private static final String NS = + ""; + + /** Римская цифра: в Tinos глифа нет, в DejaVu Serif есть. */ + private static final String ROMAN = "\u2181"; + /** Знак, которого нет ни в одном бандл-шрифте. */ + private static final String NOWHERE = "\u2188"; + /** Обычная кириллица — есть в Tinos. */ + private static final String CYRILLIC = "ы"; + + @BeforeAll + static void initFonts() { + new BundledFontMapper(); + BundledFonts.init(); + BundledFonts.restrictToBundled(); + } + + private static String run(String rPr, String body) { + return NS + "" + rPr + body + ""; + } + + private static String timesRPr() { + return ""; + } + + /** Знак без глифа в шрифте ранa уезжает в отдельный ран со своим w:rFonts. */ + @Test + void splitsRunForUncoveredGlyph() { + String xml = run(timesRPr(), "ы" + ROMAN + "ы"); + + String out = GlyphCoverageNormalizer.rewrite(xml); + + assertNotNull(out, "ран с римской цифрой не разрезан"); + assertTrue(out.contains(""), + "нет подставленного семейства: " + out); + assertTrue(out.contains("w:cs=\"Times New Roman\""), + "потеряны остальные атрибуты w:rFonts: " + out); + assertTrue(out.contains(""), + "потеряно начертание рана: " + out); + assertEquals(3, occurrences(out, ""), "ожидалось три рана: " + out); + assertTrue(out.contains(ROMAN), "пропал сам знак: " + out); + } + + /** Порядок частей сохраняется: сначала обычный текст, потом подстановка. */ + @Test + void keepsSegmentOrder() { + String out = GlyphCoverageNormalizer.rewrite( + run(timesRPr(), "ы" + ROMAN + "ы")); + + assertNotNull(out); + int substituted = out.indexOf("DejaVu Serif"); + int tail = out.lastIndexOf("ы"); + assertTrue(out.indexOf("") < substituted && substituted < tail, + "части идут не в исходном порядке: " + out); + } + + /** Всё, что рисует штатный шрифт, остаётся нетронутым. */ + @Test + void coveredRunUntouched() { + String xml = run(timesRPr(), "обычный текст 1234"); + + assertNull(GlyphCoverageNormalizer.rewrite(xml)); + } + + /** Ран без w:rFonts получает шрифт из стилей — угадывать нечем. */ + @Test + void runWithoutExplicitFontUntouched() { + String xml = run("", "" + ROMAN + ""); + + assertNull(GlyphCoverageNormalizer.rewrite(xml)); + } + + /** Составной ран (несколько детей в w:r) не трогаем. */ + @Test + void compoundRunUntouched() { + String xml = run(timesRPr(), "" + ROMAN + ""); + + assertNull(GlyphCoverageNormalizer.rewrite(xml)); + } + + /** Знака нет ни в одном бандл-шрифте: решётку не прячем за случайный шрифт. */ + @Test + void glyphMissingEverywhereUntouched() { + String xml = run(timesRPr(), "" + NOWHERE + ""); + + assertNull(GlyphCoverageNormalizer.rewrite(xml)); + } + + /** Часть с пробелами по краям обязана остаться с xml:space="preserve". */ + @Test + void addsXmlSpacePreserve() { + String out = GlyphCoverageNormalizer.rewrite( + run(timesRPr(), "" + ROMAN + " ы")); + + assertNotNull(out); + assertTrue(out.contains(" ы"), + "часть с пробелами потеряла xml:space: " + out); + assertTrue(out.contains("" + ROMAN + ""), + "часть без пробелов получила лишний xml:space: " + out); + } + + /** Исходный xml:space не дублируется. */ + @Test + void keepsExistingXmlSpace() { + String out = GlyphCoverageNormalizer.rewrite( + run(timesRPr(), "" + ROMAN + " ы")); + + assertNotNull(out); + assertEquals(2, occurrences(out, "xml:space=\"preserve\""), + "xml:space задублирован: " + out); + } + + /** Числовые сущности разбираются, а не разрезаются по буквам. */ + @Test + void decodesNumericEntities() { + String out = GlyphCoverageNormalizer.rewrite( + run(timesRPr(), "⅒⅕")); + + assertNotNull(out, "сущности не разобраны: U+2152 требует подстановки"); + assertTrue(out.contains("DejaVu Serif"), "нет подстановки: " + out); + } + + /** Экранирование обратимо: & не превращается в &amp;. */ + @Test + void escapesTextBack() { + String out = GlyphCoverageNormalizer.rewrite( + run(timesRPr(), "Tom & Jerry " + ROMAN + "")); + + assertNotNull(out); + assertTrue(out.contains("Tom & Jerry"), "сломано экранирование: " + out); + assertFalse(out.contains("&amp;"), "двойное экранирование: " + out); + } + + /** Serif-ран уходит в serif-семейство, а не в sans fallback. */ + @Test + void serifRunPrefersSerifFamily() { + List segments = + GlyphCoverageNormalizer.split("ы" + ROMAN, "tinos"); + + assertNotNull(segments); + assertEquals("dejavu serif", segments.get(1).family); + } + + /** Sans-ран уходит в sans fallback. */ + @Test + void sansRunPrefersSansFamily() { + List segments = + GlyphCoverageNormalizer.split("ы" + ROMAN, "carlito"); + + assertNotNull(segments); + assertEquals("dejavu sans", segments.get(1).family); + } + + private static int occurrences(String s, String needle) { + int count = 0; + for (int i = s.indexOf(needle); i >= 0; i = s.indexOf(needle, i + 1)) { + count++; + } + return count; + } +} diff --git a/wordpdf-core/src/test/resources/samples/exotic-glyphs.docx b/wordpdf-core/src/test/resources/samples/exotic-glyphs.docx new file mode 100644 index 0000000..e9814b3 Binary files /dev/null and b/wordpdf-core/src/test/resources/samples/exotic-glyphs.docx differ