FOP-оверлей ru.pjandro + правило 9: w:jc=distribute растягивает все строки #101
@@ -4,11 +4,11 @@
|
||||
|
||||
## Project Overview
|
||||
|
||||
Конвертер `.docx`/`.doc` → `.pdf` на чистом Java: docx4j 17.3.2 → XSL-FO → форк Apache FOP, без LibreOffice/Aspose. Бинарный `.doc` (Word 97-2003) переносится мостом MS-DOC/MS-CFB (`internal/doc`) в in-memory `.docx` и идёт тем же конвейером. Java 17, только Maven.
|
||||
Конвертер `.docx`/`.doc` → `.pdf` на чистом Java: docx4j 17.3.6 → XSL-FO → форк Apache FOP, без LibreOffice/Aspose. Бинарный `.doc` (Word 97-2003) переносится мостом MS-DOC/MS-CFB (`internal/doc`) в in-memory `.docx` и идёт тем же конвейером. Java 17, только Maven.
|
||||
|
||||
| Модуль | Содержимое |
|
||||
|---|---|
|
||||
|`wordpdf-core`|библиотека: 61 Java-файл (6 — публичный API, 16 `internal/`, 18 `internal/doc/`, 18 `internal/chart/`, 3 `fonts/`)|
|
||||
|`wordpdf-core`|библиотека: 59 Java-файл (6 — публичный API, 14 `internal/`, 18 `internal/doc/`, 18 `internal/chart/`, 3 `fonts/`)|
|
||||
| `wordpdf-app` | REST API на Spring Boot 4.1.1: 11 классов, единственный `public` — `WordPdfApplication` |
|
||||
| `wordpdf-web` | SPA (React 19 + TS + Vite + Tailwind), вне Maven-реактора, отдельный образ |
|
||||
|
||||
@@ -18,16 +18,20 @@
|
||||
|
||||
Порядок шагов 0–7 фиксирован (`convertToStream`), местами менять нельзя. Вход роутируется по сигнатуре: `PK\x03\x04` → docx-путь; `D0 CF 11 E0 A1 B1 1A E1` (CFB, MS-CFB §2.2) → `DocToDocx.convert` → in-memory `.docx` → тот же конвейер (предикат — `WordPdfValidator.isBinaryDoc`). Валидация — **до** `convertToStream`: `WordPdfValidator.validate(bytes, options)` (размер → подпись zip/CFB → контейнер → страницы); для `.doc` — `checkPageCountDoc` по сырым байтам.
|
||||
|
||||
Порядок: шрифты (`BundledFontMapper` → `BundledFonts.init` → `restrictToBundled`) и правила 1–10 (`DocxRewritePipeline.STEP`) + `OleObjectNormalizer` — до `WordprocessingMLPackage.load`; `FOSettings`/`FopFallbackFonts`/`LayoutPostRenderer` — до `setCustomXsltTemplates(VendoredXslt.TEMPLATES)`; `Docx4J.toFO(…, FLAG_EXPORT_PREFER_XSL)` — последним; `finally` → `deleteEmbeddedFontTempFiles()` + сброс имиджевых кешей общей FopFactory + `BundledFonts.restrictToBundled()` (реестр шрифтов возвращается в бандл-состояние: `load()` регистрирует встроенные шрифты документа в глобальном `PhysicalFonts`). Полная таблица шагов и подсчёт страниц — `docs/agent/pipeline.md`.
|
||||
Порядок: шрифты (`BundledFontMapper` → `BundledFonts.init` → `restrictToBundled`) и правила 1–9 (`DocxRewritePipeline.STEP`) + `OleObjectNormalizer` — до `WordprocessingMLPackage.load`; `FOSettings`/`FopFallbackFonts`/`LayoutPostRenderer` — до `setCustomXsltTemplates(VendoredXslt.TEMPLATES)`; `Docx4J.toFO(…, FLAG_EXPORT_PREFER_XSL)` — последним; `finally` → `deleteEmbeddedFontTempFiles()` + сброс имиджевых кешей общей FopFactory + `BundledFonts.restrictToBundled()` (реестр шрифтов возвращается в бандл-состояние: `load()` регистрирует встроенные шрифты документа в глобальном `PhysicalFonts`). Полная таблица шагов и подсчёт страниц — `docs/agent/pipeline.md`.
|
||||
|
||||
## Нормализаторы (`internal/DocxNormalizer`)
|
||||
|
||||
Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame`). Порядок фиксирован: Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby. Правила 1–10 применяет `DocxRewritePipeline.STEP` одним zip-проходом (неизменённые записи копируются raw-сжатыми байтами); `OleObjectNormalizer` (правило 11) — лямбдой в `WordPdfConverter.normalizers()`. `STEP` выставляют 9 из 10 rewrite-нормализаторов (нет у `RubyNormalizer`), у `OleObjectNormalizer` её нет. Правила 1–11, guard'ы, номера секций и инвариант `mc-preprocessor.xslt` (собственный рерайт strict-URI ломать нельзя) — `docs/agent/pipeline.md`.
|
||||
Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame`). Порядок фиксирован: Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby→Distribute. Правила 1–9 применяет `DocxRewritePipeline.STEP` одним zip-проходом (неизменённые записи копируются raw-сжатыми байтами); `OleObjectNormalizer` (правило 10) — лямбдой в `WordPdfConverter.normalizers()`. `STEP` выставляют 8 из 9 rewrite-нормализаторов (нет у `RubyNormalizer`), у `OleObjectNormalizer` её нет. Правил Symbol-шрифтов и complex-полей PAGE/NUMPAGES больше нет — с docx4j 17.3.x их делает сам экспорт (#701, CR-067); пины отсутствия регрессии — `symbolFonts_bulletsAreNotHash`, `pageNumbers_recomputedNotCached`. Правила 1–9, guard'ы, номера секций и инвариант `mc-preprocessor.xslt` (собственный рерайт strict-URI ломать нельзя) — `docs/agent/pipeline.md`.
|
||||
|
||||
## Мост `.doc` → `.docx` (`internal/doc`)
|
||||
|
||||
18 классов, 17 package-private; наружу — только `DocToDocx` (`convert`/`countPages`). Общий разбор — `DocFile`: CFB → потоки WordDocument / 0Table|1Table / Data + FIB + piece table. Новых runtime-зависимостей нет (POI/POIFS — test-scope). Источники: [MS-DOC] (`docs/standards/doc/`), [MS-CFB]/[MS-OLEPS]/[MS-ODRAW] (`docs/standards/binary/`). Байтовые раскладки по классам — `docs/agent/doc-bridge.md`.
|
||||
|
||||
## FOP-оверлей (`ru.pjandro:docx4j-fo-renderer-core`)
|
||||
|
||||
Форк `org.docx4j:docx4j-fo-renderer-core` 2.12-docx4j.1 (он же Apache FOP 2.12) в репо `ai/xmlgraphics-fop-pj` (Gitea); версии вида `2.12-docx4j.1-pj.N` (наследование по схеме форка, README репо), артефакты — Nexus maven-hosted (входит в `maven-public`). Подключение: в `wordpdf-core/pom.xml` — exclusion `org.docx4j:docx4j-fo-renderer-core` из `docx4j-export-fo` + зависимость `ru.pjandro:docx4j-fo-renderer-core` (версия `${fop-overlay.version}` в корневом pom); тонкий `docx4j-fo-renderer` (hooks-маркер `Docx4jFop`) НЕ исключается. В оверлее наши патчи помечены `Added by pjandro`/`CR-0xx`, тесты — package `org.apache.fop.layoutmgr.word` (в т.ч. `DistributeLineTestCase` — пин justify-пары для distribute). Новый релиз оверлея: `mvn deploy` в репо форка → bump `fop-overlay.version` → `mvn clean verify` здесь. Пайплайн CI форка не связан с этим репо.
|
||||
|
||||
## REST API (`wordpdf-app`, всё package-private кроме `WordPdfApplication`)
|
||||
|
||||
`POST /api/v1/convert`: multipart-поле `file` (`.docx`/`.doc`) + query/form-параметры `errorOnCharts`/`errorOnSmartArt`/`errorOnOle` (дефолт каждого — `false`), `maxMb`/`maxPages` (лимиты входа: переопределяют серверный дефолт в обе стороны; ≤ 0 → 400). Ответ — `application/pdf`, `Content-Disposition: attachment; filename*=UTF-8''…`; имя — `ConversionService.safeBaseName`. Тело ошибки — `{"error": …}`. Error-флаги на `.doc` **не срабатывают** (BLIP-плейсхолдеры → картинки). `ApiExceptionHandler` не видит ошибок фильтров — 401 пишет сам `ApiKeyFilter`.
|
||||
@@ -47,15 +51,16 @@ Java2D → PNG: `ChartRenderer.DPI = 300`, потолок `MAX_PIXELS = 16_777_2
|
||||
## Критические инварианты (нарушение = битый вывод, не исключение)
|
||||
|
||||
- `docx4j.convert.out.fo.gsubFeatures=false` — static-блок `WordPdfConverter`; иначе FO невалиден → `WordLayoutFixups` молча отказывает всем фиксам → FOP падает на `docx4j-baseline`.
|
||||
- `docx4j.openpackaging.load.repair=word` — static-блок `WordPdfConverter` (17.3.6, `RepairMode`): с дефолтным NONE пакеты, которые Word открывает через «восстановить» (напр. case-folded дубликаты zip-записей), отказываются грузиться — для конвертера это 500 на читаемых Word файлах.
|
||||
- `docx4j.fonts.discoverPhysicalFonts.enabled=false` и `discoverJarFonts.enabled=false` — static-блок: иначе `BestMatchingMapper` сканирует системные шрифты и jar'ы classpath'а, а `restrictToBundled()` всё найденное выбрасывает (~100–140 мс впустую на JVM). `discoverJarFonts("fonts-symbol")` свойством не гейтится — символ-шрифт регистрируется и снимается restrict'ом как раньше.
|
||||
- Единственный XSL-FO-стилист — вендорный `xslt/docx2fo.xslt` (копия из docx4j-export-fo 17.3.2 + два AUDIT-FIX-патча: `w:rPr/w:position` → `baseline-shift`, Part 1 §17.3.2.24; AUDIT-FIX-2 — `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir`, иначе их ловит catch-all `match="*"` и текст теряется). Дрейф-гейт `vendoredXsltTracksJarCopy`: вне AUDIT-FIX-регионов копия побайтно равна стилю из jar'а. `setCustomXsltTemplates` принимает предкомпилированный `Templates`.
|
||||
- Единственный XSL-FO-стилист — вендорный `xslt/docx2fo.xslt` (копия из docx4j-export-fo 17.3.6 + два AUDIT-FIX-патча: `w:rPr/w:position` → `baseline-shift`, Part 1 §17.3.2.24; AUDIT-FIX-2 — `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir`, иначе их ловит catch-all `match="*"` и текст теряется). Дрейф-гейт `vendoredXsltTracksJarCopy`: вне AUDIT-FIX-регионов копия побайтно равна стилю из jar'а. `setCustomXsltTemplates` принимает предкомпилированный `Templates`.
|
||||
- `slf4j-simple` обязателен в ядре: без SLF4J-провайдера docx4j пишет «TO HIDE THESE MESSAGES» прямо в PDF (регрессия `noLoggingWarningInPdf`); приложение исключает его — логи ведёт logback.
|
||||
- FOP — форк `org.docx4j:docx4j-fo-renderer*` 2.11-docx4j.6 (транзитив от `docx4j-export-fo`, в pom не пинится; пакеты `org.apache.fop.*`). `FopFallbackFonts` берёт `w:renderer` с mime `application/pdf`, иначе первый со шрифтами.
|
||||
- FOP — собственный оверлей `ru.pjandro:docx4j-fo-renderer-core:${fop-overlay.version}` (форк `org.docx4j:docx4j-fo-renderer-core` 2.12-docx4j.1 = FOP 2.12 + word-layout; пакеты `org.apache.fop.*`; репо `ai/xmlgraphics-fop-pj`, артефакт — Nexus). `docx4j-export-fo` исключает центральный `org.docx4j:docx4j-fo-renderer-core`; тонкий `docx4j-fo-renderer` (маркер `Docx4jFop`, хук word-layout) остаётся из `docx4j-export-fo`. `FopFallbackFonts` берёт `w:renderer` с mime `application/pdf`, иначе первый со шрифтами.
|
||||
- `BundledFonts.init()` идемпотентен, распаковывает TTF в `wordpdf-fonts-*` (`deleteOnExit`); `dropNonBundled()` чистит `PhysicalFonts` от всего, что вне бандла; ВСЕ синхронизированные методы `BundledFonts` (`init`/`restrictToBundled`/`font`) держат монитор `WordPdfConverter.class` (не собственный замок класса) — тот же, что сериализует конвертации, поэтому внешний вызов рядом с идущей конвертацией безопасен автоматически. Регрессия — `WordPdfConverterTest#concurrentFontMutators_conversionsUnharmed`.
|
||||
- `PhysicalFonts` — глобальный и мутируемый → конвертации сериализуются монитором `WordPdfConverter.class` внутри ядра (общая `FopFactory` и сброс её image-кешей — под тем же монитором); приложение держит однопоточный воркер ради 503/timeout; `warmup()` идёт тем же потоком.
|
||||
- Страницы в валидаторе = `max(кэш docProps/app.xml, явные разрывы, lastRenderedPageBreak+1)`; правила StAX-подсчёта — `docs/agent/pipeline.md`.
|
||||
- Не чинить: `jc="distribute"`, `suff="tab"`/`lvlJc`, метрика «single», кернинг, `framePr`, `REF`/`SEQ`/`TOC`-кэш, руби-надстрочница, U+2188/U+218A — доказательства в `docs/agent/render-limitations.md`.
|
||||
- Комментарии в `WordPdfConverter`/`DocxOnOffNormalizer` говорят «docx4j 11.x» — устаревшее число, фактически 17.3.2 (описанное поведение верно).
|
||||
- Не чинить: `suff="tab"`/`lvlJc`, метрика «single», кернинг, `REF`/`SEQ`/`TOC`-кэш, руби-надстрочница, U+2188/U+218A — доказательства в `docs/agent/render-limitations.md`. `framePr` починен апстримом 17.3.6 (фрейм позиционируется); `jc="distribute"` починен правилом 9 + justify-парой в `LayoutPostRenderer` (межсловный разнос всех строк, межсимвольный kashida не реализован).
|
||||
- Комментарии в `WordPdfConverter`/`DocxOnOffNormalizer` говорят «docx4j 11.x» — устаревшее число, фактически 17.3.6 (описанное поведение верно).
|
||||
|
||||
## Шрифты (30 TTF + 3 лицензии, SIL OFL, `wordpdf-core/src/main/resources/fonts/`)
|
||||
|
||||
@@ -83,6 +88,13 @@ python3 docs/standards/docx/validate-fixtures.py wordpdf-core/src/test/resources
|
||||
|
||||
**«Запусти тестовый сервер» (термин пользователя)** = полный dev-стенд, НЕ `java -jar`: `podman-compose -f compose.dev.yml up -d --build --force-recreate`, вход `http://<LAN-IP хоста>:9011` без API-ключа; гейт — контейнеры healthy + корень SPA отвечает 200. `--force-recreate` обязателен: без него контейнеры остаются на старом образе.
|
||||
|
||||
**Ожидание готовности podman-контейнеров** (одинаково для dev-стенда и для собственных тестовых контейнеров):
|
||||
- Гейт — наблюдаемый факт готовности, а не «подождал N секунд»: HTTP-эндпоинт сервиса (`curl -fs --max-time 2 …`) или, для контейнера с healthcheck, `podman inspect <name> --format '{{.State.Health.Status}}'` = `healthy`.
|
||||
- Ждать — синхронным `until`-циклом с жёстким потолком и коротким шагом, в том же вызове, что и идущая сразу за гейтом проверка: `timeout 180 sh -c 'until curl -fs --max-time 2 http://127.0.0.1:9011/ -o /dev/null; do sleep 2; done' && <смоук>`. Готово — цикл выходит за секунды; потолок срабатывает только при настоящей неполадке (тогда читать `podman logs <name>`).
|
||||
- **Нельзя** считать `healthy` по всему списку контейнеров (`grep -c healthy`): у контейнеров без healthcheck (nginx-гейтстенд) статус никогда не содержит `healthy` — такой цикл молча крутится до самого дедлайна, стена при этом уже готова. У контейнеров без healthcheck единственный гейт — HTTP.
|
||||
- **Нельзя** крутить цикл ожидания отдельным async-job'ом и поллить его: либо `podman-compose up` + `until`-гейт + смоук одним синхронным вызовом, либо (если сборка образа долгая и уходит в фон) — по её завершении гейт-цикл синхронно.
|
||||
- Одноразовая проверка в контейнере вообще не ждёт готовности: `podman run --rm <image> <cmd>` блокирующий — читать exit code и stdout.
|
||||
|
||||
Пересоздание фикстур и перевендоривание стилиста — `docs/agent/repo-map.md`. Деплой: **прод** — на пользовательском LAN-сервере; **перед деплоем/перезапуском прочитать `/home/pjandro/prod/java-word-pdf/DEPLOY.md`**; пуск — push в `main` или Run workflow, ручных скриптов нет (детали — `docs/agent/ci-cd.md`).
|
||||
|
||||
## Code Conventions & Common Patterns
|
||||
@@ -119,7 +131,7 @@ python3 docs/standards/docx/validate-fixtures.py wordpdf-core/src/test/resources
|
||||
- Стек: JUnit 6 (`org.junit.jupiter`), только `Assertions` — Mockito/AssertJ не использовать; в app-тестах допустим inline-Hamcrest `containsString` в `andExpect`; тестовые классы package-private, зеркалят main-пакеты. Счётчики — `docs/agent/testing.md`.
|
||||
- **PDF сравнивается текстом, не растеризацией**: PDFBox 3, `PDFTextStripper`; негативные маркеры — `.notdef` (`#`) и `Helvetica`; текст нормализуется по пробелам (`norm`). Пиксельные проверки — только в юнитах chart-пейнтеров (допуски `assertRatio` < 0.06 / < 0.10). Детали — `docs/agent/repo-map.md`.
|
||||
- Регрессивная конвенция: фикс = нормализатор/рендерер + юнит + конвертер-тест; в javadoc фикса — ссылка «Регрессия — Test#имя, фикстура samples/…». Пары `XxxNormalizerTest`↔`тест-в-конвейере` воспроизводятся грепом по этим ссылкам; исключения — `docs/agent/testing.md`.
|
||||
- Фикстуры — только закоммиченные `samples/*.docx` (13) + `samples/*.doc` (12), в тестах не генерировать; контракт нормализаторов «нечего менять → тот же массив» (`assertSame`) + неприкосновенность частей вне `word/*.xml`.
|
||||
- Фикстуры — только закоммиченные `samples/*.docx` (14) + `samples/*.doc` (12), в тестах не генерировать; контракт нормализаторов «нечего менять → тот же массив» (`assertSame`) + неприкосновенность частей вне `word/*.xml`.
|
||||
- App-тесты: `@SpringBootTest` + `@AutoConfigureMockMvc` (Boot 4: `org.springframework.boot.webmvc.test.autoconfigure`); четыре набора свойств = четыре контекста (отдельные классы, не `@Nested`); `ConversionServiceTest`/`ApiExceptionHandlerTest` — без Spring. Core-юниты Spring **не поднимают**; app-тесты проверяют только HTTP-код/заголовки/текст ошибки. Детали — `docs/agent/testing.md`.
|
||||
- Жизненный цикл: только `@Test`; исключения — два `@BeforeAll` (прогрев шрифтов) и `@AfterEach drainWorker` в `ConversionTimeoutTest`. Ни `@Nested`, ни `@ParameterizedTest`, ни `@Disabled`, ни `assertAll`.
|
||||
- Идиомы загрузки фикстур: **core** — classloader без ведущего слэша, **app** — class-relative со слэшем (core test-jar). Синтетика: docx — `ZipOutputStream`, `.doc` — крафт `POIFSFileSystem`.
|
||||
|
||||
+1
-1
@@ -31,7 +31,7 @@ job'ах `images-app`/`images-web` (проверка `REGISTRY`/`REGISTRY_USER`/
|
||||
|`WORDPDF_MAX_MB`|Лимит размера входного .docx, МБ (сейчас `5`)|
|
||||
|`REGISTRY`|Адрес docker-реестра `host:port` без схемы (Nexus docker-registry на прод-сервере, коннектор `:5000`)|
|
||||
|`PIP_INDEX_URL`|Полный URL pypi-proxy индекса Nexus без кредов, вида `http://<host из REGISTRY>:<http-порт Nexus>/repository/pypi-proxy/simple` (репозиторий заводится по разделу «Nexus: анонимный доступ CI» ниже; HTTP-порт Nexus — не docker-коннектор `:5000`)|
|
||||
|`MAVEN_MIRROR_URL`|Полный URL зеркала Nexus maven-central со слэшем на конце: `http://<host из REGISTRY>:<http-порт Nexus>/repository/maven-central/` (репозиторий `maven-central` — штатный proxy на Central из коробки Nexus 3, создавать не надо; заводка доступа — раздел «Nexus: анонимный доступ CI» ниже)|
|
||||
|`MAVEN_MIRROR_URL`|Полный URL зеркала Nexus **maven-public** (group) со слэшем на конце: `http://<host из REGISTRY>:<http-порт Nexus>/repository/maven-public/`. Group содержит `maven-central` (proxy на Central) **и** `maven-hosted` (наш `ru.pjandro:docx4j-fo-renderer-core`, PR-2) — mirror в `.ci/maven-settings.xml` имеет `mirrorOf=*`, поэтому при значении `…/maven-central/` форк-артефакт CI не резолвится (404, fail-closed). Group и доступ — раздел «Nexus: анонимный доступ CI» ниже|
|
||||
|
||||
При смене лимитов прода — править `WORDPDF_MAX_PAGES`/`WORDPDF_MAX_MB` в Variables, PR не нужен: job `deploy` прокидывает их в прод-stack (app пересоздаётся с новыми лимитами), job `autotests` сверяет проверки с ними же. Без обеих Variables job'ы `deploy`/`autotests` падают на проверке — fail-closed.
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# java-word-pdf
|
||||
|
||||
Конвертация **.docx/.doc → PDF** на чистом Java: `docx4j` 17.3.2 + форк
|
||||
Конвертация **.docx/.doc → PDF** на чистом Java: `docx4j` 17.3.6 + форк
|
||||
`Apache FOP`, без LibreOffice/Aspose. Бинарный `.doc` (Word 97–2003) читается
|
||||
собственным мостом [MS-DOC]/[MS-CFB] и переносится в .docx в памяти — дальше
|
||||
идёт тем же конвейером. Шрифты упакованы в jar — конвертация не зависит от
|
||||
@@ -41,7 +41,7 @@ java-word-pdf/
|
||||
|`ru.pjandro.wordpdf.ConversionException`|ошибки конвертации; подтипы `ValidationException` (некорректный вход) и `DrawingFoundException` (`enum Kind {CHARTS, SMARTART, OLE}`)|
|
||||
|`ru.pjandro.wordpdf.fonts.BundledFonts`|выгрузка TTF из jar и регистрация в docx4j|
|
||||
|`ru.pjandro.wordpdf.fonts.BundledFontMapper`|маппинг имён шрифтов документа → TTF|
|
||||
|`ru.pjandro.wordpdf.internal.DocxRewritePipeline`|правила 1–10 нормализации XML-частей одним zip-проходом (+ `OleObjectNormalizer`, правило 11)|
|
||||
|`ru.pjandro.wordpdf.internal.DocxRewritePipeline`|правила 1–9 нормализации XML-частей одним zip-проходом (+ `OleObjectNormalizer`, правило 10)|
|
||||
|`ru.pjandro.wordpdf.internal.doc.DocToDocx`|мост бинарного `.doc` → in-memory `.docx` (`convert`/`countPages`)|
|
||||
|`ru.pjandro.wordpdf.internal.FopFallbackFonts`|декларация fallback-семейства в FOP-конфиге|
|
||||
|`ru.pjandro.wordpdf.internal.chart.DrawingPreRenderer`|диаграммы/SmartArt → PNG до XSL-FO|
|
||||
@@ -294,15 +294,16 @@ Dev-режим без контейнеров: бэкенд `java -jar wordpdf-ap
|
||||
1. Вход проверяется до рендера: размер → сигнатура (zip PK или CFB) → (.docx:
|
||||
контейнер и страницы lightweight-StAX по zip; .doc: страницы по чистому
|
||||
бинарному документу мостом) — `WordPdfValidator`, без зависимости от docx4j.
|
||||
2. XML-части переписывает `DocxRewritePipeline` одним zip-проходом — десять
|
||||
2. XML-части переписывает `DocxRewritePipeline` одним zip-проходом — восемь
|
||||
правил (порядок значим): strict→transitional (`w:start`/`w:end`, проценты),
|
||||
`on/off` → `true/false` (иначе docx4j теряет значение, и regular-раны
|
||||
рендерились жирным курсивом), маркеры Symbol/Wingdings → Unicode (вместо «#»),
|
||||
поля `PAGE`/`NUMPAGES` → `w:fldSimple` (пересчитываются, а не печатают кэш
|
||||
из docx), невидимые символы, раны со знаками вне их шрифта (резка по покрытию
|
||||
глифов), `w:jc` center/right + `w:tblInd` → абсолютный отступ таблицы,
|
||||
`w:suff="space"` → пробел в номере списка, скрытые раны (`w:vanish`), руби
|
||||
(надстрочница вырезается). Затем вычищаются OLE-объекты (правило 11,
|
||||
рендерились жирным курсивом), невидимые символы, раны со знаками вне их
|
||||
шрифта (резка по покрытию глифов), `w:jc` center/right + `w:tblInd` →
|
||||
абсолютный отступ таблицы, `w:suff="space"` → пробел в номере списка,
|
||||
скрытые раны (`w:vanish`), руби (надстрочница вырезается). Маркеры
|
||||
Symbol/Wingdings и поля `PAGE`/`NUMPAGES` не переписываем — с docx4j 17.3.x
|
||||
экспорт делает это сам (маркеры → Unicode, complex-поля → пересчёт вместо
|
||||
кэша). Затем вычищаются OLE-объекты (правило 10,
|
||||
`OleObjectNormalizer`, картинка-плейсхолдер сохраняется).
|
||||
3. Документ загружается в `WordprocessingMLPackage`, привязывается
|
||||
`BundledFontMapper`.
|
||||
@@ -326,9 +327,9 @@ Dev-режим без контейнеров: бэкенд `java -jar wordpdf-ap
|
||||
целиком на SIL OFL.
|
||||
- Поддержка таблиц/изображений — базовая (через docx4j/FOP).
|
||||
- Часть расхождений с Word — неустранимые невозможности FOP/docx4j
|
||||
(`jc="distribute"`, `suff="tab"`, кернинг, `framePr`, кэш `REF`/`SEQ`/`TOC`,
|
||||
(`jc="distribute"`, `suff="tab"`, кернинг, кэш `REF`/`SEQ`/`TOC`,
|
||||
надстрочница руби) — полный перечень с доказательствами:
|
||||
`docs/agent/render-limitations.md`.
|
||||
`docs/agent/render-limitations.md`. `w:framePr` с docx4j 17.3.6 позиционируется.
|
||||
- На `.doc` error-флаги диаграмм/SmartArt/OLE не срабатывают: BLIP-плейсхолдеры
|
||||
бинарного формата — уже растры, они вставляются картинками; EMF/WMF/PICT
|
||||
пропускаются с warn.
|
||||
|
||||
File diff suppressed because one or more lines are too long
+16
-14
@@ -6,11 +6,11 @@
|
||||
|---|---|---|
|
||||
| 0 | `DependencyGuard.check()` | API-проба `ZipArchiveInputStream.getNextEntry()` — совместимость commons-compress ≥ 1.25.0; иначе `ConversionException` с инструкцией вместо мутного `NoSuchMethodError` внутри docx4j |
|
||||
| 1 | `new BundledFontMapper()` → `BundledFonts.init()` → `restrictToBundled()` | Конструктор маппера (static `BestMatchingMapper`) регистрирует в `PhysicalFonts` только symbol-шрифты из `docx4j-export-fo-fonts-symbol` (сканы системы и jar'ов отключены в static-блоке `WordPdfConverter` гейт-свойствами — всё найденное всё равно выбрасывает `restrictToBundled()`); `init()` вызывает `dropNonBundled()` **до** регистрации бандла, `restrictToBundled()` оставляет реестр = бандл + встроенные в docx. Порядок `init()` после конструктора — инвариант: `addPhysicalFont` не перезаписывает занятый ключ (иначе системный Calibri ломает em-dash-fallback) |
|
||||
|2|`DocxRewritePipeline.STEP` → `OleObjectNormalizer` → `WordprocessingMLPackage.load`|Один zip-проход переписывания XML-частей (правила 1–10 — раздел «Нормализаторы: контракт и правила 1–11» в этом файле) + условная OLE-вычистка (правило 11)|
|
||||
|2|`DocxRewritePipeline.STEP` → `OleObjectNormalizer` → `WordprocessingMLPackage.load`|Один zip-проход переписывания XML-частей (правила 1–9 — раздел «Нормализаторы: контракт и правила 1–10» в этом файле) + условная OLE-вычистка (правило 10)|
|
||||
| 3 | `pkg.setFontMapper(mapper)` | Привязка шрифтов документа к физическим TTF |
|
||||
| 3.5 | `DrawingPreRenderer.run(pkg, options)` | `c:chart`/`dgm:relIds` → PNG 300 dpi → `pic:pic` (docx2fo.xslt их не умеет) |
|
||||
| 4 | `new FOSettings(pkg)` + `FopFallbackFonts.declare(foSettings)` | В FOP-конфиг добавляются **все** бандл-семейства: FOP встраивает только задекларированные |
|
||||
| 4.25 | `LayoutPostRenderer.register(foSettings)` | Кастомный `FORenderer`: post-FO padding-компенсация таблиц (`start-indent` += `padding-left` первой ячейки), внутри — штатный `FORendererApacheFOP` |
|
||||
| 4.25 | `LayoutPostRenderer.register(foSettings)` | Кастомный `FORenderer`: post-FO padding-компенсация таблиц (`start-indent` += `padding-left` первой ячейки) + justify-пара блокам с якорем `pj-distribute-` (правило 9), внутри — штатный `FORendererApacheFOP` |
|
||||
| 4.5 | `foSettings.setCustomXsltTemplates(VendoredXslt.TEMPLATES)` | Стилист — вендорный `xslt/docx2fo.xslt` (копия docx4j-export-fo + AUDIT-FIX-патчи: `w:rPr/w:position`→`baseline-shift` и AUDIT-FIX-2 `moveFrom`/`moveTo`/`bdo`/`dir`); `Templates` компилируется один раз — `getTemplates` кастит значение в `Templates` |
|
||||
| 5 | `FORendererApacheFOP.getFopFactoryBuilder` + `getFOUserAgent` | Непустой `title` → заголовок PDF |
|
||||
| 6 | `Docx4J.toFO(foSettings, os, FLAG_EXPORT_PREFER_XSL)` | XSL-FO → PDF |
|
||||
@@ -22,24 +22,26 @@
|
||||
|
||||
### Валидация входа и подсчёт страниц
|
||||
|
||||
Вход валидируется **до** `convertToStream`: `WordPdfValidator.validate(bytes, options)` (размер → подпись: zip `PK\x03\x04` или CFB `D0 CF 11 E0` → контейнер → страницы). Для `.doc` страницы считаются **по сырым байтам .doc, до конвертации**: `checkPageCountDoc` = `max(SummaryInfo PageCount, 1 + явные разрывы)`; явные — 0x0C в основном тексте + `sprmPFPageBreakBefore` из PAPX. Тот же метод — вход приложения. Скан выполняется ровно один раз по сырому входу, до аллокаций docx4j: правила 1–10 число учитываемых разрывов не увеличивают (правило 9 способно только убрать разрыв внутри скрытого рана — счёт по сырому входу остаётся верхней оценкой лимита).
|
||||
Вход валидируется **до** `convertToStream`: `WordPdfValidator.validate(bytes, options)` (размер → подпись: zip `PK\x03\x04` или CFB `D0 CF 11 E0` → контейнер → страницы). Для `.doc` страницы считаются **по сырым байтам .doc, до конвертации**: `checkPageCountDoc` = `max(SummaryInfo PageCount, 1 + явные разрывы)`; явные — 0x0C в основном тексте + `sprmPFPageBreakBefore` из PAPX. Тот же метод — вход приложения. Скан выполняется ровно один раз по сырому входу, до аллокаций docx4j: правила 1–8 число учитываемых разрывов не увеличивают (правило 7 способно только убрать разрыв внутри скрытого рана — счёт по сырому входу остаётся верхней оценкой лимита).
|
||||
|
||||
- Страницы в валидаторе = `max(кэш docProps/app.xml, явные разрывы, lastRenderedPageBreak+1)`; explicit = межсекционные `w:sectPr` в body + `w:br type="page"` + `pageBreakBefore` (включая таблицы и `w:sdt`). Единственный путь — lightweight (StAX по zip, secure-ридер без DTD/external entities; `WordPdfValidator` не зависит от docx4j): атрибуты — по локальному имени (`attrLocal`, не по transitional-URI: иначе в strict-документе `w:br type="page"` не засчитываются); `sectPr` внутри `pPr` не считает, последнюю body-direct секцию не считает, `continuous`-секции не считает, в колонтитуках — только `w:br type="page"`, `pageBreakBefore` — только внутри `pPr` вне `sectPr` (truthy `val`: `null|true|1|on`). На не-zip молчит — подпись проверяет вызывающий. `checkPageCount` — один стриминговый проход `ZipInputStream` без буферизации частей (хелпер `noClose` глушит `close()` сканеров): потребление O(одной части) вместо O(суммы XML-частей).
|
||||
|
||||
### Нормализаторы: контракт и правила 1–11 (детали)
|
||||
### Нормализаторы: контракт и правила 1–10 (детали)
|
||||
|
||||
Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame` в тестах). Десять rewrite-нормализаторов цепляются в фиксированном порядке Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby; константу `STEP` (`public static final DocxNormalizer`) выставляют девять из десяти (нет только у `RubyNormalizer` — он цепочный, подключается внутри пайплайна), у `OleObjectNormalizer` STEP **нет** — он подключается лямбдой в `WordPdfConverter.normalizers()`. Правила 1–10 применяет `internal/DocxRewritePipeline` — **один zip-проход**: к каждой записи `word/*.xml` рерайты применяются последовательно (каждое правило работает только содержимым одной части — по-частная цепочка эквивалентна последовательным полным проходам); до прохода из `word/document.xml` извлекается полоса набора (`TableIndentNormalizer.bandOf`, −1 — полосы нет), и `word/headerN.xml`/`footerN.xml` дополнительно прогоняются через `TableIndentNormalizer.rewritePart` с этой полосой, и из `word/styles.xml` читается множество vanish-стилей (`HiddenTextNormalizer.vanishStyles`, цепочка `w:basedOn`) — контекст правила 9; неизменённые записи переносятся raw-копией сжатых байтов (без inflate/deflate); нигде не поменялось → тот же массив. `OleObjectNormalizer` — второй условный проход (меняет части, а не XML). Индивидуальные `normalize()` десяти нормализаторов сохранены (контракт юнит-тестов), но `WordPdfConverter` их не вызывает — его `normalizers(options)` = `DocxRewritePipeline.STEP` + лямбда OLE. Порядок правил значим:
|
||||
Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame` в тестах). Девять rewrite-нормализаторов цепляются в фиксированном порядке Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby→Distribute; константу `STEP` (`public static final DocxNormalizer`) выставляют восемь из девяти (нет только у `RubyNormalizer` — он цепочный, подключается внутри пайплайна), у `OleObjectNormalizer` STEP **нет** — он подключается лямбдой в `WordPdfConverter.normalizers()`. Правила 1–9 применяет `internal/DocxRewritePipeline` — **один zip-проход**: к каждой записи `word/*.xml` рерайты применяются последовательно (каждое правило работает только содержимым одной части — по-частная цепочка эквивалентна последовательным полным проходам); до прохода из `word/document.xml` извлекается полоса набора (`TableIndentNormalizer.bandOf`, −1 — полосы нет), и `word/headerN.xml`/`footerN.xml` дополнительно прогоняются через `TableIndentNormalizer.rewritePart` с этой полосой, и из `word/styles.xml` читается множество vanish-стилей (`HiddenTextNormalizer.vanishStyles`, цепочка `w:basedOn`) — контекст правила 7; неизменённые записи переносятся raw-копией сжатых байтов (без inflate/deflate); нигде не поменялось → тот же массив. `OleObjectNormalizer` — второй условный проход (меняет части, а не XML). Индивидуальные `normalize()` девяти нормализаторов сохранены (контракт юнит-тестов), но `WordPdfConverter` их не вызывает — его `normalizers(options)` = `DocxRewritePipeline.STEP` + лямбда OLE. Порядок правил значим:
|
||||
|
||||
1. `StrictOoxmlNormalizer` — strict-OOXML → transitional: `a:`-проценты и `w14:fillToRect` → тысячные ×1000, текст `wp14:pctWidth`/`pctHeight`; элементы `w:start`/`w:end` → `w:left`/`w:right` (кроме `w:lvl/w:start` в numbering.xml); значения `w:val="start"/"end"` у `w:jc` и `w:tab` правятся **всегда** (docx4j `Justification.setXslFO` знает только left/center/right/both, для END `fo:text-align` не пишет вовсе — `jc="end"` рендерился по левому краю; Part 1 §17.3.1.13: `jc val="end"` — правовыравнивание в LTR, ST_Jc §17.18.44; RTL вне контура — FOP без complex-script). Strict-ность части определяется наличием `http://purl.oclc.org` (не «transitional-URI в документе» — mixed-документ трактуется по каждой части). **Guard сосуществования форм**: атрибут `w:start`/`w:end` переименовывается только внутри открывающего тега `w:ind` (MS-OI29500 §2.1.174a — псевдонимы left/right; у `w:pgNumType` `w:start` — старт нумерации страниц, легален в transitional, Part 1 §17.13.7 — не трогается) и не переименовывается, если в том же открывающем теге уже есть `w:left`/`w:right` (дубль атрибута ломает well-formedness — регрессии `indCoexistLeftStartUntouched`, `indCoexistForms_convertsNotRejected`, `pgNumTypeStartAttrUntouched`); элементы `w:start`/`w:end` в strict-части переименовываются глобально, в transitional — только внутри `w:tcMar`/`w:tblCellMar` без одноимённого соседа (`maxOccurs=1` на left). Ничего не поменялось → `rewrite` вернул `null` → исходный массив (`StrictOoxmlNormalizerTest#transitionalCoexistReturnsOriginalArray`).
|
||||
2. `DocxOnOffNormalizer` — `w:val="off"/"on"` → `"false"/"true"`; якорь по тегу, правится только атрибут `w:val`, текст между тегами не трогается.
|
||||
3. `SymbolFontNormalizer` — PUA U+F000–U+F0FF (Symbol/Wingdings/Webdings) → Unicode + DejaVu Sans; переписывает `<w:sym>`, правит `w:lvl` в numbering.xml; 5 карт по 256 слотов (таблица `SymbolMapper` из docx4j 17.x).
|
||||
4. `FieldNormalizer` — `fldChar` PAGE/NUMPAGES/SECTIONPAGES → `w:fldSimple` (кэш страниц в PDF не попадает); вложенные/битые поля пропускаются.
|
||||
5. `InvisibleCharNormalizer` — вырезает из `w:t` U+0085, U+2028, U+2029, U+200E/200F, U+202A–202E, U+2060, U+FEFF (FOP делает из них переносы/пустые строки, Arimo/Tinos рисуют боксы). U+00A0/U+00AD/U+200B–U+200D **не** трогает.
|
||||
6. `GlyphCoverageNormalizer` — режет раны по покрытию глифов и пишет семейство в `w:rFonts`, иначе FOP рисует «#». Покрытие — `GlyphFont` (fontbox, cmap) + BitSet-кэш, **не** docx4j `GlyphCheck` (плодит INFO-лог; `java.awt.Font` требовал fontconfig на хосте). Для serif-ран fallback ищется сначала в `SERIF_FAMILIES` (`dejavu serif`, `tinos`, `caladea`), затем в sans.
|
||||
7. `TableIndentNormalizer` — свёртка `w:tblPr/w:jc` (center/right) с любым (в т.ч. отсутствующим/нулевым) `w:tblInd` в абсолютный `w:tblInd` с удалением `w:jc` (Word: tblInd — сдвиг от поля после центрирования, MS-OI29500 §2.1.155; docx4j при jc≠left игнорирует tblInd буквально — Part 1 §17.4.50, а центрированию пишет абсолютный start-indent **без** вычета cellMar, поверх которого padding-компенсация правила LayoutPostRenderer уводит текст на +padding — свёртка обязательна и при X=0): center → (W−T)/2+X, right → (W−T)+X, W — полоса набора (pgSz − pgMar left/right в transitional и `w:start`/`w:end` в strict; дефолты 11906/1440 — измеренное поведение docx4j, не ECMA-1800), T — Σ gridCol; пропускает несколько body-level `sectPr`, не-dxa `tblInd`, `tblPr` с `tblCellSpacing` без `tblInd` (нет корректной позиции вставки по CT_TblPrBase), `tblW pct`, нецелые gridCol. Кроме `rewrite`/`STEP` (document.xml, полоса из собственного sectPr) есть `rewritePart(part, xml, band)` — `word/headerN.xml`/`footerN.xml` с полосой из document.xml (в частях колонтитуков своего sectPr нет) и `bandOf(documentXml)` — экстрактор полосы (−1 — полосы нет). Регрессия — WordPdfConverterTest#tableIndentCentered_shiftedLikeWord, #headerTableIndent_centeredInHeader, #tableCenteredNoIndent_shiftedLikeWord.
|
||||
8. `NumberingSuffixNormalizer` — `w:suff w:val="space"` → дописанный обычный пробел в конце следующего `w:lvlText` того же уровня (порядок CT_Lvl suff→lvlText, wml.xsd; Part 1 §17.3.1.28): docx4j разделитель не эмитит вовсе (дамп n4.fo); уже пробельный lvlText не дублируется; suff=tab — отдельный Class C-остаток (нужна per-item ширина), nothing совпадает с docx4j. Регрессия — WordPdfConverterTest#suffSpace_labelGetsSpace.
|
||||
9. `HiddenTextNormalizer` — вырезание скрытых ранов (Part 1 §17.3.2.30): truthy `w:vanish` в собственном `w:rPr` ранa (обе OnOff-формы; вал опущен — default true) **или** `w:rStyle` ∈ vanish-стили из `word/styles.xml` (транзитивно по `w:basedOn`, капа цепочки 16, цикл — обрыв); ран с защищённым содержимым (`fldChar`/`instrText`/`footnoteReference`/`endnoteReference`/`drawing`/`pict`/`object`/`txbxContent`) не трогается — удаление спаренных `begin…separate…end` сломало бы поле. Word скрытое не печатает, стилист docx4j `vanish` не читает вовсе → без правила скрытое утекало в PDF. Индивидуальный `normalize()` — свой pass styles.xml. Регрессия — WordPdfConverterTest#hiddenText_notPrinted, юниты — HiddenTextNormalizerTest.
|
||||
10. `RubyNormalizer` — разбор руби-разметки (Part 1 §17.3.3.18/.19/.20/.21): `w:rubyBase`/`w:rubyBaseText` разворачиваются в обычные раны, `w:rt`/`w:rubyPr`/`w:rubyAlign` вырезаются с содержимым (надстрочница — принятая деградация, ruby-разметки в FOP нет; потеря текста хуже потери аннотации). Чинится **в байтах**, а не в XSLT: схема docx4j 17.3.2 не биндит `w:rubyBase`/`w:rt` в `w:r` — unmarshaller теряет их до стилиста (в отличие от `moveFrom`/`moveTo`/`bdo`/`dir`, которых схема знает — тех ловит AUDIT-FIX-2). Регрессия — WordPdfConverterTest#rubyBase_textPrinted, юниты — RubyNormalizerTest.
|
||||
11. `OleObjectNormalizer` — принимает флаг `errorOnOle`. Два этапа: дешёвый детект по центральному каталогу zip (`ZipFile`; читаются только `[Content_Types].xml` и `word/*.xml` до первого `<w:object`; не-zip/нет центрального каталога → входной массив — прежняя снисходительность), переупаковка — только при находке. Детект OLE-бинарников — по `[Content_Types].xml`: тип `…oleObject` **или** ложный `+xml`-тип у `.bin` (XML в bin не бывает; `printerSettings` не трогается). Удаляются вместе с rels-ссылками (по типу, включая `TargetMode=External`) и Override удалённых частей. Элементы `<w:object>` из `word/*.xml` не выбрасываются, а заменяются статичным представлением — картинкой-плейсхолдером (ECMA-376 §15.2.10): `w:drawing` переиспользуется дословно, `v:imagedata r:id` → inline-DrawingML на ту же image-часть (размер из `style` `v:shape`, иначе `w:dxaOrig`/`w:dyaOrig` ×635), блоки с `w:control` и без плейсхолдера удаляются. OLE-бинарники никогда не читаются. При `errorOnOle=true` вместо вычистки — `DrawingFoundException(OLE)`. Лечит оба механизма падения docx4j: JAXB-разбор бинарника под ложным XML-типом («Content is not allowed in prolog» → NPE) и NPE `chunkType is null` в VML-сериализации `w:object`. Многочастный: публичный член только `normalize(byte[], boolean)`, `rewrite`-хука нет.
|
||||
|
||||
> Правил symbol-шрифтов (PUA U+F000–U+F0FF → Unicode) и complex-полей PAGE/NUMPAGES/SECTIONPAGES → `w:fldSimple` в цепочке больше нет — их удалил апгрейд docx4j до 17.3.x: экспорт сам маппит символ-маркеры и пересчитывает page-поля вместо кэша. Пины отсутствия регрессии — `WordPdfConverterTest#symbolFonts_bulletsAreNotHash`, `pageNumbers_recomputedNotCached`.
|
||||
|
||||
3. `InvisibleCharNormalizer` — вырезает из `w:t` U+0085, U+2028, U+2029, U+200E/200F, U+202A–202E, U+2060, U+FEFF (FOP делает из них переносы/пустые строки, Arimo/Tinos рисуют боксы). U+00A0/U+00AD/U+200B–U+200D **не** трогает.
|
||||
4. `GlyphCoverageNormalizer` — режет раны по покрытию глифов и пишет семейство в `w:rFonts`, иначе FOP рисует «#». Покрытие — `GlyphFont` (fontbox, cmap) + BitSet-кэш, **не** docx4j `GlyphCheck` (плодит INFO-лог; `java.awt.Font` требовал fontconfig на хосте). Для serif-ран fallback ищется сначала в `SERIF_FAMILIES` (`dejavu serif`, `tinos`, `caladea`), затем в sans.
|
||||
5. `TableIndentNormalizer` — свёртка `w:tblPr/w:jc` (center/right) с любым (в т.ч. отсутствующим/нулевым) `w:tblInd` в абсолютный `w:tblInd` с удалением `w:jc` (Word: tblInd — сдвиг от поля после центрирования, MS-OI29500 §2.1.155; docx4j при jc≠left игнорирует tblInd буквально — Part 1 §17.4.50, а центрированию пишет абсолютный start-indent **без** вычета cellMar, поверх которого padding-компенсация правила LayoutPostRenderer уводит текст на +padding — свёртка обязательна и при X=0): center → (W−T)/2+X, right → (W−T)+X, W — полоса набора (pgSz − pgMar left/right в transitional и `w:start`/`w:end` в strict; дефолты 11906/1440 — измеренное поведение docx4j, не ECMA-1800), T — Σ gridCol; пропускает несколько body-level `sectPr`, не-dxa `tblInd`, `tblPr` с `tblCellSpacing` без `tblInd` (нет корректной позиции вставки по CT_TblPrBase), `tblW pct`, нецелые gridCol. Кроме `rewrite`/`STEP` (document.xml, полоса из собственного sectPr) есть `rewritePart(part, xml, band)` — `word/headerN.xml`/`footerN.xml` с полосой из document.xml (в частях колонтитуков своего sectPr нет) и `bandOf(documentXml)` — экстрактор полосы (−1 — полосы нет). Регрессия — WordPdfConverterTest#tableIndentCentered_shiftedLikeWord, #headerTableIndent_centeredInHeader, #tableCenteredNoIndent_shiftedLikeWord.
|
||||
6. `NumberingSuffixNormalizer` — `w:suff w:val="space"` → дописанный обычный пробел в конце следующего `w:lvlText` того же уровня (порядок CT_Lvl suff→lvlText, wml.xsd; Part 1 §17.3.1.28): docx4j разделитель не эмитит вовсе (дамп n4.fo); уже пробельный lvlText не дублируется; suff=tab — отдельный Class C-остаток (нужна per-item ширина), nothing совпадает с docx4j. Регрессия — WordPdfConverterTest#suffSpace_labelGetsSpace.
|
||||
7. `HiddenTextNormalizer` — вырезание скрытых ранов (Part 1 §17.3.2.30): truthy `w:vanish` в собственном `w:rPr` ранa (обе OnOff-формы; вал опущен — default true) **или** `w:rStyle` ∈ vanish-стили из `word/styles.xml` (транзитивно по `w:basedOn`, капа цепочки 16, цикл — обрыв); ран с защищённым содержимым (`fldChar`/`instrText`/`footnoteReference`/`endnoteReference`/`drawing`/`pict`/`object`/`txbxContent`) не трогается — удаление спаренных `begin…separate…end` сломало бы поле. Word скрытое не печатает, стилист docx4j `vanish` не читает вовсе → без правила скрытое утекало в PDF. Индивидуальный `normalize()` — свой pass styles.xml. Регрессия — WordPdfConverterTest#hiddenText_notPrinted, юниты — HiddenTextNormalizerTest.
|
||||
8. `RubyNormalizer` — разбор руби-разметки (Part 1 §17.3.3.18/.19/.20/.21): `w:rubyBase`/`w:rubyBaseText` разворачиваются в обычные раны, `w:rt`/`w:rubyPr`/`w:rubyAlign` вырезаются с содержимым (надстрочница — принятая деградация, ruby-разметки в FOP нет; потеря текста хуже потери аннотации). Чинится **в байтах**, а не в XSLT: схема docx4j 17.3.6 не биндит `w:rubyBase`/`w:rt` в `w:r` — unmarshaller теряет их до стилиста (в отличие от `moveFrom`/`moveTo`/`bdo`/`dir`, которых схема знает — тех ловит AUDIT-FIX-2). Регрессия — WordPdfConverterTest#rubyBase_textPrinted, юниты — RubyNormalizerTest.
|
||||
9. `DistributeStampNormalizer` — `w:pPr/w:jc w:val="distribute"` → невидимая закладка-якорь `w:bookmarkStart w:name="pj-distribute-<часть>-<n>"` сразу после `</w:pPr>` (Part 1 §17.18.44): docx4j для DISTRIBUTE не эмитит в FO ничего, канонический эквивалент — пара `text-align`/`text-align-last="justify"`, но стилист править нельзя (дрейф-гейт), а `LayoutPostRenderer` опознаёт абзац только по якорю — `BookmarkStartWriter` делает из закладки `<fo:inline id="pj-distribute-…"/>` первым инлайн-ребёнком блока, фильтр дописывает блоку justify-пару (сериализация без префикса `fo:` учтена паттерном). Штампуются контентные части (document/footnotes/endnotes, `headerN`/`footerN` — якорь работает и в колонтитулах; в numbering у `CT_Lvl` закладок не бывает, `w:jc` в `trPr`/`tblPr` не читается — разбор только внутри `w:pPr`, первого ребёнка `w:p`, §17.3.1.23); старое `jc` внутри `w:pPrChange` (реvision) — не текущее выравнивание: окно поиска режется началом реvision, штамп ставится после наружного `</w:pPr>`; счётчик id от max существующих +1, идемпотентность позиционная (штамп всегда сразу за закрытием pPr). Идёт после Hidden, чтобы не штамповать вырезанный абзац. Регрессия — WordPdfConverterTest#distribute_allLinesReachRightMargin, юниты — DistributeStampNormalizerTest, пин форка — DistributeLineTestCase.
|
||||
10. `OleObjectNormalizer` — принимает флаг `errorOnOle`. Два этапа: дешёвый детект по центральному каталогу zip (`ZipFile`; читаются только `[Content_Types].xml` и `word/*.xml` до первого `<w:object`; не-zip/нет центрального каталога → входной массив — прежняя снисходительность), переупаковка — только при находке. Детект OLE-бинарников — по `[Content_Types].xml`: тип `…oleObject` **или** ложный `+xml`-тип у `.bin` (XML в bin не бывает; `printerSettings` не трогается). Удаляются вместе с rels-ссылками (по типу, включая `TargetMode=External`) и Override удалённых частей. Элементы `<w:object>` из `word/*.xml` не выбрасываются, а заменяются статичным представлением — картинкой-плейсхолдером (ECMA-376 §15.2.10): `w:drawing` переиспользуется дословно, `v:imagedata r:id` → inline-DrawingML на ту же image-часть (размер из `style` `v:shape`, иначе `w:dxaOrig`/`w:dyaOrig` ×635), блоки с `w:control` и без плейсхолдера удаляются. OLE-бинарники никогда не читаются. При `errorOnOle=true` вместо вычистки — `DrawingFoundException(OLE)`. Лечит оба механизма падения docx4j: JAXB-разбор бинарника под ложным XML-типом («Content is not allowed in prolog» → NPE) и NPE `chunkType is null` в VML-сериализации `w:object`. Многочастный: публичный член только `normalize(byte[], boolean)`, `rewrite`-хука нет.
|
||||
|
||||
`mc-preprocessor.xslt` docx4j (в jar `docx4j-core`) перебивает strict-namespace'ы в transitional и конвертит `pt` в twips/half-points, но ветку перевода процентов в тысячные для namespace'ных атрибутов содержит с закомментированным `<xsl:value-of select="$cleanValue * 1000"/>` (для атрибутов без namespace — она активна), а `w:start`/`w:end` в `w:left`/`w:right` не маппит вовсе. Поэтому собственный рерайт URI ломать нельзя — он сломал бы pt-конверсию preprocessor'а (FOP получил бы «10pt»).
|
||||
|
||||
@@ -4,6 +4,6 @@
|
||||
|
||||
- Известный остаток эталона: U+2188/U+218A — глифов нет в OFL-шрифтах бандла, остаются `.notdef` (GNU FreeSerif GPL — не добавляем намеренно).
|
||||
|
||||
- Аудит раскладки по ECMA-376 Part 1 (2026-10) — известные нечинимые ограничения FOP/docx4j (Java-слой): `w:jc="distribute"` рендерится как left — межсимвольного распределения в FOP нет (ST_Jc §17.18.44: distribute — межсимвольный разнос, justify только межсловный), последняя строка блока не растягивается, свойства `text-align-last` в форке нет (в docx4j-fo-renderer отсутствуют классы TextAlign*); `w:suff="tab"` и `w:lvlJc` игнорируются (numbering-лейбл всегда через hanging-tab; suff=space чинит правило 8, suff=nothing совпадает с docx4j — разделителя нет); абзац без `w:line` рендерится natural-высотой FOP 15.44pt@11pt, явный `lineRule="auto"` — 13.4277pt, два «single» в конвертере (13.4277 — канонический single по метрикам Carlito/Calibri 2500/2048 em; обе величины считаются по метрикам шрифта); кернинг не применяется ни для одного бандл-семейства (замер: advance A→V = A→A — Carlito 6.369pt, DejaVu Sans 7.524pt@11pt): 22 TTF — GPOS-only, а legacy `kern`-таблица DejaVu Sans/Serif ключована glyph id, не совпадающими с cmap (2568/2727 пар без Unicode-маппинга, пары A→V нет) — латинский путь FOP (`TextLayoutManager`→`Font.hasKerning`) читает только legacy `kern` и такие пары отбрасывает; свойства `kerning` в форке нет, порог `w:kern` через FO не выражается. Word кернит только при явно заданном `w:kern` в иерархии стилей и при sz ≥ val (Part 1 §17.3.2.19; при отсутствии `w:kern` Office не кернит — MS-OI29500 §21.1.2.3.9a) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 7), `w:suff="space"` (правило 8).
|
||||
- Аудит раскладки по ECMA-376 Part 1 (2026-10, реаудит на docx4j 17.3.6 + форке FOP 2.12 — 2026-11) — известные нечинимые ограничения FOP/docx4j (Java-слой): `w:lvlJc` игнорируется (numbering-лейбл всегда у number position: `lvlJc="right"`/`"center"` рендерятся идентично `left` — лейблы по общему левому краю; suff=space чинит правило 6, suff=nothing совпадает с docx4j — разделителя нет); абзац без `w:line` рендерится natural-высотой FOP 15.44pt@11pt, явный `lineRule="auto"` — 13.4277pt, два «single» в конвертере (13.4277 — канонический single по метрикам Carlito/Calibri 2500/2048 em; обе величины считаются по метрикам шрифта); кернинг не применяется ни для одного бандл-семейства (замер на 17.3.6/форке 2.12: dx пары = сумма advance без поправки — Carlito «Wa»/«AV», DejaVu Sans «Ta»; GPOS-only у 22 TTF, а legacy `kern`-таблица DejaVu Sans/Serif ключована glyph id, не совпадающими с cmap (2568/2727 пар без Unicode-маппинга, пары A→V нет) — латинский путь FOP (`TextLayoutManager`→`Font.hasKerning`) читает только legacy `kern` и такие пары отбрасывает; GPOS-путь в форке тоже не применяется); свойства `kerning` в форке нет, порог `w:kern` через FO не выражается. Word кернит только при явно заданном `w:kern` в иерархии стилей и при sz ≥ val (Part 1 §17.3.2.19; при отсутствии `w:kern` Office не кернит — MS-OI29500 §21.1.2.3.9a) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 5), `w:suff="space"` (правило 6). Починено на 17.3.6+форке: `w:jc="distribute"` (правило 9 `DistributeStampNormalizer` ставит закладку-якорь, `LayoutPostRenderer` дописывает блоку пару `text-align`/`text-align-last="justify"` — межсловный разнос всех строк, включая последнюю; пин в форке `DistributeLineTestCase`, в конвертере `distribute_allLinesReachRightMargin`; межсимвольный kashida-разнос §17.18.44 не реализован — для латиницы Word разносит межсловные пробелы, однословная строка не растягивается, потому что растягивать нечем). Починено апстримом 17.3.6: `w:framePr` (фрейм `hAnchor="page"` позиционируется: текст на x=180pt от края страницы — `w:x=3600` twips при `hAnchor="page"` отсчитывается от края страницы, не от поля, §17.4.31; пин — фикстура frame-pr.docx и WordPdfConverterTest#framePr_positionedLikeWord; до апгрейда текст шёл в общем потоке), symbol-шрифты и complex-поля PAGE/NUMPAGES (экспорт сам маппит PUA-маркеры и пересчитывает page-поля).
|
||||
|
||||
- Аудит .docx-путей по ECMA-376 (2026-11) — запинено синтетикой (без фикстур): сноски/концевые сноски с номерами (§17.11), внешние гиперссылки с `/URI`-аннотацией (§17.12.23), `PAGEREF` (complex и вложенный в результат `TOC`) и `DATE` подменяют кэш живым значением, `titlePg` → first/default колонтитуки (§17.13.1.35), `vMerge` restart/continue (§17.4.70), block-level `w:sdt` (§17.5.2), `wps:txbx`-текст (§17.3.3.23), OMML-формулы рисуются вектором jeuclid-fop (§22.1 — текст из PDF не извлекается, пинь пикселями), фон `w:highlight`/`w:shd` рисуется (§17.3.2.16/.29). Скрытый текст `w:vanish` не печатается (правило 9); текст руби-базы и `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir` не теряется (правило 10 + AUDIT-FIX-2). Остаток (не чиним): `w:framePr` игнорируется — текст печатается в общем потоке, геометрия фрейма теряется (ни XSLT, ни `createBlockForPPr` не читают); `REF`/`SEQ`/литеральные записи `TOC` печатают устаревший кэш из docx (движка пересчёта нет; инстринции полей не печатаются); надстрочница руби не выводится (правило 10 печатает только базу — ruby-разметки в FOP нет); `w:ptab` без `@w:alignment`, `bar`, `list` теряются catch-all'ом; `w:bdo`/`w:dir` печатаются LTR (bidi вне контура).
|
||||
- Аудит .docx-путей по ECMA-376 (2026-11) — запинено синтетикой (без фикстур): сноски/концевые сноски с номерами (§17.11), внешние гиперссылки с `/URI`-аннотацией (§17.12.23), `PAGEREF` (complex и вложенный в результат `TOC`) и `DATE` подменяют кэш живым значением, `titlePg` → first/default колонтитуки (§17.13.1.35), `vMerge` restart/continue (§17.4.70), block-level `w:sdt` (§17.5.2), `wps:txbx`-текст (§17.3.3.23), OMML-формулы рисуются вектором jeuclid-fop (§22.1 — текст из PDF не извлекается, пинь пикселями), фон `w:highlight`/`w:shd` рисуется (§17.3.2.16/.29). Скрытый текст `w:vanish` не печатается (правило 7); текст руби-базы и `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir` не теряется (правило 8 + AUDIT-FIX-2). Остаток (не чиним): `REF`/`SEQ`/литеральные записи `TOC` печатают устаревший кэш из docx (движка пересчёта нет; инстринции полей не печатаются); надстрочница руби не выводится (правило 8 печатает только базу — ruby-разметки в FOP нет); `w:ptab` без `@w:alignment`, `bar`, `list` теряются catch-all'ом; `w:bdo`/`w:dir` печатаются LTR (bidi вне контура).
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
|---|---|
|
||||
| `wordpdf-core/src/main/java/ru/pjandro/wordpdf/` | Публичный API: `WordPdfConverter` (`convert(byte[],String,ConvertOptions)`), `WordPdfValidator` (`checkInput`/`validate` наружу; `checkPageCount`/`checkPageCountDoc`/`isBinaryDoc` — package-private, всё без зависимости от docx4j), `ConversionException`, `ValidationException` (наследник — «вход некорректен»), `DrawingFoundException` (`enum Kind {CHARTS, SMARTART, OLE}`), `ConvertOptions` (record; дефолтов в ядре нет). Пороги защиты — производные от лимитов входа: `WordPdfValidator.maxDecompressedBytes`/`maxDecompressedXmlBytes` (`max(MIN_*×MiB, maxMb×10/4MiB + maxPages×64/32KiB)`, крышек нет), `maxZipEntries` (`max(2048, maxMb×512 + maxPages×32)`), `maxImagePixels` (`maxMb×5_000_000`); коэффициенты и полы — package-private литералы `WordPdfConverter` (`DECOMPRESS_*`, `MIN_DECOMPRESSED_*`, `IMAGE_PIXELS_PER_MAX_MB`, `ZIP_ENTRIES_*`, javac их инлайнит — валидатор не инициализирует конвертер) |
|
||||
| `…/wordpdf/fonts/` | `BundledFonts` (реестр/выгрузка TTF), `BundledFontMapper` (алиасы, self-map, `DISPLAY_NAMES`, `bundledFamily`), `GlyphFont` (глиф-движок fontbox) |
|
||||
| `…/wordpdf/internal/` | 11 нормализаторов + `DocxRewritePipeline` (один zip-проход правил 1–10, raw-копия неизменённых записей) + `LayoutPostRenderer` (кастомный `FORenderer`, post-FO padding-компенсация таблиц, шаг 4.25) + интерфейс `DocxNormalizer` + `FopFallbackFonts` + `DependencyGuard` (проверка commons-compress, шаг 0). Классы package-private; `public` — `DocxNormalizer`, `DocxRewritePipeline` (наружу только `STEP`, `normalize` package-private), `OleObjectNormalizer`, `FopFallbackFonts` (`declare`), `LayoutPostRenderer` (`register`), `DependencyGuard` (`check`), остальные нормализаторы полностью package-private; `OleObjectNormalizer` — многочастный, публичный `normalize(byte[], boolean)`, бросает `DrawingFoundException(OLE)` |
|
||||
| `…/wordpdf/internal/` | 9 нормализаторов + `DocxRewritePipeline` (один zip-проход правил 1–8, raw-копия неизменённых записей) + `LayoutPostRenderer` (кастомный `FORenderer`, post-FO padding-компенсация таблиц, шаг 4.25) + интерфейс `DocxNormalizer` + `FopFallbackFonts` + `DependencyGuard` (проверка commons-compress, шаг 0). Классы package-private; `public` — `DocxNormalizer`, `DocxRewritePipeline` (наружу только `STEP`, `normalize` package-private), `OleObjectNormalizer`, `FopFallbackFonts` (`declare`), `LayoutPostRenderer` (`register`), `DependencyGuard` (`check`), остальные нормализаторы полностью package-private; `OleObjectNormalizer` — многочастный, публичный `normalize(byte[], boolean)`, бросает `DrawingFoundException(OLE)` |
|
||||
| `…/wordpdf/internal/doc/` | Мост `.doc` → `.docx`: 18 классов (детали — `docs/agent/doc-bridge.md`) — `CfbReader`, `FibHeader`, `PieceTable`, `Grpprl`, `ChpxIndex`, `PapxIndex`, `Styles`, `Tables`, `Lists`, `Sections`, `FontTable`, `SummaryInfo`, `Headers`, `OfficeArt`, `PrcData`, `DocFile`, `DocxWriter`, `DocToDocx` (публичные `convert`/`countPages`; вложенный `DocxBody` — рендер текста и табличного автомата в XML) |
|
||||
| `…/wordpdf/internal/chart/` |18 классов Java2D-рендера диаграмм/SmartArt в PNG (public: `DrawingPreRenderer.run` и `ChartImageHandler` — второй инстанцируется из `WordPdfConverter`)|
|
||||
| `wordpdf-core/src/main/resources/fonts/` | 30 TTF + 3 лицензии — бинарные фикстуры, часть jar |
|
||||
@@ -34,7 +34,7 @@
|
||||
- `wordpdf-app/src/main/resources/application.properties` — multipart 100MB (`max-file-size`/`max-request-size` + `file-size-threshold=2MB` — части крупнее 2 МБ на диск, не в память; в тон gateway `client_max_body_size 100m`), `wordpdf.convert-timeout=2m`, пустой `wordpdf.api-key`, `server.forward-headers-strategy=framework` (префикс прод-прокси для springdoc) + `springdoc.swagger-ui.persist-authorization=true`; `wordpdf.max-mb`/`max-pages` здесь намеренно нет.
|
||||
- `wordpdf-app/pom.xml` — `spring-boot-maven-plugin` с **явной** execution `repackage` (в 4.1.1 сам не связывается, jar останется тонким); `slf4j-simple` исключён; `spring-boot-starter-webmvc` (Boot 4: переименован из starter-web) + `spring-boot-starter-actuator` (нужен HEALTHCHECK контейнера `/actuator/health`); тест-зависимости: `spring-boot-webmvc-test` (в Boot 4 автоконфиг MockMvc вынесен из starter-test), test-jar core.
|
||||
- `wordpdf-core/pom.xml` — `maven-jar-plugin` execution `test-jar` (публикует фикстуры для app); JaCoCo execution `check` переопределён (LINE 0.90 + BRANCH 0.85).
|
||||
- Корневой `pom.xml` — все версии зависимостей (в модулях версии не объявлять): docx4j `17.3.2`, commons-compress `1.28.0`, slf4j `2.0.20`, JUnit `6.1.3`, PDFBox/fontbox `3.0.8` (`fontbox` — compile в core: глиф-движок `GlyphFont`; `pdfbox` — test в обоих модулях; commons-logging исключён, мост — `jcl-over-slf4j`), POI `5.5.1` (test), Spring Boot `4.1.1` (BOM-import), springdoc `3.1.1`; pluginManagement: compiler `3.16.0`, surefire `3.6.0` с `-Djava.awt.headless=true`, jar `3.5.1`, PMD `3.28.0`, JaCoCo `0.8.15`; пустой дефолт `<argLine>` (для `-Djacoco.skip=true`).
|
||||
- Корневой `pom.xml` — все версии зависимостей (в модулях версии не объявлять): docx4j `17.3.6`, commons-compress `1.28.0`, slf4j `2.0.20`, JUnit `6.1.3`, PDFBox/fontbox `3.0.8` (`fontbox` — compile в core: глиф-движок `GlyphFont`; `pdfbox` — test в обоих модулях; commons-logging исключён, мост — `jcl-over-slf4j`), POI `5.5.1` (test), Spring Boot `4.1.1` (BOM-import), springdoc `3.1.1`; pluginManagement: compiler `3.16.0`, surefire `3.6.0` с `-Djava.awt.headless=true`, jar `3.5.1`, PMD `3.28.0`, JaCoCo `0.8.15`; пустой дефолт `<argLine>` (для `-Djacoco.skip=true`).
|
||||
- `pmd-ruleset.xml` — ruleset PMD (см. Code Conventions).
|
||||
- `.ci/maven-settings.xml` — Maven-зеркало Nexus с URL из `${env.MAVEN_MIRROR_URL}` (общий файл CI-job'ов `java` и Containerfile; координаты стенда в репо не хранятся — Variable/build-arg).
|
||||
- `wordpdf-core/src/main/resources/slf4j-simple.properties` — без него предупреждение лезет в PDF.
|
||||
@@ -107,7 +107,7 @@ unzip -p ~/.m2/repository/org/docx4j/docx4j-export-fo/<версия>/docx4j-expo
|
||||
|
||||
PMD: `failurePriority` в плагине не задан — на практике `verify` валит нарушение любой приоритетности; перечень исключённых правил в AGENTS.md не дублируется — единственный источник `pmd-ruleset.xml`.
|
||||
|
||||
- Нормализаторы — единый контракт `internal/DocxNormalizer` + константа `STEP`; цепочка `WordPdfConverter.normalizers()` = `DocxRewritePipeline.STEP` (правила 1–10 одним zip-проходом) + лямбда `OleObjectNormalizer`; нечего менять → **тот же массив**; package-private хук `static String rewrite(String xml)` для юнит-тестов (возвращает `null` при отсутствии изменений; есть у 10 из 11 — у многочастного `OleObjectNormalizer` нет); у `StrictOoxmlNormalizer` есть также `rewritePart(entryName, xml)`, у `TableIndentNormalizer` — `rewritePart(name, xml, band)` (per-part-логика, хуки пайплайна); правятся только части `word/*.xml`.
|
||||
- Нормализаторы — единый контракт `internal/DocxNormalizer` + константа `STEP`; цепочка `WordPdfConverter.normalizers()` = `DocxRewritePipeline.STEP` (правила 1–8 одним zip-проходом) + лямбда `OleObjectNormalizer`; нечего менять → **тот же массив**; package-private хук `static String rewrite(String xml)` для юнит-тестов (возвращает `null` при отсутствии изменений; есть у 8 из 9 — у многочастного `OleObjectNormalizer` нет); у `StrictOoxmlNormalizer` есть также `rewritePart(entryName, xml)`, у `TableIndentNormalizer` — `rewritePart(name, xml, band)` (per-part-логика, хуки пайплайна); правятся только части `word/*.xml`.
|
||||
|
||||
- Классы в `internal` — `public` (иначе родительский пакет не вызвал бы), но публичные члены наружу только `normalize`/`STEP`/`declare`/`DrawingPreRenderer.run`/`DependencyGuard.check` (`rewrite`, карты — package-private); в `wordpdf-app` всё package-private кроме `WordPdfApplication`.
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
### Счётчики (2026-11)
|
||||
|
||||
- 59 тестовых классов / 898 тестов: core 53/849 (`internal/doc/` 17/225, `internal/chart/` 17/271, `WordPdfConverterTest` 77), app 6/49 (ConvertController 23, ApiKeyFilter 8, ConversionService 5, ApiExceptionHandler 5, ConvertLimits 5, ConversionTimeout 3). Обновлять при изменении набора.
|
||||
- 58 тестовых классов / 906 тестов: core 52/858 (`internal/doc/` 17/232, `internal/chart/` 17/277, `WordPdfConverterTest` 83), app 6/48 (ConvertController 26, ApiKeyFilter 8, ConversionService 5, ApiExceptionHandler 5, ConvertLimits 3, ConversionTimeout 1). Обновлять при изменении набора.
|
||||
|
||||
### Пиксели, метрики шрифтов, стенд без fontconfig
|
||||
|
||||
|
||||
@@ -22,10 +22,13 @@
|
||||
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||
|
||||
<!-- docx4j: последняя стабильная версия на Maven Central -->
|
||||
<docx4j.version>17.3.2</docx4j.version>
|
||||
<!-- commons-compress: версию декларирует docx4j-core 17.3.2 (1.28.0);
|
||||
<docx4j.version>17.3.6</docx4j.version>
|
||||
<!-- commons-compress: версию декларирует docx4j-core 17.3.6 (1.28.0);
|
||||
не завышать — версия привязана к docx4j, а не к свежести -->
|
||||
<commons-compress.version>1.28.0</commons-compress.version>
|
||||
<!-- FOP-оверлей (форк fop-core): репозиторий — Nexus maven-hosted (входит в
|
||||
maven-public); см. AGENTS.md «FOP-оверлей» и ai/xmlgraphics-fop-pj README -->
|
||||
<fop-overlay.version>2.12-docx4j.1-pj.2</fop-overlay.version>
|
||||
<slf4j.version>2.0.20</slf4j.version>
|
||||
|
||||
<!-- Spring Boot + springdoc: последние стабильные на Maven Central -->
|
||||
@@ -77,8 +80,15 @@
|
||||
<artifactId>docx4j-export-fo</artifactId>
|
||||
<version>${docx4j.version}</version>
|
||||
</dependency>
|
||||
<!-- FOP-оверлей: наше ядро FOP (форк org.apache.xmlgraphics:fop-core с
|
||||
word-layout менеджером) вместо docx4j-fo-renderer-core из docx4j-export-fo -->
|
||||
<dependency>
|
||||
<groupId>ru.pjandro</groupId>
|
||||
<artifactId>docx4j-fo-renderer-core</artifactId>
|
||||
<version>${fop-overlay.version}</version>
|
||||
</dependency>
|
||||
<!-- Прямая зависимость ядра (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>
|
||||
<groupId>org.apache.commons</groupId>
|
||||
<artifactId>commons-compress</artifactId>
|
||||
|
||||
@@ -29,6 +29,20 @@
|
||||
<dependency>
|
||||
<groupId>org.docx4j</groupId>
|
||||
<artifactId>docx4j-export-fo</artifactId>
|
||||
<exclusions>
|
||||
<exclusion>
|
||||
<groupId>org.docx4j</groupId>
|
||||
<artifactId>docx4j-fo-renderer-core</artifactId>
|
||||
</exclusion>
|
||||
</exclusions>
|
||||
</dependency>
|
||||
<!-- FOP-оверлей (pj): форк fop-core (word-layout менеджеры: label-align,
|
||||
line-box, tab-транпорт, distribute-пин) вместо docx4j-fo-renderer-core;
|
||||
репозиторий — Nexus maven-hosted (входит в maven-public). Тонкий
|
||||
docx4j-fo-renderer (маркер Docx4jFop) остаётся из docx4j-export-fo. -->
|
||||
<dependency>
|
||||
<groupId>ru.pjandro</groupId>
|
||||
<artifactId>docx4j-fo-renderer-core</artifactId>
|
||||
</dependency>
|
||||
<!-- Простой логгер в консоль (slf4j). Обязателен: без него docx4j
|
||||
пишет предупреждение прямо в выходной PDF. -->
|
||||
|
||||
@@ -77,12 +77,18 @@ public final class WordPdfConverter {
|
||||
// classpath'а за шрифтами — всё найденное выбрасывает
|
||||
// BundledFonts.restrictToBundled() перед каждой конвертацией.
|
||||
// Реестр обязан оставаться бандл + встроенные в docx. Свойства читает
|
||||
// тот же static-блок BestMatchingMapper (docx4j-core 17.3.2); наша
|
||||
// тот же static-блок BestMatchingMapper (docx4j-core 17.3.6); наша
|
||||
// инициализация предшествует первому new BundledFontMapper().
|
||||
// discoverJarFonts("fonts-symbol") свойством не гейтится — символ-
|
||||
// шрифт регистрируется как раньше и снимается restrict'ом как раньше.
|
||||
Docx4jProperties.setProperty("docx4j.fonts.discoverPhysicalFonts.enabled", "false");
|
||||
Docx4jProperties.setProperty("docx4j.fonts.discoverJarFonts.enabled", "false");
|
||||
// docx4j 17.3.6 (RepairMode, свойство docx4j.openpackaging.load.repair):
|
||||
// пакеты, которые Word открывает только через «восстановить», по умолчанию
|
||||
// (NONE) отказываются грузиться — для конвертера это регрессия 500 на
|
||||
// «битых, но читаемых Word» файлах. Значение "word" возвращает толерантность
|
||||
// уровня Word.
|
||||
Docx4jProperties.setProperty("docx4j.openpackaging.load.repair", "word");
|
||||
}
|
||||
|
||||
private WordPdfConverter() {
|
||||
@@ -156,8 +162,8 @@ public final class WordPdfConverter {
|
||||
* считаются ровно раз по сырому входу, до аллокаций docx4j: для .docx —
|
||||
* lightweight-скан по zip, для .doc — по чистому бинарному документу до
|
||||
* конвертации. Повторного скана по нормализованным байтам нет: правила
|
||||
* 1–10 {@code DocxRewritePipeline} число учитываемых разрывов не
|
||||
* увеличивают (правило 9 способно только убрать разрыв внутри скрытого
|
||||
* 1–8 {@code DocxRewritePipeline} число учитываемых разрывов не
|
||||
* увеличивают (правило 7 способно только убрать разрыв внутри скрытого
|
||||
* рана — счёт по сырому входу остаётся верхней оценкой лимита), а скан
|
||||
* внутри живой JAXB-модели удваивал бы пиковую память.
|
||||
*
|
||||
@@ -435,7 +441,7 @@ public final class WordPdfConverter {
|
||||
}
|
||||
|
||||
/**
|
||||
* Нормализация входных байтов (цепочка {@link #normalizers}: правила 1–10
|
||||
* Нормализация входных байтов (цепочка {@link #normalizers}: правила 1–8
|
||||
* одним zip-проходом {@code DocxRewritePipeline} + условная OLE-вычистка)
|
||||
* и {@code WordprocessingMLPackage.load} полученного transitional-байта.
|
||||
* Нормализация переиспользует слот {@code bytes}: каждая замена массива
|
||||
@@ -453,7 +459,7 @@ public final class WordPdfConverter {
|
||||
/**
|
||||
* Конвейер байтовой нормализации docx. Порядок фиксирован: сначала один
|
||||
* zip-проход переписывания XML-частей (внутри части порядок рерайтов
|
||||
* Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→
|
||||
* Strict→OnOff→Invisible→GlyphCoverage→TableIndent→
|
||||
* NumberingSuffix→Hidden→Ruby значим: Strict первым — дальше transitional-байт;
|
||||
* GlyphCoverage — по финальному тексту рана; Hidden — вырезает скрытые
|
||||
* раны по финальному содержимому; Ruby — разворачивает руби-разметку,
|
||||
@@ -463,10 +469,11 @@ public final class WordPdfConverter {
|
||||
*/
|
||||
private static List<DocxNormalizer> normalizers(ConvertOptions options) {
|
||||
return List.of(
|
||||
// один zip-проход: strict→transitional, on/off, Symbol-PUA,
|
||||
// поля PAGE/NUMPAGES, невидимки, покрытие глифов, tblInd при
|
||||
// jc≠left, suff=space, скрытый текст (vanish) — порядок
|
||||
// рерайтов внутри части фиксирован (DocxRewritePipeline)
|
||||
// один zip-проход: strict→transitional, on/off, невидимки,
|
||||
// покрытие глифов, tblInd при jc≠left, suff=space, скрытый
|
||||
// текст (vanish) — порядок рерайтов внутри части фиксирован
|
||||
// (DocxRewritePipeline); символьные шрифты и complex-поля
|
||||
// PAGE/NUMPAGES с docx4j 17.3.x обрабатывает сам экспорт
|
||||
DocxRewritePipeline.STEP,
|
||||
// OLE-объекты: при выключенном errorOnOle тихо удаляем
|
||||
// (часть/rels/w:object), при включённом — DrawingFoundException
|
||||
|
||||
+230
@@ -0,0 +1,230 @@
|
||||
package ru.pjandro.wordpdf.internal;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.zip.ZipEntry;
|
||||
import java.util.zip.ZipInputStream;
|
||||
import java.util.zip.ZipOutputStream;
|
||||
|
||||
/**
|
||||
* {@code w:pPr/w:jc w:val="distribute"} → невидимая закладка-штамп в начале
|
||||
* абзаца — до загрузки docx4j (Part 1 §17.18.44).
|
||||
*
|
||||
* <p>Word при {@code distribute} растягивает межсловные пробелы каждой строки
|
||||
* абзаца, включая последнюю. docx4j для DISTRIBUTE не эмитит в FO ничего
|
||||
* ({@code Justification.setXslFO} не знает этого значения): абзац приходит в
|
||||
* FOP без {@code text-align} и печатается по левому краю. Канонический FO
|
||||
* эквивалент — {@code text-align="justify" text-align-last="justify"} (пин в
|
||||
* форке: DistributeLineTestCase), но в XSLT-стилиста дописать атрибутику jc
|
||||
* нельзя (дрейф-гейт {@code vendoredXsltTracksJarCopy}), а рендер-фильтр
|
||||
* {@code LayoutPostRenderer} видит только FO и опознал бы distribute-абзац
|
||||
* лишь по якорю. Штамп — этот якорь: {@code w:bookmarkStart
|
||||
* w:name="pj-distribute-<часть>-<n>"} сразу после закрывающего {@code </w:pPr>}
|
||||
* абзаца; экспорт docx4j ({@code BookmarkStartWriter}) превращает её в
|
||||
* {@code <fo:inline id="pj-distribute-…"/>} первым инлайн-ребёнком блока, и
|
||||
* фильтр дописывает блоку пару justify-свойств. Имена закладок уникальны в
|
||||
* пределах конвертации (docx4j дубликаты выбрасывает с warn), поэтому
|
||||
* счётчик per-part с меткой части в имени.</p>
|
||||
*
|
||||
* <p>Штампуются контентные части ({@code document}, {@code footnotes},
|
||||
* {@code endnotes}, {@code headerN}/{@code footerN} — закладка-якорь работает
|
||||
* и в колонтитулах): в {@code numbering.xml} у {@code CT_Lvl} закладки быть
|
||||
* не может (не входит в EG_PPrGeneralContent, WML XSD), а {@code w:jc} в
|
||||
* {@code trPr}/{@code tblPr} (выравнивание таблицы/строки) не читается —
|
||||
* разбор идёт только содержимым {@code w:pPr} (первый ребёнок {@code w:p},
|
||||
* Part 1 §17.3.1.23). Старое значение {@code w:jc} внутри {@code w:pPrChange}
|
||||
* (реvision) — не текущее выравнивание: окно поиска огранивается началом
|
||||
* реvision, а штамп вставляется после наружного {@code </w:pPr>}. Диапазон
|
||||
* абзаца плоский: {@code w:p} не вложен в {@code w:p}. Уже проштампованный
|
||||
* абзац не дублируется (идемпотентность проверяется позиционно — штамп
|
||||
* всегда стоит сразу после закрытия pPr). Нечего менять → {@code null}
|
||||
* (контракт rewrite-хуков).</p>
|
||||
*
|
||||
* <p>Регрессии — DistributeStampNormalizerTest (юнит),
|
||||
* WordPdfConverterTest#distribute_allLinesReachRightMargin (конвейер),
|
||||
* фикстура samples/distribute.docx.</p>
|
||||
*/
|
||||
final class DistributeStampNormalizer {
|
||||
|
||||
/** Начало абзаца: {@code <w:p>} или {@code <w:p …>}; {@code w:pPr}-подобные не матчатся. */
|
||||
private static final Pattern PARA_START = Pattern.compile("<w:p(?=[ >/])");
|
||||
|
||||
/** justify-раскладка абзаца; ищем только внутри w:pPr. */
|
||||
private static final Pattern JC_DISTRIBUTE =
|
||||
Pattern.compile("<w:jc\\b[^>]*w:val=\"distribute\"");
|
||||
|
||||
/** Существующие id закладок — штампуете от max+1 (Part 1: id уникален в части). */
|
||||
private static final Pattern BOOKMARK_ID =
|
||||
Pattern.compile("<w:bookmarkStart\\b[^>]*w:id=\"(\\d+)\"");
|
||||
|
||||
/** Собственные штампы — защита от повторного штампа (идемпотентность). */
|
||||
private static final String STAMP_MARK = "pj-distribute-";
|
||||
|
||||
/** Закрывающий слэш открывающего тега: {@code <w:p/>} — абзац без содержимого. */
|
||||
private static final char SELF_CLOSE_SLASH = '/';
|
||||
|
||||
/** Закрытие w:pPr; наружное ищем от конца абзаца (внутри — w:pPrChange). */
|
||||
private static final String PPR_CLOSE = "</w:pPr>";
|
||||
|
||||
/** Начало реvision абзаца — старое значение jc внутри неё не текущее. */
|
||||
private static final Pattern PPR_CHANGE = Pattern.compile("<w:pPrChange\\b");
|
||||
|
||||
/** Штампы всегда стоят сразу после наружного {@code </w:pPr>} — проверка позиционная. */
|
||||
private static final String BOOKMARK_OPEN = "<w:bookmarkStart";
|
||||
|
||||
private DistributeStampNormalizer() {
|
||||
}
|
||||
|
||||
/** Шаг конвейера WordPdfConverter#normalizers: этот нормализатор как DocxNormalizer. */
|
||||
static final DocxNormalizer STEP = DistributeStampNormalizer::normalize;
|
||||
|
||||
/**
|
||||
* Штампует distribute-абзацы content-части.
|
||||
*
|
||||
* @param part имя zip-записи ({@code word/document.xml} и т. п.)
|
||||
* @param xml разметка части
|
||||
* @return размеченная разметка либо {@code null}, если менять нечего
|
||||
* (не content-часть / нет distribute-абзацев)
|
||||
*/
|
||||
static String rewrite(String part, String xml) {
|
||||
String tag = contentTag(part);
|
||||
if (tag == null) {
|
||||
return null;
|
||||
}
|
||||
Matcher starts = PARA_START.matcher(xml);
|
||||
StringBuilder sb = null;
|
||||
int mark = 0;
|
||||
int nextId = maxBookmarkId(xml) + 1;
|
||||
int seq = 0;
|
||||
while (starts.find()) {
|
||||
int body = starts.end();
|
||||
int gt = xml.indexOf('>', body);
|
||||
if (gt < 0) {
|
||||
break;
|
||||
}
|
||||
if (xml.charAt(gt - 1) == SELF_CLOSE_SLASH) {
|
||||
continue; // самозакрывающийся <w:p/> — pPr нет в помине
|
||||
}
|
||||
int end = xml.indexOf("</w:p>", gt);
|
||||
if (end < 0) {
|
||||
break;
|
||||
}
|
||||
// pPr — первый ребёнок w:p (Part 1 §17.3.1.23): проверка на месте,
|
||||
// без поиска по хвосту части (O(1) на абзац без pPr).
|
||||
int pos = gt + 1;
|
||||
while (pos < end && xml.charAt(pos) <= ' ') {
|
||||
pos++;
|
||||
}
|
||||
if (!xml.startsWith("<w:pPr", pos)) {
|
||||
continue;
|
||||
}
|
||||
// Наружное закрытие — последнее до конца абзаца: внутри pPr может
|
||||
// стоять w:pPrChange (реvision), чей контент содержит </w:pPr>.
|
||||
int pprClose = xml.lastIndexOf(PPR_CLOSE, end - 1);
|
||||
if (pprClose <= pos) {
|
||||
continue;
|
||||
}
|
||||
CharSequence ppr = xml.subSequence(pos, pprClose);
|
||||
// Старое значение jc из реvision — не текущее выравнивание:
|
||||
// окно jc-поиска ограниваем началом w:pPrChange.
|
||||
Matcher rev = PPR_CHANGE.matcher(ppr);
|
||||
int jcWindow = rev.find() ? rev.start() : ppr.length();
|
||||
if (!JC_DISTRIBUTE.matcher(ppr.subSequence(0, jcWindow)).find()) {
|
||||
continue;
|
||||
}
|
||||
// Идемпотентность: наш штамп стоит сразу после наружного закрытия,
|
||||
// проверяем позицию, а не сканируем абзац в поисках метки.
|
||||
int after = pprClose + PPR_CLOSE.length();
|
||||
int probe = after;
|
||||
while (probe < end && xml.charAt(probe) <= ' ') {
|
||||
probe++;
|
||||
}
|
||||
if (xml.startsWith(BOOKMARK_OPEN, probe)) {
|
||||
int tagEnd = xml.indexOf('>', probe);
|
||||
int stampAt = tagEnd > 0 ? xml.indexOf(STAMP_MARK, probe) : -1;
|
||||
if (stampAt >= probe && stampAt < tagEnd) {
|
||||
continue; // уже проштампован
|
||||
}
|
||||
}
|
||||
seq++;
|
||||
if (sb == null) {
|
||||
sb = new StringBuilder(xml.length() + 64);
|
||||
}
|
||||
sb.append(xml, mark, after);
|
||||
sb.append("<w:bookmarkStart w:id=\"").append(nextId++).append("\" w:name=\"")
|
||||
.append(STAMP_MARK).append(tag).append('-').append(seq).append("\"/>")
|
||||
.append("<w:bookmarkEnd w:id=\"").append(nextId - 1).append("\"/>");
|
||||
mark = after;
|
||||
}
|
||||
return sb == null ? null : sb.append(xml, mark, xml.length()).toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Метка части для имён закладок; {@code null} — часть не content
|
||||
* (в numbering/styles закладок быть не может, прочие не рендерятся).
|
||||
*/
|
||||
private static String contentTag(String part) {
|
||||
switch (part) {
|
||||
case "word/document.xml":
|
||||
return "document";
|
||||
case "word/footnotes.xml":
|
||||
return "footnotes";
|
||||
case "word/endnotes.xml":
|
||||
return "endnotes";
|
||||
default:
|
||||
break;
|
||||
}
|
||||
// word/header1.xml, word/footer2.xml, … — метка = имя файла без расширения;
|
||||
// точка в основании отсекает .rels и вложенные пути.
|
||||
if (part.startsWith("word/header") || part.startsWith("word/footer")) {
|
||||
String base = part.substring("word/".length(), part.length() - ".xml".length());
|
||||
return base.indexOf('.') < 0 ? base : null;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static int maxBookmarkId(String xml) {
|
||||
int max = 0;
|
||||
Matcher m = BOOKMARK_ID.matcher(xml);
|
||||
while (m.find()) {
|
||||
try {
|
||||
max = Math.max(max, Integer.parseInt(m.group(1)));
|
||||
} catch (NumberFormatException ignored) {
|
||||
// нечисловой id — не конкурент нашим id
|
||||
}
|
||||
}
|
||||
return max;
|
||||
}
|
||||
|
||||
/**
|
||||
* Самостоятельный zip-проход (тот же контракт, что у остальных; в
|
||||
* конвейере вызывается {@link #rewrite} через {@link DocxRewritePipeline}).
|
||||
*
|
||||
* @param docx байты .docx (zip)
|
||||
* @return те же или переупакованные байты
|
||||
*/
|
||||
static byte[] normalize(byte[] docx) throws IOException {
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream(docx.length);
|
||||
boolean changed = false;
|
||||
try (ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(docx));
|
||||
ZipOutputStream zos = new ZipOutputStream(out)) {
|
||||
ZipEntry entry;
|
||||
while ((entry = zis.getNextEntry()) != null) {
|
||||
byte[] data = zis.readAllBytes();
|
||||
String name = entry.getName();
|
||||
String fixed = name.startsWith("word/") && name.endsWith(".xml")
|
||||
? rewrite(name, new String(data, StandardCharsets.UTF_8))
|
||||
: null;
|
||||
zos.putNextEntry(new ZipEntry(name));
|
||||
zos.write(fixed != null ? fixed.getBytes(StandardCharsets.UTF_8) : data);
|
||||
zos.closeEntry();
|
||||
changed |= fixed != null;
|
||||
}
|
||||
}
|
||||
return changed ? out.toByteArray() : docx;
|
||||
}
|
||||
}
|
||||
@@ -15,21 +15,31 @@ import org.apache.commons.compress.utils.SeekableInMemoryByteChannel;
|
||||
/**
|
||||
* Единый zip-проход переписывания XML-частей (.docx) вместо отдельных
|
||||
* проходов нормализаторов: к каждой записи {@code word/*.xml} применяются
|
||||
* все десять рерайтов в фиксированном порядке
|
||||
* Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby.
|
||||
* все девять рерайтов в фиксированном порядке
|
||||
* Strict→OnOff→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby→Distribute.
|
||||
* Порядок значим: Strict первым — дальше части в transitional-виде
|
||||
* (TableIndent читает transitional-атрибуты {@code w:}); GlyphCoverage
|
||||
* режет раны по финальному тексту рана (после Symbol/Invisible); Hidden
|
||||
* последним — вырезает уже финальные раны (после Symbol/GLYPH-разбиений),
|
||||
* а его OnOff-форма vanish читается после правила 2. Каждый
|
||||
* режет раны по финальному тексту рана (после Invisible); Hidden
|
||||
* идёт после GlyphCoverage — вырезает уже финальные раны (после GLYPH-разбиений),
|
||||
* а его OnOff-форма vanish читается после правила 2; Distribute (штамп
|
||||
* {@code w:jc="distribute"} закладкой-якорем) — последним, он вставляет узел
|
||||
* после {@code </w:pPr>} и не трогает текст, но обязан видеть финальную
|
||||
* разметку, чтобы не штамповать абзац, вырезанный Hidden. Каждый
|
||||
* рерайт работает только содержимым одной части, поэтому по-частная
|
||||
* цепочка эквивалентна последовательным полным проходам. Исключения из
|
||||
* «по-частности» — контексты, читаемые один раз до цикла: правило 7
|
||||
* «по-частности» — контексты, читаемые один раз до цикла: правило 5
|
||||
* (TableIndent) — у header/footer-частей своей sectPr нет, ширина полосы
|
||||
* передаётся из document.xml (многосекционный документ — полоса
|
||||
* неоднозначна, header/footer пропускаются); правило 9 (Hidden) —
|
||||
* неоднозначна, header/footer пропускаются); правило 7 (Hidden) —
|
||||
* стилевые 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-копией
|
||||
* сжатых байтов — без inflate/deflate; прочие (редкие методы сжатия,
|
||||
* шифрованные) — обычный перенос. Ни одна часть не изменилась →
|
||||
@@ -52,7 +62,7 @@ public final class DocxRewritePipeline {
|
||||
public static final DocxNormalizer STEP = DocxRewritePipeline::normalize;
|
||||
|
||||
/**
|
||||
* Применяет десять рерайтов к каждой записи {@code word/*.xml} за один
|
||||
* Применяет девять рерайтов к каждой записи {@code word/*.xml} за один
|
||||
* проход zip.
|
||||
*
|
||||
* @param docx байты .docx (валидный zip)
|
||||
@@ -63,7 +73,7 @@ public final class DocxRewritePipeline {
|
||||
boolean changed = false;
|
||||
try (ZipFile zf = new ZipFile(new SeekableInMemoryByteChannel(docx));
|
||||
ZipArchiveOutputStream zos = new ZipArchiveOutputStream(out)) {
|
||||
// Ширина полосы набора для правила 7 (таблицы в header/footer-
|
||||
// Ширина полосы набора для правила 5 (таблицы в header/footer-
|
||||
// частях своей sectPr не содержат): из сырого document.xml —
|
||||
// геометрия инвариантна к рерайтам цепочки (Strict не трогает
|
||||
// w:pgSz/@w:w, а pgMar-чередование left|start покрывает strict).
|
||||
@@ -76,7 +86,7 @@ public final class DocxRewritePipeline {
|
||||
new String(zf.getInputStream(docEntry).readAllBytes(),
|
||||
StandardCharsets.UTF_8));
|
||||
}
|
||||
// Стилевые vanish для правила 9 (скрытый текст): часть стилевой
|
||||
// Стилевые vanish для правила 7 (скрытый текст): часть стилевой
|
||||
// цепочки w:basedOn вычисляется один раз до цикла. Записи нет →
|
||||
// пустое множество, рерайт работает по прямому vanish.
|
||||
Set<String> hiddenStyles = Set.of();
|
||||
@@ -101,14 +111,6 @@ public final class DocxRewritePipeline {
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
}
|
||||
next = SymbolFontNormalizer.rewrite(cur);
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
}
|
||||
next = FieldNormalizer.rewrite(cur);
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
}
|
||||
next = InvisibleCharNormalizer.rewrite(cur);
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
@@ -133,6 +135,10 @@ public final class DocxRewritePipeline {
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
}
|
||||
next = DistributeStampNormalizer.rewrite(name, cur);
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
}
|
||||
if (cur != xml) {
|
||||
changed = true;
|
||||
rewritten = cur.getBytes(StandardCharsets.UTF_8);
|
||||
|
||||
@@ -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("&", "&")
|
||||
.replace("<", "<")
|
||||
.replace(">", ">")
|
||||
.replace("\"", """);
|
||||
}
|
||||
|
||||
private static String unescape(String value) {
|
||||
String v = value;
|
||||
if (v.indexOf('&') < 0) {
|
||||
return v;
|
||||
}
|
||||
v = v.replace("<", "<").replace(">", ">").replace(""", "\"");
|
||||
return v.replace("&", "&");
|
||||
}
|
||||
}
|
||||
@@ -52,7 +52,8 @@ import java.util.concurrent.ConcurrentHashMap;
|
||||
* честнее оставить, чем подменять случайным шрифтом.</li>
|
||||
* </ul>
|
||||
*
|
||||
* Как и {@link SymbolFontNormalizer}, правим байты zip до JAXB-разбора.
|
||||
* Как и прочие рерайты {@link DocxRewritePipeline}, правим байты zip до
|
||||
* JAXB-разбора.
|
||||
*/
|
||||
final class GlyphCoverageNormalizer {
|
||||
|
||||
@@ -128,8 +129,7 @@ final class GlyphCoverageNormalizer {
|
||||
* Проходит блоки {@code <w:r>} ... {@code </w:r>} и заменяет каждый через
|
||||
* {@link #rewriteBlock}. Вложенные раны текстбоксов (w:r → w:drawing →
|
||||
* txbxContent → w:r) переписываются рекурсивно по телу внешнего блока —
|
||||
* каркас внешнего рана остаётся нетронутым. Приём общий с
|
||||
* {@link SymbolFontNormalizer}.
|
||||
* каркас внешнего рана остаётся нетронутым.
|
||||
*/
|
||||
private static String rewriteBlocks(String xml, String tag) {
|
||||
String open = "<" + tag;
|
||||
|
||||
@@ -27,6 +27,13 @@ import java.util.regex.Pattern;
|
||||
* обратно к {@code start-indent}. Вложенные таблицы: первой считается ячейка
|
||||
* внешней — принятая аппроксимация (компенсация всё равно от default
|
||||
* cellMar). Регрессия — WordPdfConverterTest#tableCellPadding_textInsetLikeWord.</li>
|
||||
* <li><b>distribute → justify-пара.</b> docx4j для {@code w:jc="distribute"}
|
||||
* не эмитит в FO ничего; по якорю-закладке {@code pj-distribute-…}
|
||||
* (DistributeStampNormalizer, правило 9) блоку дописывается
|
||||
* {@code text-align="justify" text-align-last="justify"} — Word растягивает
|
||||
* пробелы всех строк, включая последнюю (Part 1 §17.18.44). Регрессия —
|
||||
* LayoutPostRendererTest (фильтр),
|
||||
* WordPdfConverterTest#distribute_allLinesReachRightMargin (конвейер).</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>{@code lineRule="auto"} НЕ правится: высота «single» 13.4277pt@11pt,
|
||||
@@ -56,6 +63,14 @@ public final class LayoutPostRenderer implements FORenderer {
|
||||
private static final double IN_TO_PT = 72.0;
|
||||
|
||||
private static final Pattern TABLE = Pattern.compile("<fo:table\\b[^>]*>");
|
||||
/**
|
||||
* Якорь distribute-абзаца: fo:inline с id закладки-штампа. docx4j пишет
|
||||
* его DOM-поддеревом ({@code XsltCommonFunctions.toNode}), на сериализации
|
||||
* префикс может не унаследоваться — форма {@code <inline xmlns="fo-uri" …/>},
|
||||
* поэтому префикс факультативен.
|
||||
*/
|
||||
private static final Pattern DISTRIBUTE_STAMP =
|
||||
Pattern.compile("<(?:fo:)?inline\\b[^>]*\\bid=\"pj-distribute-[^\"]*\"[^>]*/>");
|
||||
private static final Pattern START_INDENT = Pattern.compile("start-indent=\"(-?[0-9.]+)pt\"");
|
||||
private static final Pattern FIRST_CELL = Pattern.compile("<fo:table-cell\\b[^>]*>");
|
||||
private static final Pattern PADDING_LEFT =
|
||||
@@ -84,7 +99,59 @@ public final class LayoutPostRenderer implements FORenderer {
|
||||
* возвращает ту же строку.
|
||||
*/
|
||||
static String fix(String fo) {
|
||||
return compensateTablePadding(fo);
|
||||
return compensateTablePadding(justifyDistributed(fo));
|
||||
}
|
||||
|
||||
/**
|
||||
* Абзац со штампом {@code w:jc="distribute"} (якорь-закладка
|
||||
* {@code pj-distribute-…} от {@link DistributeStampNormalizer}) получает
|
||||
* пару {@code text-align="justify" text-align-last="justify"} —
|
||||
* канонический FO-эквивалент Word-раскладки (Part 1 §17.18.44; пин
|
||||
* поведения — форк DistributeLineTestCase). Атрибут дописывается в тег
|
||||
* ближайшего открывающего {@code fo:block} перед якорем; уже заданное
|
||||
* {@code text-align} не перетирается.
|
||||
*/
|
||||
private static String justifyDistributed(String fo) {
|
||||
Matcher stamp = DISTRIBUTE_STAMP.matcher(fo);
|
||||
StringBuilder sb = null;
|
||||
int mark = 0;
|
||||
int search = 0;
|
||||
while (stamp.find(search)) {
|
||||
search = stamp.end();
|
||||
int block = fo.lastIndexOf("<fo:block", stamp.start());
|
||||
int blockClose = block < mark ? -1 : fo.indexOf("</fo:block>", block);
|
||||
if (block < mark || block < 0 || (blockClose >= 0 && blockClose < stamp.start())) {
|
||||
continue; // якорь вне блока/после закрытия — править нечего
|
||||
}
|
||||
int blockEnd = fo.indexOf('>', block + "<fo:block".length());
|
||||
if (blockEnd < 0 || fo.charAt(blockEnd - 1) == '/') {
|
||||
continue; // пустой самозакрывающийся блок — не наш случай
|
||||
}
|
||||
String fixed = addJustify(fo.substring(block, blockEnd + 1));
|
||||
if (fixed != null) {
|
||||
if (sb == null) {
|
||||
sb = new StringBuilder(fo.length() + 64);
|
||||
}
|
||||
sb.append(fo, mark, block).append(fixed);
|
||||
mark = blockEnd + 1;
|
||||
}
|
||||
}
|
||||
return sb == null ? fo : sb.append(fo, mark, fo.length()).toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* @return тег блока с дописанными justify-свойствами либо {@code null},
|
||||
* если {@code text-align-last} уже задан
|
||||
*/
|
||||
private static String addJustify(String blockTag) {
|
||||
if (blockTag.contains("text-align-last=")) {
|
||||
return null;
|
||||
}
|
||||
String attrs = blockTag.contains("text-align=\"")
|
||||
? " text-align-last=\"justify\""
|
||||
: " text-align=\"justify\" text-align-last=\"justify\"";
|
||||
int close = blockTag.endsWith("/>") ? blockTag.length() - 2 : blockTag.length() - 1;
|
||||
return blockTag.substring(0, close) + attrs + blockTag.substring(close);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -28,6 +28,11 @@ import java.util.zip.ZipOutputStream;
|
||||
* wml.xsd: suff → lvlText; между ними нет {@code </w:lvl>}); уже
|
||||
* заканчивающийся пробелом lvlText не дублируется. suff=tab/absent/nothing —
|
||||
* не трогаем. Нечего менять → тот же массив.
|
||||
*
|
||||
* <p>Двойного пробела правило с форком не даёт: TP-поток PDF на suff=space —
|
||||
* «1.·ITEM» (один разделитель): word-layout путь форка
|
||||
* ({@code labelSuffixSpace}) разделитель не дописывает — эмитится только наш
|
||||
* lvlText-пробел.</p>
|
||||
*/
|
||||
final class NumberingSuffixNormalizer {
|
||||
|
||||
|
||||
@@ -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=""/>} + {@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: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" />
|
||||
|
||||
<!-- AUDIT-FIX position: docx4j createBlockForRPr игнорирует
|
||||
@@ -523,9 +526,11 @@
|
||||
<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
|
||||
(ConversionSectionWrapperFactory): a block spanning them all -->
|
||||
<fo:block span="all">
|
||||
<xsl:variable name="childResults">
|
||||
<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 test="starts-with(./w:sdtPr/w:tag/@w:val, 'XSLT_Ind')">
|
||||
<!-- 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(
|
||||
$conversionContext, $wpinline, $childResults)" />
|
||||
</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:copy-of
|
||||
@@ -833,6 +844,14 @@
|
||||
</xsl:if>
|
||||
|
||||
<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>
</xsl:text>
|
||||
</xsl:when>
|
||||
<xsl:when test="$predecessor='br' and not(@w:type='page') and not(@w:type='column')">
|
||||
<!-- special case; see discussion in BrWriter -->
|
||||
<fo:block white-space-treatment="preserve" linefeed-treatment="preserve"><xsl:text> <!-- one carriage return -->
|
||||
@@ -867,7 +886,15 @@
|
||||
</xsl:template>
|
||||
|
||||
<xsl:template match="w:cr">
|
||||
<xsl:choose>
|
||||
<xsl:when test="ancestor::w:footnote">
|
||||
<!-- as w:br above: no block inside a footnote's inline -->
|
||||
<xsl:text>
</xsl:text>
|
||||
</xsl:when>
|
||||
<xsl:otherwise>
|
||||
<fo:block white-space-treatment="preserve"> </fo:block>
|
||||
</xsl:otherwise>
|
||||
</xsl:choose>
|
||||
</xsl:template>
|
||||
|
||||
<!-- <w:sym w:font="Wingdings" w:char="F04A"/> -->
|
||||
@@ -1116,7 +1143,8 @@
|
||||
AbstractVisitorExporterGenerator.walkJAXBElements. @since 17.1.0 -->
|
||||
<xsl:template match="mc:AlternateContent" >
|
||||
<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:when test="$preferred">
|
||||
<xsl:variable name="info"
|
||||
@@ -1163,7 +1191,7 @@
|
||||
bidi-направление — принятая деградация (complex-script в FOP-форке нет).
|
||||
Руби (w:rubyBase/w:rt, §17.3.3.19/.20/.21) тут не чинится: схема docx4j
|
||||
не биндит эти элементы, unmarshaller выбрасывает их до XSLT — разбор
|
||||
делает RubyNormalizer (правило 10) в байтах.
|
||||
делает RubyNormalizer (правило 8) в байтах.
|
||||
Регрессии — WordPdfConverterTest#movedRevision_textPrinted, #bdoDir_textPrinted. -->
|
||||
<xsl:template match="w:moveFrom">
|
||||
<xsl:apply-templates select="*|text()"/>
|
||||
|
||||
@@ -22,6 +22,7 @@ import org.apache.poi.xwpf.usermodel.XWPFAbstractNum;
|
||||
import org.apache.poi.xwpf.usermodel.XWPFNumbering;
|
||||
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR;
|
||||
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPr;
|
||||
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STJc;
|
||||
|
||||
import javax.imageio.ImageIO;
|
||||
import java.awt.Color;
|
||||
@@ -76,6 +77,7 @@ public final class SampleDocxGenerator {
|
||||
exoticGlyphs(dir.resolve("exotic-glyphs.docx"));
|
||||
tooManyPages(dir.resolve("too-many-pages.docx"));
|
||||
staleCache(dir.resolve("stale-cache.docx"));
|
||||
distribute(dir.resolve("distribute.docx"));
|
||||
|
||||
System.out.println("Готово: " + dir.toAbsolutePath());
|
||||
}
|
||||
@@ -211,8 +213,8 @@ public final class SampleDocxGenerator {
|
||||
/**
|
||||
* Маркеры списков из символьных шрифтов: {@code w:lvlText} кодами из
|
||||
* 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 {
|
||||
try (XWPFDocument doc = new XWPFDocument()) {
|
||||
@@ -268,8 +270,9 @@ public final class SampleDocxGenerator {
|
||||
/**
|
||||
* Нумерация страниц: {@code PAGE} в колонтитуле — сложным полем
|
||||
* ({@code fldChar} + {@code instrText} + кэш), как его пишет Word.
|
||||
* Экспорт docx4j в FO {@code instrText} в таком поле игнорирует и печатает
|
||||
* кэш, поэтому без FieldNormalizers все страницы получают одно число.
|
||||
* С docx4j 17.3.5 (CR-067) {@code FieldsCombiner} сворачивает такое поле
|
||||
* в {@code w:fldSimple}; без этого все страницы получили бы одно число
|
||||
* из кэша.
|
||||
*/
|
||||
private static void pageNumbers(Path out) throws Exception {
|
||||
try (XWPFDocument doc = new XWPFDocument()) {
|
||||
@@ -438,6 +441,35 @@ public final class SampleDocxGenerator {
|
||||
/** Сколько {@code w:t} в фикстуре stale-cache остаются без маркера. */
|
||||
private static final int STALE_CACHE_UNMARKED_RUNS = 1;
|
||||
|
||||
/**
|
||||
* w:jc="distribute" (+ контроль {@code both} и левый): Word растягивает
|
||||
* пробелы всех строк, включая последнюю (Part 1 §17.18.44); docx4j для
|
||||
* DISTRIBUTE не эмитит ничего, без правила 9 абзац печатается влево.
|
||||
* Регрессия — WordPdfConverterTest#distribute_allLinesReachRightMargin.
|
||||
*/
|
||||
private static void distribute(Path out) throws Exception {
|
||||
try (XWPFDocument doc = new XWPFDocument()) {
|
||||
heading(doc, "Distribute justification", "Calibri");
|
||||
String text = "alpha bravo charlie delta echo foxtrot golf hotel "
|
||||
+ "india juliett kilo lima mike november oscar papa quebec romeo sierra";
|
||||
XWPFParagraph p = doc.createParagraph();
|
||||
setJc(p, STJc.DISTRIBUTE);
|
||||
run(p, text, "Calibri", false, false);
|
||||
p = doc.createParagraph();
|
||||
run(p, text, "Calibri", false, false);
|
||||
p = doc.createParagraph();
|
||||
setJc(p, STJc.BOTH);
|
||||
run(p, text, "Calibri", false, false);
|
||||
save(doc, out);
|
||||
}
|
||||
}
|
||||
|
||||
/** w:jc прямо в pPr: POI-перечисление Alignment не знает DISTRIBUTE. */
|
||||
private static void setJc(XWPFParagraph p, STJc.Enum val) {
|
||||
CTPPr pPr = p.getCTP().isSetPPr() ? p.getCTP().getPPr() : p.getCTP().addNewPPr();
|
||||
pPr.addNewJc().setVal(val);
|
||||
}
|
||||
|
||||
// ================== Вспомогательные ==================
|
||||
|
||||
/** Абзац-заголовок: POI 5.5 не имеет createHeading, поэтому
|
||||
|
||||
@@ -372,9 +372,10 @@ class WordPdfConverterTest {
|
||||
|
||||
/**
|
||||
* Маркеры списков из символьных шрифтов (Symbol/Wingdings, коды из
|
||||
* PUA U+F0xx) экспорт в FO не понимает и рисует .notdef — решётку «#».
|
||||
* SymbolFontNormalizer заменяет их Unicode-эквивалентами, поэтому
|
||||
* маркеры остаются маркерами.
|
||||
* PUA U+F0xx) исторически рисовались .notdef — решёткой «#»; их
|
||||
* Unicode-маппинг делал SymbolFontNormalizer. С docx4j 17.3.3 (#701)
|
||||
* маркеры маппит сам экспорт в FO — правило удалено, тест пинит
|
||||
* отсутствие регрессии на апстримном поведении.
|
||||
*/
|
||||
@Test
|
||||
void symbolFonts_bulletsAreNotHash() throws Exception {
|
||||
@@ -428,10 +429,11 @@ class WordPdfConverterTest {
|
||||
|
||||
/**
|
||||
* Поля PAGE/NUMPAGES Word пишет как {@code fldChar} + {@code instrText}
|
||||
* + закэшированный результат. Экспорт docx4j в FO инструкцию игнорирует
|
||||
* и печатает кэш — все страницы получают одно и то же число.
|
||||
* FieldNormalizer разворачивает поле в {@code w:fldSimple}, и FOP
|
||||
* считает номер заново на каждой странице.
|
||||
* + закэшированный результат; docx4j 11.x печатал кэш — все страницы
|
||||
* получали одно число, его разворачивал FieldNormalizer. С docx4j 17.3.5
|
||||
* (CR-067) {@code FieldsCombiner} сворачивает complex-поля в
|
||||
* {@code w:fldSimple} и внутри {@code w:sdt}, FOP считает номер заново
|
||||
* на каждой странице — правило удалено, тест пинит апстримное поведение.
|
||||
*/
|
||||
@Test
|
||||
void pageNumbers_recomputedNotCached() throws Exception {
|
||||
@@ -1442,8 +1444,8 @@ class WordPdfConverterTest {
|
||||
* Синтетический .doc со списками (ни одна фикстура заказчика списков не
|
||||
* содержит — крафт POIFS, дубль хелперов DocToDocxFormattingTest):
|
||||
* PlfLst/PlfLfo → numbering.xml + w:numPr — decimal «1.»/«2.», буквенный
|
||||
* подуровень «a)»/«b)», Symbol-буллет (PUA в w:lvl чинит
|
||||
* SymbolFontNormalizer — та же цепочка, что symbol-bullets.docx).
|
||||
* подуровень «a)»/«b)», Symbol-буллет (PUA в w:lvl маппит экспорт
|
||||
* docx4j 17.3.x — та же цепочка, что symbol-bullets.docx).
|
||||
* Регрессия — internal.doc.Lists + DocxBody#numPrXml.
|
||||
*/
|
||||
@Test
|
||||
@@ -2344,7 +2346,7 @@ class WordPdfConverterTest {
|
||||
}
|
||||
|
||||
/**
|
||||
* Скрытый текст не выводится: правило 9 (HiddenTextNormalizer) вырезает
|
||||
* Скрытый текст не выводится: правило 7 (HiddenTextNormalizer) вырезает
|
||||
* раны с прямым truthy vanish и с rStyle на vanish-стиль; falsy vanish
|
||||
* остаётся. Word при печати/PDF-export скрытое не печатает.
|
||||
* Регрессия — аудит 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 терял их до
|
||||
* XSLT. Надстрочница удаляется (принятая деградация, §17.3.3.19/.20 —
|
||||
* ruby-разметки в FOP нет) и пинится негативом.
|
||||
@@ -2930,4 +2932,61 @@ class WordPdfConverterTest {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* w:jc="distribute" (Part 1 §17.18.44): Word растягивает пробелы всех строк,
|
||||
* включая последнюю. docx4j для DISTRIBUTE не эмитит в FO ничего — без
|
||||
* правила 9 (DistributeStampNormalizer) и justify-пары (LayoutPostRenderer)
|
||||
* абзац печатается по левому краю. Фикстура — samples/distribute.docx:
|
||||
* один и тот же текст абзацами distribute / left / both; правое поле
|
||||
* A4 72pt → 523.28pt; хвостовая строка трёхсловная («quebec romeo sierra») —
|
||||
* одно слово растягивать нечем (нет склейки), такие строки Word тоже оставляет
|
||||
* на месте. last-line justify пинут в форке (DistributeLineTestCase).
|
||||
*/
|
||||
@Test
|
||||
void distribute_allLinesReachRightMargin() throws Exception {
|
||||
Path pdf = convertPdf(sampleBytes("distribute.docx"), "distribute");
|
||||
Map<Long, double[]> ends = new LinkedHashMap<>();
|
||||
Map<Long, StringBuilder> lineTexts = new LinkedHashMap<>();
|
||||
try (PDDocument doc = Loader.loadPDF(pdf.toFile())) {
|
||||
PDFTextStripper stripper = new PDFTextStripper() {
|
||||
@Override
|
||||
protected void processTextPosition(org.apache.pdfbox.text.TextPosition tp) {
|
||||
String u = tp.getUnicode();
|
||||
if (!u.trim().isEmpty()) {
|
||||
long y = Math.round(tp.getYDirAdj());
|
||||
double right = tp.getXDirAdj() + tp.getWidthDirAdj();
|
||||
double[] max = ends.computeIfAbsent(y, k -> new double[1]);
|
||||
max[0] = Math.max(max[0], right);
|
||||
lineTexts.computeIfAbsent(y, k -> new StringBuilder()).append(u);
|
||||
}
|
||||
super.processTextPosition(tp);
|
||||
}
|
||||
};
|
||||
String text = stripper.getText(doc);
|
||||
assertEquals(3, count(text, "quebec"), "все три абзаца напечатаны");
|
||||
}
|
||||
List<Double> tails = new ArrayList<>();
|
||||
for (Map.Entry<Long, StringBuilder> e : lineTexts.entrySet()) {
|
||||
if (e.getValue().toString().trim().endsWith("sierra")) {
|
||||
tails.add(Math.round(ends.get(e.getKey())[0] * 10) / 10.0);
|
||||
}
|
||||
}
|
||||
assertEquals(3, tails.size(), "найдены концы трёх абзацев");
|
||||
double right = 595.276 - 72.0;
|
||||
assertTrue(Math.abs(tails.get(0) - right) < 1.5,
|
||||
"distribute: последняя строка дотянута до правого поля, конец=" + tails.get(0));
|
||||
assertTrue(tails.get(1) < right - 20.0,
|
||||
"левый абзац остаётся рваным: конец=" + tails.get(1));
|
||||
assertTrue(tails.get(2) < right - 20.0,
|
||||
"both не растягивает последнюю строку: конец=" + tails.get(2));
|
||||
}
|
||||
|
||||
private static int count(String hay, String needle) {
|
||||
int n = 0;
|
||||
for (int i = hay.indexOf(needle); i >= 0; i = hay.indexOf(needle, i + 1)) {
|
||||
n++;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -661,6 +661,96 @@ class WordPdfValidatorTest {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Мусорные и обрезанные заголовки растров — все ветки отказа «-1» в
|
||||
* сканере {@link WordPdfValidator}: PNG длиной ≥24 с битой сигнатурой
|
||||
* (каждый байт отдельно), BMP короче 26 и BMP с битым вторым байтом,
|
||||
* JPEG короче 4, JPEG без FFD8, мусор-маркер после валидных сегментов,
|
||||
* SOFn без телеги (i+9>len), обход нетелевых маркеров (SOI внутри
|
||||
* потока, RSTn, TEM) и сегментов DHT/JPEG-app (C4/C8/CC не считаются
|
||||
* SOF). Ни один не отклоняется: площадь не объявлена, decode ограничен
|
||||
* бюджетом распаковки. Регрессия — WordPdfValidator#rasterArea.
|
||||
*/
|
||||
@Test
|
||||
void validate_rasterGarbageHeadsAccepted() throws Exception {
|
||||
byte[][] pngs = new byte[4][];
|
||||
for (int bad = 0; bad < 4; bad++) {
|
||||
byte[] png = new byte[24];
|
||||
System.arraycopy(new byte[] {(byte) 0x89, 'P', 'N', 'G', 0x0D, 0x0A, 0x1A, 0x0A},
|
||||
0, png, 0, 8);
|
||||
png[bad] = (byte) (bad == 0 ? 0x00 : 'X'); // байт сигнатуры испорчен
|
||||
pngs[bad] = png;
|
||||
}
|
||||
byte[] bmpShort = {'B', 'M'}; // < 26 байт
|
||||
byte[] bmpMagic = new byte[26];
|
||||
bmpMagic[0] = 'B';
|
||||
bmpMagic[1] = 'X'; // 'BM' битый со второго байта
|
||||
byte[] jpgEmpty = {(byte) 0xFF}; // < 4 байт
|
||||
byte[] jpgNoFf = {0x00, 0x01, 0x02, 0x03}; // первый байт не 0xFF
|
||||
byte[] jpgNoD8 = {(byte) 0xFF, 0x00, 0x00, 0x00}; // нет FFD8
|
||||
// FFD8 FFD8 (SOI внутри потока — i+=2), APP0-сегмент (пропуск по длине),
|
||||
// DHT (C4 — не SOF), RST0 (нет телеги), TEM, затем SOF0 без телеги: i+9 > len.
|
||||
// Отрезано на 44-м байте: маркер FFC0 виден сканеру (окно i+4), телеги не хватает.
|
||||
byte[] jpgSofTruncated = java.util.Arrays.copyOf(jpgSkippingSegments(), 44);
|
||||
// тот же поток, но SOF0 полный (10×10) — проходит как маленький растр.
|
||||
byte[] jpgOk = jpgSkippingSegments();
|
||||
// мусор вместо маркера после валидного APP0-сегмента (len 6 — сам
|
||||
// сканер читает окно i+4, следующий «маркер» 00 попадает в него).
|
||||
ByteArrayOutputStream junk = new ByteArrayOutputStream();
|
||||
junk.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xD8, (byte) 0xFF, (byte) 0xE0, 0x00, 0x06});
|
||||
junk.writeBytes(new byte[4]);
|
||||
junk.writeBytes(new byte[] {0x00, 0x00, 0x00, 0x00});
|
||||
byte[][] jpgs = {jpgEmpty, jpgNoFf, jpgNoD8, jpgSofTruncated, jpgOk, junk.toByteArray()};
|
||||
for (int i = 0; i < pngs.length; i++) {
|
||||
byte[] zip = zipOf("word/media/g" + i + ".png", pngs[i]);
|
||||
assertDoesNotThrow(() -> WordPdfValidator.validate(zip, DEF_OPTS), "png[" + i + "]");
|
||||
}
|
||||
byte[][] bmps = {bmpShort, bmpMagic};
|
||||
for (int i = 0; i < bmps.length; i++) {
|
||||
byte[] zip = zipOf("word/media/g" + i + ".bmp", bmps[i]);
|
||||
assertDoesNotThrow(() -> WordPdfValidator.validate(zip, DEF_OPTS), "bmp[" + i + "]");
|
||||
}
|
||||
for (int i = 0; i < jpgs.length; i++) {
|
||||
byte[] zip = zipOf("word/media/g" + i + ".jpg", jpgs[i]);
|
||||
assertDoesNotThrow(() -> WordPdfValidator.validate(zip, DEF_OPTS), "jpg[" + i + "]");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* JPEG-поток, проводящий сканер через все continue-ветки: двойной SOI,
|
||||
* APP0 (пропуск по длине), DHT (C4 — не SOF несмотря на диапазон C0–CF),
|
||||
* C8/CC (аналогично), RST0 и TEM (маркеры без телеги, i+=2), и
|
||||
* завершающий полный SOF0 10×10.
|
||||
*/
|
||||
private static byte[] jpgSkippingSegments() {
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xD8}); // SOI
|
||||
out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xD8}); // второй SOI: i+=2
|
||||
out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xE0, 0x00, 0x12}); // APP0, len 18
|
||||
out.writeBytes(new byte[16]);
|
||||
out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xC4, 0x00, 0x02}); // DHT: не SOF, пропуск
|
||||
out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xC8, 0x00, 0x02}); // C8: не SOF
|
||||
out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xCC, 0x00, 0x02}); // CC: не SOF
|
||||
out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xD0}); // RST0: без телеги
|
||||
out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0x01}); // TEM: без телеги
|
||||
out.writeBytes(new byte[] {(byte) 0xFF, (byte) 0xC0, 0x00, 0x11, 0x08, 0x00, 0x0A, 0x00, 0x0A});
|
||||
return out.toByteArray();
|
||||
}
|
||||
|
||||
/** {@code null}-входы package-private гейтов: отказ {@link ValidationException} / false. */
|
||||
@Test
|
||||
void nullGuards_rejectBeforeWork() {
|
||||
assertThrows(ValidationException.class, () -> WordPdfValidator.checkPageCountDoc(null, 100));
|
||||
assertFalse(WordPdfValidator.isBinaryDoc(null));
|
||||
assertFalse(WordPdfValidator.isBinaryDoc(new byte[] {(byte) 0xD0, (byte) 0xCF, 0x11, (byte) 0xE0}));
|
||||
}
|
||||
|
||||
/** {@code null}-параметры публичного {@code validate}: лимиты обязаны быть заданы. */
|
||||
@Test
|
||||
void validate_nullOptions_rejected() {
|
||||
assertThrows(ValidationException.class, () -> WordPdfValidator.validate(new byte[8], null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void validate_tooManyPages() throws Exception {
|
||||
byte[] bytes = docxWithPageBreaks(120);
|
||||
|
||||
+217
@@ -0,0 +1,217 @@
|
||||
package ru.pjandro.wordpdf.internal;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.zip.ZipEntry;
|
||||
import java.util.zip.ZipOutputStream;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotSame;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertSame;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
* Юниты {@link DistributeStampNormalizer}: штамп {@code w:jc="distribute"}
|
||||
* закладкой-якорем после {@code </w:pPr>} (Part 1 §17.18.44, правило 9).
|
||||
*/
|
||||
class DistributeStampNormalizerTest {
|
||||
|
||||
private static String document(String body) {
|
||||
return "<w:document xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">"
|
||||
+ "<w:body>" + body + "</w:body></w:document>";
|
||||
}
|
||||
|
||||
/** Абзац с pPr (или без, если pPrInner пуст) и одним раном. */
|
||||
private static String para(String pPrInner, String text) {
|
||||
return "<w:p>" + (pPrInner.isEmpty()
|
||||
? "" : "<w:pPr>" + pPrInner + "</w:pPr>")
|
||||
+ "<w:r><w:t>" + text + "</w:t></w:r></w:p>";
|
||||
}
|
||||
|
||||
private static final String JC_DISTRIBUTE = "<w:jc w:val=\"distribute\"/>";
|
||||
|
||||
/** distribute-абзац: штамп сразу после </w:pPr>, id=1 (закладок нет). */
|
||||
@Test
|
||||
void distribute_paragraphStampedAfterPPr() {
|
||||
String xml = document(para(JC_DISTRIBUTE, "раз"));
|
||||
String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml);
|
||||
assertEquals(document(para(JC_DISTRIBUTE, "раз")
|
||||
.replace("</w:pPr>", "</w:pPr><w:bookmarkStart w:id=\"1\""
|
||||
+ " w:name=\"pj-distribute-document-1\"/>"
|
||||
+ "<w:bookmarkEnd w:id=\"1\"/>")),
|
||||
fixed);
|
||||
}
|
||||
|
||||
/** Несколько абзацев: имена per-part по счёту, id за max существующих. */
|
||||
@Test
|
||||
void multipleParagraphs_namesAndIdsUnique() {
|
||||
String xml = document(
|
||||
para(JC_DISTRIBUTE, "раз")
|
||||
+ "<w:p><w:pPr><w:jc w:val=\"both\"/></w:pPr>"
|
||||
+ "<w:bookmarkStart w:id=\"41\" w:name=\"_Toc1\"/><w:bookmarkEnd w:id=\"41\"/>"
|
||||
+ "<w:r><w:t>два</w:t></w:r></w:p>"
|
||||
+ para(JC_DISTRIBUTE, "три"));
|
||||
String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml);
|
||||
assertTrue(fixed.contains("w:name=\"pj-distribute-document-1\""), fixed);
|
||||
assertTrue(fixed.contains("w:name=\"pj-distribute-document-2\""), fixed);
|
||||
assertFalse(fixed.contains("w:name=\"pj-distribute-document-3\""), fixed);
|
||||
assertTrue(fixed.contains("<w:bookmarkStart w:id=\"42\" w:name=\"pj-distribute-document-1\"")
|
||||
&& fixed.contains("<w:bookmarkStart w:id=\"43\" w:name=\"pj-distribute-document-2\""),
|
||||
"id продолжение существующих: " + fixed);
|
||||
assertEquals(2, countOf(fixed, "<w:bookmarkEnd w:id=\"42\"/>") + countOf(fixed, "<w:bookmarkEnd w:id=\"43\"/>"),
|
||||
"каждому start — свой end");
|
||||
}
|
||||
|
||||
private static int countOf(String s, String sub) {
|
||||
return (s.length() - s.replace(sub, "").length()) / sub.length();
|
||||
}
|
||||
|
||||
/** Повторный вызов на проштампованном — null (идемпотентность). */
|
||||
@Test
|
||||
void alreadyStamped_returnsNull() {
|
||||
String xml = document(para(JC_DISTRIBUTE, "раз"));
|
||||
String once = DistributeStampNormalizer.rewrite("word/document.xml", xml);
|
||||
assertNull(DistributeStampNormalizer.rewrite("word/document.xml", once));
|
||||
}
|
||||
|
||||
/** jc=center/both/нет — не our case: null. */
|
||||
@Test
|
||||
void otherJustification_returnsNull() {
|
||||
String xml = document(para("<w:jc w:val=\"center\"/>", "раз") + para("", "два"));
|
||||
assertNull(DistributeStampNormalizer.rewrite("word/document.xml", xml));
|
||||
}
|
||||
|
||||
/** jc вне w:pPr (например, w:jc строки таблицы в trPr) — не штампуется. */
|
||||
@Test
|
||||
void jcOutsidePPr_returnsNull() {
|
||||
String xml = document("<w:tr><w:trPr><w:jc w:val=\"distribute\"/></w:trPr>"
|
||||
+ para("", "раз") + "</w:tr>");
|
||||
assertNull(DistributeStampNormalizer.rewrite("word/document.xml", xml));
|
||||
}
|
||||
|
||||
/** numbering.xml (уровни списков с pPrGeneral) — часть не штампуется вовсе. */
|
||||
@Test
|
||||
void nonContentPart_returnsNull() {
|
||||
String xml = "<w:numbering><w:lvl><w:pPr>" + JC_DISTRIBUTE + "</w:pPr></w:lvl></w:numbering>";
|
||||
assertNull(DistributeStampNormalizer.rewrite("word/numbering.xml", xml));
|
||||
}
|
||||
|
||||
/** footnotes.xml — штампуется с меткой части (имена не коллизируют с document). */
|
||||
@Test
|
||||
void footnotes_partTagInName() {
|
||||
String xml = document(para(JC_DISTRIBUTE, "сноска"));
|
||||
String fixed = DistributeStampNormalizer.rewrite("word/footnotes.xml", xml);
|
||||
assertTrue(fixed.contains("w:name=\"pj-distribute-footnotes-1\""), fixed);
|
||||
}
|
||||
|
||||
/** Самозакрывающийся абзац — не ломает разбор. */
|
||||
@Test
|
||||
void selfClosingParagraph_survives() {
|
||||
String xml = document("<w:p w:rsidR=\"00A1\"/><w:p><w:pPr>" + JC_DISTRIBUTE
|
||||
+ "</w:pPr><w:r><w:t>тут</w:t></w:r></w:p>");
|
||||
String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml);
|
||||
assertTrue(fixed.contains("pj-distribute-document-1"), fixed);
|
||||
}
|
||||
|
||||
/** distribute только в w:pPrChange (старое значение) — не текущий jc, не штампуем. */
|
||||
@Test
|
||||
void revisionJcOnly_returnsNull() {
|
||||
String xml = document("<w:p><w:pPr><w:jc w:val=\"both\"/>"
|
||||
+ "<w:pPrChange w:id=\"3\" w:author=\"a\">" + JC_DISTRIBUTE + "</w:pPrChange></w:pPr>"
|
||||
+ "<w:r><w:t>правка</w:t></w:r></w:p>");
|
||||
assertNull(DistributeStampNormalizer.rewrite("word/document.xml", xml));
|
||||
}
|
||||
|
||||
/** Реvision с собственным w:pPr внутри: штамп — после наружного </w:pPr>. */
|
||||
@Test
|
||||
void revisionNestedPPr_stampAfterOuterClose() {
|
||||
String xml = document("<w:p><w:pPr>" + JC_DISTRIBUTE
|
||||
+ "<w:pPrChange w:id=\"3\" w:author=\"a\"><w:pPr><w:jc w:val=\"both\"/></w:pPr>"
|
||||
+ "</w:pPrChange></w:pPr><w:r><w:t>правки</w:t></w:r></w:p>");
|
||||
String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml);
|
||||
int stamp = fixed.indexOf("pj-distribute-document-1");
|
||||
assertTrue(stamp > fixed.indexOf("</w:pPrChange>"), fixed);
|
||||
assertTrue(stamp < fixed.indexOf("<w:r>"), fixed);
|
||||
}
|
||||
|
||||
/** Колонтитулы — контентные части: штамп с меткой файла. */
|
||||
@Test
|
||||
void headerAndFooter_partStamped() {
|
||||
String xml = document(para(JC_DISTRIBUTE, "шапка"));
|
||||
String header = DistributeStampNormalizer.rewrite("word/header1.xml", xml);
|
||||
assertTrue(header.contains("w:name=\"pj-distribute-header1-1\""), header);
|
||||
String footer = DistributeStampNormalizer.rewrite("word/footer2.xml", xml);
|
||||
assertTrue(footer.contains("w:name=\"pj-distribute-footer2-1\""), footer);
|
||||
assertNull(DistributeStampNormalizer.rewrite("word/header1.xml.rels", xml));
|
||||
}
|
||||
|
||||
/** Отступы между тегами (pretty-printed часть) — pPr остаётся первым ребёнком. */
|
||||
@Test
|
||||
void whitespaceBeforePPr_stillStamped() {
|
||||
String xml = document("<w:p>\n <w:pPr>" + JC_DISTRIBUTE + "</w:pPr>\n"
|
||||
+ "<w:r><w:t>отступ</w:t></w:r></w:p>");
|
||||
String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml);
|
||||
assertTrue(fixed.contains("</w:pPr><w:bookmarkStart w:id=\"1\""
|
||||
+ " w:name=\"pj-distribute-document-1\"/>"), fixed);
|
||||
}
|
||||
|
||||
/** Чужая Word-закладка сразу после </w:pPr> — не штамп, штампуем свой. */
|
||||
@Test
|
||||
void foreignBookmarkAfterPPr_stillStamped() {
|
||||
String xml = document("<w:p><w:pPr>" + JC_DISTRIBUTE + "</w:pPr>"
|
||||
+ "<w:bookmarkStart w:id=\"7\" w:name=\"_Toc9\"/><w:bookmarkEnd w:id=\"7\"/>"
|
||||
+ "<w:r><w:t>оглав</w:t></w:r></w:p>");
|
||||
String fixed = DistributeStampNormalizer.rewrite("word/document.xml", xml);
|
||||
assertTrue(fixed.contains("w:name=\"pj-distribute-document-1\""), fixed);
|
||||
}
|
||||
|
||||
/** Контракт zip-пути: нечего менять → тот же массив; есть штамп → новые байты со штампом. */
|
||||
@Test
|
||||
void normalize_identityWhenNothing_stampWhenDistribute() throws IOException {
|
||||
byte[] clean = docx("<w:p><w:r><w:t>чисто</w:t></w:r></w:p>");
|
||||
assertSame(clean, DistributeStampNormalizer.normalize(clean));
|
||||
|
||||
byte[] dirty = docx("<w:p><w:pPr>" + JC_DISTRIBUTE + "</w:pPr>"
|
||||
+ "<w:r><w:t>тяни</w:t></w:r></w:p>");
|
||||
byte[] fixed = DistributeStampNormalizer.normalize(dirty);
|
||||
assertNotSame(dirty, fixed);
|
||||
String part = new String(entry(fixed, "word/document.xml"), StandardCharsets.UTF_8);
|
||||
assertTrue(part.contains("w:name=\"pj-distribute-document-1\""), part);
|
||||
}
|
||||
|
||||
// ================== Синтетический .docx ==================
|
||||
|
||||
private static byte[] docx(String body) throws IOException {
|
||||
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
||||
try (ZipOutputStream zos = new ZipOutputStream(bos)) {
|
||||
zos.putNextEntry(new ZipEntry("[Content_Types].xml"));
|
||||
zos.write("<Types/>".getBytes(StandardCharsets.UTF_8));
|
||||
zos.closeEntry();
|
||||
zos.putNextEntry(new ZipEntry("word/document.xml"));
|
||||
zos.write(document(body).getBytes(StandardCharsets.UTF_8));
|
||||
zos.closeEntry();
|
||||
zos.putNextEntry(new ZipEntry("word/numbering.xml"));
|
||||
zos.write("<w:numbering/>".getBytes(StandardCharsets.UTF_8));
|
||||
zos.closeEntry();
|
||||
}
|
||||
return bos.toByteArray();
|
||||
}
|
||||
|
||||
private static byte[] entry(byte[] zip, String name) throws IOException {
|
||||
try (java.util.zip.ZipInputStream zis =
|
||||
new java.util.zip.ZipInputStream(new java.io.ByteArrayInputStream(zip))) {
|
||||
ZipEntry e;
|
||||
while ((e = zis.getNextEntry()) != null) {
|
||||
if (e.getName().equals(name)) {
|
||||
return zis.readAllBytes();
|
||||
}
|
||||
}
|
||||
}
|
||||
throw new IllegalArgumentException("нет записи " + name);
|
||||
}
|
||||
}
|
||||
@@ -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 \"Раздел & номер\" ", "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));
|
||||
}
|
||||
}
|
||||
@@ -3,6 +3,7 @@ package ru.pjandro.wordpdf.internal;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertSame;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
@@ -125,4 +126,69 @@ class LayoutPostRendererTest {
|
||||
String fo = "<fo:root><fo:block font-family=\"DejaVu Sans\">text</fo:block></fo:root>";
|
||||
assertSame(fo, LayoutPostRenderer.fix(fo));
|
||||
}
|
||||
|
||||
// ================== distribute-штамп ==================
|
||||
|
||||
/** Якорь-закладка: блок получает пару justify-свойств (Part 1 §17.18.44). */
|
||||
@Test
|
||||
void distributeStamp_justifyPairAdded() {
|
||||
String fo = "<fo:block font-family=\"Carlito Regular\"><fo:inline id=\"pj-distribute-document-1\"/>"
|
||||
+ "alpha bravo</fo:block>";
|
||||
String fixed = LayoutPostRenderer.fix(fo);
|
||||
assertTrue(fixed.contains("<fo:block font-family=\"Carlito Regular\""
|
||||
+ " text-align=\"justify\" text-align-last=\"justify\">"), fixed);
|
||||
}
|
||||
|
||||
/** Якорь в колонтитуле (fo:static-content) — justify-пара так же дописывается. */
|
||||
@Test
|
||||
void distributeStamp_inStaticContent_justifyPairAdded() {
|
||||
String fo = "<fo:static-content flow-name=\"xsl-region-before\">"
|
||||
+ "<fo:block font-family=\"Carlito Regular\">"
|
||||
+ "<fo:inline id=\"pj-distribute-header1-1\"/>шапка строки</fo:block>"
|
||||
+ "</fo:static-content>";
|
||||
String fixed = LayoutPostRenderer.fix(fo);
|
||||
assertTrue(fixed.contains("<fo:block font-family=\"Carlito Regular\""
|
||||
+ " text-align=\"justify\" text-align-last=\"justify\">"), fixed);
|
||||
}
|
||||
|
||||
/** Реальная форма сериализации docx4j: DOM-поддерево без префикса fo. */
|
||||
@Test
|
||||
void distributeStamp_unprefixedInline_stillStamped() {
|
||||
String fo = "<fo:block font-size=\"11.0pt\">"
|
||||
+ "<inline xmlns=\"http://www.w3.org/1999/XSL/Format\" id=\"pj-distribute-document-1\"/>"
|
||||
+ "alpha</fo:block>";
|
||||
String fixed = LayoutPostRenderer.fix(fo);
|
||||
assertTrue(fixed.contains("<fo:block font-size=\"11.0pt\""
|
||||
+ " text-align=\"justify\" text-align-last=\"justify\">"), fixed);
|
||||
}
|
||||
|
||||
/** Текст уже выровнен (both + наш штамп) — дописывается только align-last. */
|
||||
@Test
|
||||
void distributeStamp_existingTextAlignPreserved() {
|
||||
String fo = "<fo:block text-align=\"justify\"><fo:inline id=\"pj-distribute-document-2\"/>x</fo:block>";
|
||||
String fixed = LayoutPostRenderer.fix(fo);
|
||||
assertTrue(fixed.contains("text-align=\"justify\" text-align-last=\"justify\""), fixed);
|
||||
assertFalse(fixed.contains("text-align-last=\"justify\" text-align-last"), fixed);
|
||||
}
|
||||
|
||||
/** text-align-last уже задан — блок не трогается, чужая закладка молча живёт. */
|
||||
@Test
|
||||
void distributeStamp_alignLastAlreadySet_untouched() {
|
||||
String fo = "<fo:block text-align-last=\"center\"><fo:inline id=\"pj-distribute-footnotes-1\"/>x</fo:block>";
|
||||
assertSame(fo, LayoutPostRenderer.fix(fo));
|
||||
}
|
||||
|
||||
/** Закладка вне fo:block (после закрытия) — правки нет, FO не ломается. */
|
||||
@Test
|
||||
void distributeStamp_outsideBlock_untouched() {
|
||||
String fo = "<fo:block>до</fo:block><fo:inline id=\"pj-distribute-document-1\"/>";
|
||||
assertSame(fo, LayoutPostRenderer.fix(fo));
|
||||
}
|
||||
|
||||
/** Обычная закладка пользователя (не pj-distribute) — игнор. */
|
||||
@Test
|
||||
void userBookmark_ignored() {
|
||||
String fo = "<fo:block><fo:inline id=\"_Toc12345\"/>x</fo:block>";
|
||||
assertSame(fo, LayoutPostRenderer.fix(fo));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -17,7 +17,7 @@ import static org.junit.jupiter.api.Assertions.assertSame;
|
||||
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}
|
||||
* (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:rFonts w:ascii=\"Symbol\" w:hAnsi=\"Symbol\"/>"), xml);
|
||||
assertTrue(xml.contains("<w:lvlText w:val=\"\uF0B7\"/>"),
|
||||
"PUA-символ дословно (чинит SymbolFontNormalizer): " + xml);
|
||||
"PUA-символ дословно (маппит экспорт docx4j 17.3.x): " + xml);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
Binary file not shown.
Reference in New Issue
Block a user