feat(core): собственный рендер OMML→PNG и полный FOP-конфиг шрифтов
PR checks / web (pull_request) Successful in 9s
PR checks / java (pull_request) Successful in 5m26s
Main: tests, deploy, autotests / web (push) Successful in 9s
Main: tests, deploy, autotests / images-web (push) Successful in 23s
Main: tests, deploy, autotests / java (push) Successful in 1m30s
Main: tests, deploy, autotests / images-app (push) Successful in 49s
Main: tests, deploy, autotests / deploy (push) Successful in 2m13s
Main: tests, deploy, autotests / autotests (push) Successful in 17s
Main: tests, deploy, autotests / rollback (push) Has been skipped

Замена JEuclid/AWT-ветки формул на детерминированный растер только
бандл-шрифтами jar (без fontconfig); FOP-конфиг дополняется всеми
бандл-начертаниями при каждом declare — иначе общая FopFactory
замораживает fopconf первого документа и теряет глифы.

MathModel/MathRenderer: OMML (§22.1) → дерево боксов → PNG 300 dpi
(только GlyphFont/fontbox, без java.awt.Font); метрики боксов равны
габариту paint (пределы nary/sPre не обрезаются канвой). Unsupported
конструкция или переполнение бюджета — текстовая деградация (m:t).
Inline-картинка опускается раном w:rPr/w:position на базовую линию
строки (FOP ставит инлайн-графику нижним краем на базу; AUDIT-FIX
baseline-shift). Байтовое правило 6 MathFallbackNormalizer (перед
GlyphCoverage) срезает unsupported-формулы до загрузки docx4j; формула
в wps:txbx уходит в docx4j-фолбэк mathText.

JEuclid исключён из pom (de.rototor jeuclid-core/jeuclid-fop); порядок
zip-правил сдвинут (MathFallback → 6). Порядок сканов шрифтов закрыт
гейтом FontsBundledOnlyInvariantTest + BundledFontAliases (единый
алиас-реестр вместо рефлексивных мутаций реестра).

Счётчики: 63 класса / 1004 теста (core 57/956, app 6/48); JaCoCo
BRANCH core 0.8518. Доки: pipeline/render-limitations/repo-map/
testing/doc-bridge/MEM_USAGE_UPGRADE синхронизированы.
This commit was merged in pull request #113.
This commit is contained in:
Pjandro
2026-11-20 23:51:40 +03:00
parent 202e4ca97e
commit f3ff218686
27 changed files with 2894 additions and 328 deletions
+6 -6
View File
@@ -15,7 +15,7 @@
0. `DependencyGuard.check()` (commons-compress ≥ 1.25.0 API-проба);
1. шрифты: `new BundledFontMapper()` → `BundledFonts.init()` → `restrictToBundled()` — строго в этом порядке, до `load()`;
2. нормализаторы (`DocxRewritePipeline.STEP` + лямбда `OleObjectNormalizer`) → `WordprocessingMLPackage.load`;
3. `setFontMapper`; 3.5 `DrawingPreRenderer.run` (chart/SmartArt → PNG; error-флаги бросаются здесь) — **обязателен до `FOSettings`**, иначе FOP молча теряет диаграммы;
3. `setFontMapper`; 3.5 `DrawingPreRenderer.run` (chart/SmartArt/OMML-формулы → PNG; error-флаги бросаются здесь) — **обязателен до `FOSettings`**, иначе FOP молча теряет диаграммы;
4. `FOSettings` + `ChartImageHandler` + `FopFallbackFonts.declare`; 4.25 `LayoutPostRenderer.register`; 4.5 `setCustomXsltTemplates(VendoredXslt.TEMPLATES)`;
5. общая `FopFactory` (DCL на мониторе `WordPdfConverter.class`);
6. `Docx4J.toFO(…, FLAG_EXPORT_PREFER_XSL)` — последним;
@@ -25,9 +25,9 @@
**Слои ядра** (`wordpdf-core/src/main/java/ru/pjandro/wordpdf/`):
- публичный API: `WordPdfConverter`, `WordPdfValidator`, `ConvertOptions` (record `errorOnCharts/errorOnSmartArt/errorOnOle/maxMb/maxPages` — порядок полей фиксирован), `ConversionException` + `ValidationException` + `Charts/SmartArt/OleFoundException`; `warmup()` — идемпотентный прогрев (никогда не бросает), решает вызывающий;
- `internal/`: контракт нормализатора — `byte[] normalize(byte[])`, нечего менять → **тот же массив** (`assertSame`); правила 1–11 идут одним zip-проходом `DocxRewritePipeline.STEP` в фиксированном порядке Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby→MathFallback, `OleObjectNormalizer` — 12-й, отдельным байтовым проходом (не zip); неизменённые записи копируются raw-сжатыми байтами; наружу только `DocxNormalizer`, `DocxRewritePipeline.STEP`, `OleObjectNormalizer`, `FopFallbackFonts`, `LayoutPostRenderer`, `DependencyGuard`;
- `internal/`: контракт нормализатора — `byte[] normalize(byte[])`, нечего менять → **тот же массив** (`assertSame`); правила 1–11 идут одним zip-проходом `DocxRewritePipeline.STEP` в фиксированном порядке Strict→OnOff→Symbol→Field→Invisible→MathFallback→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby, `OleObjectNormalizer` — 12-й, отдельным байтовым проходом (не zip); неизменённые записи копируются raw-сжатыми байтами; наружу только `DocxNormalizer`, `DocxRewritePipeline.STEP`, `OleObjectNormalizer`, `FopFallbackFonts`, `LayoutPostRenderer`, `DependencyGuard`;
- `internal/doc`: мост `.doc`→`.docx`, 17 top-level классов (+ вложенный `DocxBody` в `DocToDocx`), наружу только `DocToDocx.convert/countPages`; любая бита/шифрованный/Word 6-95 входов → `ConversionException`; раскладки — `docs/agent/doc-bridge.md`;
- `internal/chart`: Java2D → PNG (`ChartRenderer.DPI = 300`, `MAX_PIXELS` 4096² — `fitDpi` понижает dpi; `MAX_POINTS` 100 000, бюджет chart-PNG на документ 128 MiB); модель **деградации**: битая chart-часть/превышение бюджета → объект удалён + warn; `wp:extent` вне диапазона/ноль → объект **остаётся** + warn (FOP молча потеряет); `OutOfMemoryError` — не деградация, а `ConversionException` (500);
- `internal/chart`: Java2D → PNG (`ChartRenderer.DPI = 300`, `MAX_PIXELS` 4096² — `fitDpi` понижает dpi; `MAX_POINTS` 100 000, бюджет chart/math-PNG на документ 128 MiB); формулы OMML — собственный растер `MathModel` (разбор §22.1 в дерево боксов, `SUPPORTED` — единый список конструкций) + `MathRenderer` (без AWT/JEuclid, только бандл через `GlyphFont`); модель **деградации**: битая chart-часть/превышение бюджета → объект удалён + warn; неподдерживаемая/битая формула → **текст** (конкатенация `m:t`) + warn; `wp:extent` вне диапазона/ноль → объект **остаётся** + warn (FOP молча потеряет); `OutOfMemoryError` — не деградация, а `ConversionException` (500);
- `fonts/GlyphFont`: метрика/глифы через fontbox напрямую, **без** `java.awt.Font` (fontconfig хосту не нужен).
**Concurrency-инвариант**: `PhysicalFonts` — глобальный мутируемый реестр → все конвертации сериализованы монитором `WordPdfConverter.class` (convert, warmup, DCL-фабрика, мутации `BundledFonts`, `BundledFonts.font()`). Приложение дополнительно держит однопоточный `ThreadPoolExecutor` (очередь 16 → 503, `wordpdf.convert-timeout=2m` → 504), головой очереди стоит `warmup()`; `WordPdfValidator.checkInput` выполняется синхронно до очереди.
@@ -86,9 +86,9 @@ python3 docs/standards/docx/validate-fixtures.py wordpdf-core/src/test/resources
- Классы `final`, приватный конструктор, только `static` (stateless, DI в ядре нет). Исключения-экземпляры: `BundledFontMapper`, Spring-компоненты app. В `internal/**` классы package-private; `public` — только вызываемые извне пакета, контракт не расширять.
- Ошибки публичного API — только `ConversionException extends RuntimeException`; `ValidationException` не оборачивать; в chart — деградация вместо падения; текст 500 наружу фиксированный (сообщения ядра логируются, не отдаются).
- Javadoc на русском: «зачем» со ссылкой на секцию спецификации (§17.3.2.24, [MS-DOC] §2.6.1…) + что сломается без шага + регрессия в формате `Регрессия — WordPdfConverterTest#имя, фикстура samples/….docx` (по этой строке грепом восстанавливаются пары «нормализатор-тест ↔ тест-в-конвейере»).
- Логирование по пакетам: `java.util.logging` — корневой пакет и `internal/` (`WordPdfConverter`, `MathMlSupport`, `OleObjectNormalizer`, `DocToDocx`); SLF4J — `internal/chart` и `wordpdf-app`.
- Логирование по пакетам: `java.util.logging` — корневой пакет и `internal/` (`WordPdfConverter`, `OleObjectNormalizer`, `DocToDocx`); SLF4J — `internal/chart` и `wordpdf-app`.
- Модели — `record` (`ConvertOptions`, `BundledFonts.Entry`, `ApiError`); константы UPPER_SNAKE с javadoc-обоснованием числа; holder-идиомы для ленивой инициализации (`VendoredXslt.TEMPLATES`); compile-time literals там, где важен инлайн (`WordPdfConverter` ↔ `WordPdfValidator`).
- Шрифты: новый шрифт = файл в `resources/fonts/` + запись в `BundledFonts.ENTRIES` (синхрон проверяет `BundledFontsTest`); алиасы — `BundledFontMapper.ALIASES` (Calibri→Carlito, Cambria→Caladea, Arial→Arimo, Times New Roman→Tinos, Courier New→Cousine, …), fallback — DejaVu Sans.
- Шрифты: новый шрифт = файл в `resources/fonts/` + запись в `BundledFonts.ENTRIES` (синхрон проверяет `BundledFontsTest`); алиасы — `BundledFontAliases.ALIASES` (Calibri→Carlito, Cambria→Caladea, Arial→Arimo, Times New Roman→Tinos, Courier New→Cousine, …; вынесено из `BundledFontMapper`, чтобы обращение к статикам не инициировало ungated-скан `BestMatchingMapper.<clinit>`), fallback — DejaVu Sans.
- PMD (`pmd-ruleset.xml`, execution `pmd-check` на `verify`, `includeTests=true`, валит любой приоритет): правила не перенастраивать, подавления (`@SuppressWarnings("PMD…")`, `// NOPMD`) запрещены — нарушения чинятся кодом.
- Git: origin `git.pjandro.ru:pjandro/java-word-pdf`; защищённые `main`/`master`/`dev`; все правки — через PR в дефолтную ветку; push — только после `./mise.sh run verify`. Прод-координаты и креды в репо не попадают (Gitea Variables/Secrets — `GITEA-vars.md`; `WORDPDF_API_KEY` ни в один файл).
@@ -122,5 +122,5 @@ python3 docs/standards/docx/validate-fixtures.py wordpdf-core/src/test/resources
- Фикстуры — только закоммиченные `samples/*.docx`/`*.doc`, в тестах не генерировать; XSD-невалидная фикстура правится, не код. Синтетика в памяти разрешена: docx — `ZipOutputStream` из литеральных XML, `.doc` — крафт `POIFSFileSystem`. Пересоздание — одноразовые `SampleDocxGenerator`/`ChartTypesDocxGenerator` (POI test-scope, команда — `docs/agent/repo-map.md`); `charts-smartart.docx` и `ole-embedded.docx` сделаны руками — **никогда не перезаписывать** (все 12 `.doc` — эталоны заказчика, не вывод генераторов).
- Идиома загрузки (ловушка): **core** — classloader без ведущего слэша (`getResourceAsStream("samples/…")`); **app** — class-relative со слэшем (`"/samples/…"`, ресурсы из core test-jar).
- App-тесты: 4 набора свойств = 4 Spring-контекста (`ConvertControllerTest` пинует пустой `wordpdf.api-key=`; `ApiKeyFilterTest`; `ConvertLimitsTest`; `ConversionTimeoutTest`); `ConversionServiceTest`/`ApiExceptionHandlerTest` — без Spring; проверяют только HTTP-код/заголовки/текст ошибки; core-юниты Spring не поднимают. Ловушка: mise инжектирует корневой `.env` в окружение задач — ambient `WORDPDF_API_KEY` взорвёт 401 все MockMvc-тесты, если ключ не запинен свойствами контекста.
- Регрессивная конвенция: фикс = нормализатор/рендерер + юнит + конвертер-тест + javadoc-ссылка. Счётчики (2026-11): 60 классов / 962 теста (core 54/914, app 6/48); детали — `docs/agent/testing.md`.
- Регрессивная конвенция: фикс = нормализатор/рендерер + юнит + конвертер-тест + javadoc-ссылка. Счётчики (2026-11): 63 класса / 1004 теста (core 57/956, app 6/48); детали — `docs/agent/testing.md`.
- Прод-автотесты: pytest 9.1.1 + requests (timeout `(10,180)` — больше серверных 2m), конфигурация **только env** (`WORDPDF_BASE_URL` обязателен, `WORDPDF_API_KEY` факультативен → `needs_key` SKIP, `WORDPDF_MAX_MB`/`MAX_PAGES` — ожидаемые лимиты стенда 5/100, `WORDPDF_SAMPLES_DIR` — путь к фикстурам); запуск `./mise.sh run prod-tests` либо job `autotests` в CI.
+6 -3
View File
@@ -84,8 +84,10 @@ JVM: temurin 17.0.21, флаги харнеса `-Xms64m -Xmx2g -XX:+UseG1GC -XX
Xalan/XSLT, FOP (таблицы OpenType: `OTFAdvancedTypographicTableReader`, `OpenFont.readHorizontalMetrics`),
commons-io `IOUtils.byteArray`, `Arrays.copyOf`, `Throwable.fillInStackTrace` (docx4j использует
исключения как control flow — «Package field null» и т.п.);
- JEuclid (`Parser.parseStreamSourceAsOdf`) — OMML-формулы на хосте с fontconfig (в CI/контейнере
иначе: MathFallback).
- ~~JEuclid (`Parser.parseStreamSourceAsOdf`) — OMML-формулы на хосте с fontconfig (в CI/контейнере
иначе: MathFallback)~~ — **удалён из класса путей** (2026-11): jeuclid исключён exclusion'ом из
`docx4j-export-fo`, формулы рисует собственный `MathRenderer` (PNG, только бандл-шрифты);
`MathFallbackNormalizer` теперь деградирует в текст только конструкции вне `MathModel.SUPPORTED`.
## 3. Что нашли при чтении кода (архитектурные находки)
@@ -135,7 +137,8 @@ JVM: temurin 17.0.21, флаги харнеса `-Xms64m -Xmx2g -XX:+UseG1GC -XX
- вердикт гейта: не улучшено → откачен, конвейер остался на `ByteArrayOutputStream`.
**Итог по правкам ядра: ни один кандидат не прошёл гейт.** Это не «нечего улучшать», а «у текущих
документов память тратят библиотеки» (JAXB-via-DOM, XSLT, FOP-шрифты, JEuclid — §2): точечными
документов память тратят библиотеки» (JAXB-via-DOM, XSLT, FOP-шрифты — §2; JEuclid больше
не потребитель — исключён из зависимостей): точечными
правками репозитория их не сократить, а правки библиотек/форка (FO-стриминг, font cache) —
отдельные задачи с фиделити-гейтом. Практический рычаг «потреблять меньше» прямо сейчас — размеры
кучи и GC (§5).
+1 -1
View File
@@ -4,7 +4,7 @@
Java2D → PNG 300 dpi (`ChartRenderer.DPI = 300`, `PADDING = 4.0`, растр × `DPI/72`, размеры в пунктах, EMU→pt `cx/12700.0`). Потолок растра `ChartRenderer.MAX_PIXELS = 16_777_216` (4096², 64 МБ ARGB): при превышении `fitDpi` uniform-но понижает эффективный dpi (геометрия в пунктах и безразмерные пропорции не меняются; 24″-график: 208 МБ → 64 МБ, dpi 300 → ≈171); `SmartArtRenderer` использует тот же `DPI`/`fitDpi`. `ChartSpec.parse` (`enum Type`: PIE, PIE3D, DOUGHNUT, BAR, BAR_HORIZONTAL, LINE, AREA, SURFACE3D, AREA3D, BAR3D, LINE3D, RADAR, SCATTER, BUBBLE, STOCK, OF_PIE, SURFACE, UNSUPPORTED). `c:autoTitleDeleted` (§21.2.2.7, `val` опущен — default true) применяется только при отсутствии `c:title` (MS-OI29500 §2.1.1431(a)) — явный заголовок показывается при любом флаге; при отсутствии `c:title` и `val=0` рисуется автозаголовок. Пустой/пробельный `c:title` (или `val=0` без `c:title`) — автозаголовок Office (MS-OI29500 §2.1.1561(a)): одиночный ряд с именем → имя ряда (любой тип графика), иначе `ChartSpec.AUTO_TITLE = "Название диаграммы"`; несколько абзацев `a:p` склеиваются `'\n'` (жёсткий перенос в `DrawMlText`). Регрессии — `ChartSpecTest#emptyTitleSingleSeriesBar_usesSeriesName`, `#deletedTitleWithText_stillShown`, `#deletedTitleValOmitted_stillShown`, `#multiSeriesDoughnut_placeholderNotSeriesName`, `#multiParagraphTitle_joinedWithNewlines`. Палитра `accent1..6` темы; легенда по умолчанию снизу; `overlay` (§21.2.2.132) рисуется поверх области построения, место не резервирует.
Пейнтеры: `CartesianPainter` (2-D line/bar/area; `c:grouping` stacked/percentStacked §21.2.2.76 — ряд рисуется накопленной суммой через `ChartRenderer.stackedCumulative`), `PiePainter` (`PIE_DEPTH = 0.22`, `PIE_FIT = 0.865`), `Surface3dPainter` (камера — регрессия `cameraMatchesWordReference`: `DEPTH_RATIO = 0.705`, `HEIGHT_RATIO = 0.664`, `GUTTER_LEFT/RIGHT = 0.1485`, `GUTTER_TOP = 0.116`, `GUTTER_BOTTOM = 0.146`, свет `LIGHT_X/Y/Z = 0.83/0.48/0.28`; `c:rAngAx=true` приоритетнее `c:perspective` (MS-OI29500 §2.1.1516(b)); `c:wireframe` §21.2.2.205 — только каркас), `ScatterPainter` (радиус пузыря sqrt при `c:sizeRepresents="area"` §21.2.2.128), `RadarPainter` (спицы от 12 часов), `StockPainter` (upDownBars обводятся контуром, дефолт чёрный 0.75pt), `OfPiePainter` (MS-OI29500 §2.1.1507(a), §2.1.1545(a)), `Surface2dPainter` (контурная карта §21.2.2.204, marching squares, изолинии по `c:bandFmts` §21.2.2.13/.14), `Cartesian3dPainter` (bar3D/line3D/area3D §21.2.2.19/.101/.122, `c:shape` §21.2.3.44), `SmartArtRenderer` (кэш `word/diagrams/drawing1.xml` через relationship `…/office/2007/relationships/diagramDrawing`; формы — `PresetGeometry` из `a:prstGeom`, семь пресетов дословно из `presetShapeDefinitions.xml`; оператор `?:` = «if x > 0 then y else z» (ISO/IEC 29500-1, **не** x != 0); углы в Arc2D — со знаком минус; текст — `DrawMlText`, шрифты через `BundledFontMapper.bundledFamily`; autofit только `normAutofit` §21.1.2.1.2/.3; `dgm:prSet/@phldrT` не рисуется).
Пейнтеры: `CartesianPainter` (2-D line/bar/area; `c:grouping` stacked/percentStacked §21.2.2.76 — ряд рисуется накопленной суммой через `ChartRenderer.stackedCumulative`), `PiePainter` (`PIE_DEPTH = 0.22`, `PIE_FIT = 0.865`), `Surface3dPainter` (камера — регрессия `cameraMatchesWordReference`: `DEPTH_RATIO = 0.705`, `HEIGHT_RATIO = 0.664`, `GUTTER_LEFT/RIGHT = 0.1485`, `GUTTER_TOP = 0.116`, `GUTTER_BOTTOM = 0.146`, свет `LIGHT_X/Y/Z = 0.83/0.48/0.28`; `c:rAngAx=true` приоритетнее `c:perspective` (MS-OI29500 §2.1.1516(b)); `c:wireframe` §21.2.2.205 — только каркас), `ScatterPainter` (радиус пузыря sqrt при `c:sizeRepresents="area"` §21.2.2.128), `RadarPainter` (спицы от 12 часов), `StockPainter` (upDownBars обводятся контуром, дефолт чёрный 0.75pt), `OfPiePainter` (MS-OI29500 §2.1.1507(a), §2.1.1545(a)), `Surface2dPainter` (контурная карта §21.2.2.204, marching squares, изолинии по `c:bandFmts` §21.2.2.13/.14), `Cartesian3dPainter` (bar3D/line3D/area3D §21.2.2.19/.101/.122, `c:shape` §21.2.3.44), `SmartArtRenderer` (кэш `word/diagrams/drawing1.xml` через relationship `…/office/2007/relationships/diagramDrawing`; формы — `PresetGeometry` из `a:prstGeom`, семь пресетов дословно из `presetShapeDefinitions.xml`; оператор `?:` = «if x > 0 then y else z» (ISO/IEC 29500-1, **не** x != 0); углы в Arc2D — со знаком минус; текст — `DrawMlText`, шрифты через `BundledFontAliases.bundledFamily`; autofit только `normAutofit` §21.1.2.1.2/.3; `dgm:prSet/@phldrT` не рисуется).
Защитные лимиты против враждебного chart-XML: `ChartSpec.MAX_POINTS = 100_000` (`c:pt/@idx` §21.2.2.150/.151, `c:ptCount` §21.2.2.152 — ST_UnsignedInt без верхней границы; отказ `IllegalArgumentException` **до** предвыделения списка), `ChartRenderer.MAX_TICKS = 1000` (шаг ≤ 0/NaN/слишком мелкий в `axisBounds` заменяется `niceUnit` 1/2/5·10ⁿ), `DrawingPreRenderer.MAX_EXTENT_EMU = 22_000_000` (≈24″; при `cx/cy` вне капа объект **оставляется как есть** + warn, картинка не рендерится — регрессия `hugeExtentChart_removedNotOom`). Бросок перехватывает catch в `DrawingPreRenderer.renderChart` → штатная деградация «объект удалён + warn». Обход `pkg.getParts()` — только по **снимку** списка (вставка media-частей `addChartMedia→addPart→loadPart` мутирует реестр → CME); rels частей — `part.getRelationshipsPart()`, **не** `getOwningRelationshipPart()`; обход XML обязан раскрывать `JAXBElement`.
File diff suppressed because one or more lines are too long
+10 -10
View File
@@ -8,8 +8,8 @@
| 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–11 — раздел «Нормализаторы: контракт и правила 1–12» в этом файле) + условная OLE-вычистка (правило 12)|
| 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 встраивает только задекларированные |
| 3.5 | `DrawingPreRenderer.run(pkg, options)` | `c:chart`/`dgm:relIds`/`m:oMath` → PNG 300 dpi → `pic:pic` (docx2fo.xslt их не умеет); формулы — собственный растер `MathModel`/`MathRenderer` (только бандл-шрифты, без AWT/JEuclid), inline-картинка опускается ран-`w:rPr/w:position` на свой нижний запас (FOP ставит инлайн-графику нижним краем на базу строки; регрессия — WordPdfConverterTest#ommlMathInline_sitsOnTextBaseline), неподдерживаемая конструкция — текстовая деградация + warn; budget chart/math-PNG общий |
| 4 | `new FOSettings(pkg)` + `FopFallbackFonts.declare(foSettings)` | В FOP-конфиг добавляются **все** бандл-семейства: FOP встраивает только задекларированные. Конфиг обязан быть **полным при каждом `declare`**: docx4j декларирует из `fontsInUse` только использованные начертания (или simulate-style на regular-файле), а общая `FopFactory` замораживает fopconf **первого** документа JVM — `declareFamily`+`hasRealFace` дополняют каждое семейство недостающими реальными начертаниями (регрессия — `fopFactoryFrozenFromFirstDoc_fontsComplete`) |
| 4.25 | `LayoutPostRenderer.register(foSettings)` | Кастомный `FORenderer`: post-FO padding-компенсация таблиц (`start-indent` += `padding-left` первой ячейки), внутри — штатный `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 |
@@ -22,25 +22,25 @@
### Валидация входа и подсчёт страниц
Вход валидируется **до** `convertToStream`: `WordPdfValidator.validate(bytes, options)` (размер → подпись: zip `PK\x03\x04` или CFB `D0 CF 11 E0` → контейнер → страницы). Для `.doc` страницы считаются **по сырым байтам .doc, до конвертации**: `checkPageCountDoc` = `max(SummaryInfo PageCount, 1 + разрывы 0x0C − непрерывные межсекционные (sprmSBkc 0/1) + sprmPFPageBreakBefore)` (код — `DocFile.countPages`). Тот же метод — вход приложения. Скан выполняется ровно один раз по сырому входу, до аллокаций docx4j: правила 1–11 число учитываемых разрывов не увеличивают (правило 9 способно только убрать разрыв внутри скрытого рана — счёт по сырому входу остаётся верхней оценкой лимита).
Вход валидируется **до** `convertToStream`: `WordPdfValidator.validate(bytes, options)` (размер → подпись: zip `PK\x03\x04` или CFB `D0 CF 11 E0` → контейнер → страницы). Для `.doc` страницы считаются **по сырым байтам .doc, до конвертации**: `checkPageCountDoc` = `max(SummaryInfo PageCount, 1 + разрывы 0x0C − непрерывные межсекционные (sprmSBkc 0/1) + sprmPFPageBreakBefore)` (код — `DocFile.countPages`). Тот же метод — вход приложения. Скан выполняется ровно один раз по сырому входу, до аллокаций docx4j: правила 1–11 число учитываемых разрывов не увеличивают (правило 10 способно только убрать разрыв внутри скрытого рана — счёт по сырому входу остаётся верхней оценкой лимита).
- Страницы в валидаторе = `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–12 (детали)
Контракт: `byte[] normalize(byte[]) throws IOException`; нечего менять → вернуть **тот же массив** (`assertSame` в тестах). Одиннадцать rewrite-нормализаторов цепляются в фиксированном порядке Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby→MathFallback; константу `STEP` (`public static final DocxNormalizer`) несёт только `DocxRewritePipeline` (собирает рерайты сам), у `OleObjectNormalizer` STEP **нет** — он подключается лямбдой в `WordPdfConverter.normalizers()`, а вместо `normalize(byte[])` у него `normalize(byte[], boolean)`. Правила 1–11 применяет `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→Symbol→Field→Invisible→MathFallback→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby; константу `STEP` (`public static final DocxNormalizer`) несёт только `DocxRewritePipeline` (собирает рерайты сам), у `OleObjectNormalizer` STEP **нет** — он подключается лямбдой в `WordPdfConverter.normalizers()`, а вместо `normalize(byte[])` у него `normalize(byte[], boolean)`. Правила 1–11 применяет `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`) — контекст правила 10; неизменённые записи переносятся 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.174 — псевдонимы left/right; у `w:pgNumType` `w:start` — старт нумерации страниц, легален в transitional, Part 1 §17.13.4 — не трогается) и не переименовывается, если в том же открывающем теге уже есть `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 буквально — аудит раскладки ECMA-376, матрица B3, а центрированию пишет абсолютный start-indent **без** вычета cellMar, поверх которого padding-компенсация правила LayoutPostRenderer уводит текст на +padding — свёртка обязательна и при X=0): center → (W−T)/2+X, right → (W−T)+X, W — полоса набора (pgSz − pgMar left/right; у CT_PageMar полей `w:start`/`w:end` нет, полоса берётся из сырого document.xml до правила 1; дефолты 11906/1440 — измеренное поведение docx4j, ECMA дефолтов не фиксирует §17.6.11/.13), T — Σ gridCol; пропускает несколько body-level `sectPr`, `tblInd` с явным `w:type` ≠ dxa (опущенный type — dxa, §17.4.87), `tblPr` с `tblCellSpacing` без `tblInd` (нет корректной позиции вставки по CT_TblPrBase), `tblW pct`, нецелые gridCol. Кроме `rewrite` (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; ST_LevelSuffix Part 1 §17.9.28): docx4j разделитель не эмитит вовсе (дамп n4.fo); уже пробельный lvlText не дублируется; suff=tab — отдельный Class C-остаток (нужна per-item ширина), nothing совпадает с docx4j. Регрессия — WordPdfConverterTest#suffSpace_labelGetsSpace.
9. `HiddenTextNormalizer` — вырезание скрытых ранов (Part 1 §17.3.2.41): truthy `w:vanish` в собственном `w:rPr` ранa (обе OnOff-формы; вал опущен — default true; явный `false/0/off` в ране **перекрывает** vanish-стиль) **или** `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, #hiddenText_directFalseOverridesVanishStyle, юниты — HiddenTextNormalizerTest.
10. `RubyNormalizer` — разбор руби-разметки (Part 1 §17.3.3.24–.28): снимается обёртка `w:ruby` (схемно-валидная транзишнл-разметка `w:r`→`w:ruby`→rubyPr/rt/rubyBase иначе достаёт catch-all-шаблону XSLT, и база теряется молча), `w:rubyBase` разворачивается в обычные раны, `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. `MathFallbackNormalizer` — деградация OMML-формул (§22.1) в текст на хостах без fontconfig: `m:oMathPara`/`m:oMath` → обычные раны с конкатенацией `m:t` (как в штатном фолбэке docx4j `XsltFOFunctions.mathText`). JEuclid (`jeuclid-fop`) при первой формуле обращается к AWT-менеджеру шрифтов, которому на Linux нужен fontconfig; без него — `InternalError: Fontconfig head is null` (контейнерный рантайм проекта без fontconfig — Containerfile). На хосте с fontconfig рерайт не срабатывает (`rewrite` → `null`, тот же массив). `m:oMathPara` содержит `m:oMath`, поэтому блок para заменяется первым. Регрессия — WordPdfConverterTest#ommlMath_drawnAsVectors.
6. `MathFallbackNormalizer` — байтовый скан OMML-формул (§22.1) до загрузки пакета: формулы с конструкциями вне `MathModel.SUPPORTED` (или structurally битые) деградируют в текст — `m:oMathPara`/`m:oMath` → обычные раны с конкатенацией `m:t` (как в штатном фолбэке docx4j `XsltFOFunctions.mathText`); поддерживаемые части не трогаются (`rewrite` → `null`, тот же массив) — их рисует собственный `MathRenderer` на шаге 3.5. Позиция **до GlyphCoverage** обязательна: деградировавшие раны с математическими символами (U+1D400+) обязаны пройти резку по покрытию, иначе FOP рисует «#». `m:oMathPara` содержит `m:oMath`, поэтому блок para заменяется первым. Регрессия — WordPdfConverterTest#ommlMathUnsupported_flattenedToText, юниты — MathFallbackNormalizerTest.
7. `GlyphCoverageNormalizer` — режет раны по покрытию глифов и пишет семейство в `w:rFonts`, иначе FOP рисует «#». Покрытие — `GlyphFont` (fontbox, cmap) + BitSet-кэш, **не** docx4j `GlyphCheck` (плодит INFO-лог; `java.awt.Font` требовал fontconfig на хосте). Для serif-ран fallback ищется сначала в `SERIF_FAMILIES` (`dejavu serif`, `tinos`, `caladea`), затем в sans.
8. `TableIndentNormalizer` — свёртка `w:tblPr/w:jc` (center/right) с любым (в т.ч. отсутствующим/нулевым) `w:tblInd` в абсолютный `w:tblInd` с удалением `w:jc` (Word: tblInd — сдвиг от поля после центрирования, MS-OI29500 §2.1.155; docx4j при jc≠left игнорирует tblInd буквально — аудит раскладки ECMA-376, матрица B3, а центрированию пишет абсолютный start-indent **без** вычета cellMar, поверх которого padding-компенсация правила LayoutPostRenderer уводит текст на +padding — свёртка обязательна и при X=0): center → (W−T)/2+X, right → (W−T)+X, W — полоса набора (pgSz − pgMar left/right; у CT_PageMar полей `w:start`/`w:end` нет, полоса берётся из сырого document.xml до правила 1; дефолты 11906/1440 — измеренное поведение docx4j, ECMA дефолтов не фиксирует §17.6.11/.13), T — Σ gridCol; пропускает несколько body-level `sectPr`, `tblInd` с явным `w:type` ≠ dxa (опущенный type — dxa, §17.4.87), `tblPr` с `tblCellSpacing` без `tblInd` (нет корректной позиции вставки по CT_TblPrBase), `tblW pct`, нецелые gridCol. Кроме `rewrite` (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.
9. `NumberingSuffixNormalizer` — `w:suff w:val="space"` → дописанный обычный пробел в конце следующего `w:lvlText` того же уровня (порядок CT_Lvl suff→lvlText, wml.xsd; ST_LevelSuffix Part 1 §17.9.28): docx4j разделитель не эмитит вовсе (дамп n4.fo); уже пробельный lvlText не дублируется; suff=tab — отдельный Class C-остаток (нужна per-item ширина), nothing совпадает с docx4j. Регрессия — WordPdfConverterTest#suffSpace_labelGetsSpace.
10. `HiddenTextNormalizer` — вырезание скрытых ранов (Part 1 §17.3.2.41): truthy `w:vanish` в собственном `w:rPr` ранa (обе OnOff-формы; вал опущен — default true; явный `false/0/off` в ране **перекрывает** vanish-стиль) **или** `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, #hiddenText_directFalseOverridesVanishStyle, юниты — HiddenTextNormalizerTest.
11. `RubyNormalizer` — разбор руби-разметки (Part 1 §17.3.3.24–.28): снимается обёртка `w:ruby` (схемно-валидная транзишнл-разметка `w:r`→`w:ruby`→rubyPr/rt/rubyBase иначе достаёт catch-all-шаблону XSLT, и база теряется молча), `w:rubyBase` разворачивается в обычные раны, `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.
12. `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` вместо вычистки — `OleFoundException`. Лечит оба механизма падения 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»).
+2 -2
View File
@@ -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` не кернит; MS-OI29500 §2.1.83 уточняет лишь диапазон `w:val`) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `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) — известные нечинимые ограничения 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 чинит правило 9, 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` не кернит; MS-OI29500 §2.1.83 уточняет лишь диапазон `w:val`) — по умолчанию совпадает с нами, расходится только для документов с явно заданным `w:kern`. Починено веткой layout-class-c: левый padding ячейки (`LayoutPostRenderer`, шаг 4.25), `w:tblInd` при `w:jc`≠left (правило 8), `w:suff="space"` (правило 9).
- Аудит .docx-путей по ECMA-376 (2026-11) — запинено синтетикой (без фикстур): сноски/концевые сноски с номерами (§17.11), внешние гиперссылки с `/URI`-аннотацией (§17.12.23), `PAGEREF` (complex и вложенный в результат `TOC`) и `DATE` подменяют кэш живым значением, `titlePg` → first/default колонтитуки (§17.10.6), `vMerge` restart/continue (§17.4.70), block-level `w:sdt` (§17.5.2), `wps:txbx`-текст (§17.3.3.23), OMML-формулы: на хосте с fontconfig рисуются вектором jeuclid-fop (§22.1 — текст из PDF не извлекается, пинь пикселями), без fontconfig — деградация в текст `m:t` (правило 11; контейнерный рантайм без fontconfig), фон `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.10.6), `vMerge` restart/continue (§17.4.70), block-level `w:sdt` (§17.5.2), `wps:txbx`-текст (§17.3.3.23; формула внутри текстового бокса до растера не доходит — обход drawing-нагрузку не спускается и уходит в docx4j-фолбэк `mathText`, конкатенация `m:t`; регрессия — WordPdfConverterTest#drawingTextBoxMath_convertsViaDocx4jTextFallback), OMML-формулы (§22.1) рисует собственный растер `MathModel`/`MathRenderer` — PNG 300 dpi, только бандл-шрифты jar, без AWT/JEuclid (текст из PDF не извлекается, пинь пикселями); неподдерживаемая конструкция или превышение бюджета — текстовая деградация (конкатенация `m:t`, `MathFallbackNormalizer`, правило 6) + warn, inline-формула выравнивается по базовой линии текста (мат-ось Word — принятая деградация), `m:oMathPara` — отдельный центрированный абзац (left/right по `m:jc`, indentLeft→left); фон `w:highlight`/`w:shd` рисуется (§17.3.2.16/.29). Скрытый текст `w:vanish` не печатается (правило 10); текст руби-базы и `w:moveFrom`/`w:moveTo`/`w:bdo`/`w:dir` не теряется (правило 11 + AUDIT-FIX-2). Остаток (не чиним): `w:framePr` игнорируется — текст печатается в общем потоке, геометрия фрейма теряется (ни XSLT, ни `createBlockForPPr` не читают); `REF`/`SEQ`/литеральные записи `TOC` печатают устаревший кэш из docx (движка пересчёта нет; инстринции полей не печатаются); надстрочница руби не выводится (правило 11 печатает только базу — ruby-разметки в FOP нет); `w:ptab` без `@w:alignment`, `bar`, `list` теряются catch-all'ом; `w:bdo`/`w:dir` печатаются LTR (bidi вне контура).
+4 -4
View File
@@ -5,10 +5,10 @@
| Путь | Назначение |
|---|---|
| `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` (наследник — «вход некорректен»), `ChartsFoundException`/`SmartArtFoundException`/`OleFoundException` (по error-флагам), `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/fonts/` | `BundledFonts` (реестр/выгрузка TTF), `BundledFontAliases` (алиасы, `DISPLAY_NAMES`, `bundledFamily` — без наследования, статика безопасна до гейта), `BundledFontMapper` (экземпляр-маппер docx4j), `GlyphFont` (глиф-движок fontbox) |
| `…/wordpdf/internal/` | 12 нормализаторов + `DocxRewritePipeline` (один zip-проход правил 1–11, 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)`, бросает `OleFoundException` |
| `…/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/internal/chart/` |21 классов Java2D-рендера диаграмм/SmartArt/OMML-формул в PNG (`MathModel`/`MathRenderer`/`MathUnsupportedException` — формулы); public: `DrawingPreRenderer.run` и `ChartImageHandler` — второй инстанцируется из `WordPdfConverter`|
| `wordpdf-core/src/main/resources/fonts/` | 30 TTF + 3 лицензии — бинарные фикстуры, часть jar |
| `wordpdf-core/src/main/resources/xslt/` | `docx2fo.xslt` — вендорный XSL-FO-стилист (копия docx4j-export-fo + AUDIT-FIX-патчи), часть jar |
| `wordpdf-core/src/test/resources/samples/` | 25 закоммиченных фикстур: 13 `.docx` + 12 `.doc` (11 эталонов заказчика из `develop/doc/` с теми же базовыми именами + `doc-formats.doc`); `.docx` проходят `docs/standards/docx/validate-fixtures.py`, `.doc` — бинарные, XSD к ним неприменим |
@@ -30,7 +30,7 @@
- `wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java` — точка входа библиотеки + static-блок `gsubFeatures` + `normalizers(options)` (порядок цепочки).
- `wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfValidator.java` — валидация входа и lightweight-подсчёт страниц (StAX, без docx4j).
- Дефолтов лимитов в ядре нет (`WordPdfSettings` упразднён): лимиты входа всегда приходят с вызовом через `ConvertOptions`, производные пороги считает `WordPdfValidator.max*` (см. таблицу выше).
- `wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/DrawingPreRenderer.java` — замена диаграмм/SmartArt на PNG; владеет `MAX_EXTENT_EMU` и деградацией при падении рендера.
- `wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/DrawingPreRenderer.java` — замена диаграмм/SmartArt/OMML-формул на PNG; владеет `MAX_EXTENT_EMU` и деградацией при падении рендера (формула — текст вместо удаления).
- `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).
@@ -121,4 +121,4 @@ PMD: `failurePriority` в плагине не задан — на практик
## Шрифты (детали)
`DISPLAY_NAMES` — обратный маппинг lowercase→отображаемое имя для `documentFontName` (пишет `GlyphCoverageNormalizer` в `w:rFonts`). `BundledFontMapper.bundledFamily` — public-хук «имя шрифта из docx → бандл-семейство или fallback» (пользуется chart-движком). `GlyphFont` — глиф-движок на fontbox (метрики + растеризация глифов для chart-движка и покрытия глифов); читает TTF **напрямую из classpath** `fonts/<file>` (не из temp-каталога `BundledFonts`), кэш по `family/variant`, `of()` возвращает `null` для неизвестного семейства; `java.awt.Font` из рантайм-пути убран, AWT остаётся только как геометрия Graphics2D.
`DISPLAY_NAMES` — обратный маппинг lowercase→отображаемое имя для `documentFontName` (пишет `GlyphCoverageNormalizer` в `w:rFonts`). `BundledFontAliases.bundledFamily` — public-хук «имя шрифта из docx → бандл-семейство или fallback» (пользуется chart/math-движком и покрытием); вынесен из `BundledFontMapper`, чтобы обращение к статике не тянуло `BestMatchingMapper.<clinit>` (скан classpath вне гейта свойств `docx4j.fonts.discover*`, которые выставляет `WordPdfConverter.<clinit>`). `GlyphFont` — глиф-движок на fontbox (метрики + растеризация глифов для chart-движка и покрытия глифов); читает TTF **напрямую из classpath** `fonts/<file>` (не из temp-каталога `BundledFonts`), кэш по `family/variant`, `of()` возвращает `null` для неизвестного семейства; `java.awt.Font` из рантайм-пути убран, AWT остаётся только как геометрия Graphics2D.
+2 -2
View File
@@ -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). Обновлять при изменении набора.
- 63 тестовых классов / 1004 теста: core 57/956 (`internal/doc/` 17/256, `internal/chart/` 18/301, `WordPdfConverterTest` 87), app 6/48 (ConvertController 26, ApiKeyFilter 8, ConversionService 5, ApiExceptionHandler 5, ConvertLimits 3, ConversionTimeout 1). Обновлять при изменении набора.
### Пиксели, метрики шрифтов, стенд без fontconfig
@@ -31,5 +31,5 @@
- `lineRuleAuto_wordSingleLinePitch` — пинит метрический шаг «single» (13.4277pt) от псевдофиксов раскладки; `carlitoAutoBlock_untouched` — блок без явного `w:line` не трогается.
- `vendoredXsltTracksJarCopy` — дрейф-гейт: вне AUDIT-FIX-регионов вендорный `docx2fo.xslt` обязан быть побайтно равен стилисту из jar'а docx4j-export-fo (при апгрейде docx4j — перевендорить и перенести патчи).
- Крафт POIFS (закоммиченных фикстур нет, крафт продублирован в `WordPdfConverterTest`): `ListsTest`+`DocToDocxFormattingTest#list*`↔`docLists_numberingAndBulletsRendered` (синтетический .doc со списками → PDF: `1.` `2.` `a)` `b)` `•`, ни одного `#`; фикстур со списками нет — крафт POIFS продублирован в `WordPdfConverterTest`), `PrcDataTest`+`DocToDocxFormattingTest#hugePapxRowMark_closesRowWithGridFromPrcData` (TTP-абзац с grpprl в PrcData Data-потока → `w:tbl`/`w:tr`/сетка из цепочки; фикстуры нет — `docTest.doc` заказчика не коммитим, крафт POIFS продублирован), `SectionsTest`+`HeadersTest`+`DocToDocxFormattingTest#twoSections*/sectionBreakInTable*`↔`docMultiSection_perSectionHeaders` (двухсекционный .doc → PDF: стр. 1 — ШАПКА-1+ПОДВАЛ-1, стр. 2 — ШАПКА-2 + унаследованный ПОДВАЛ-1, ни одной `#`; крафт POIFS продублирован в `WordPdfConverterTest`), `ChpxIndexTest#zeroOffset_defaultPropsBoundaryKept`+`DocToDocxFormattingTest#runFlags_*/keepNextKeepLines_*/sectLandscapePgNumCols_*/sectUnevenCols_*/cellVertAlign_*/drawnObject_*`+`SectionsTest#orientationPgNumColumns_applied/unevenColumns_perIndexWidths/restartWithoutStart_clampsToOne`+`TablesTest#vertAlign_*`↔`WordPdfConverterTest#docClassD_landscapeHiddenDelCaps/#docClassD_pageNumberRestartLowerRoman/#docClassD_twoColumnsBreak/#docClassD_drawnObjectBecomesImage` (закрытие пробелов класса D: vanish-фильтр/правки/caps/position/keep, landscape+pgNumType, колонки+column break, vAlign, 0x08→inline-картинка; фикстур нет — крафт POIFS продублирован в обоих тестовых классах).
- Синтетика через общий хелпер `docx(docXmlns, body, sect, rels, overrides, parts)`: AUDIT-FIX-2↔`movedRevision_textPrinted`/`bdoDir_textPrinted` (фикстур нет — синтетический docx через общий хелпер `docx(docXmlns, body, sect, rels, overrides, parts)`); пиннинг аудита .docx↔`footnote_rendersAtPageBottom`, `endnote_rendersAtDocumentEnd`, `docxHyperlink_uriAnnotation`, `pageRefField_liveNotCached` (кэш 9001/7777 заменён живым номером), `dateField_notStaleCache` (кэш 01.02.2003 заменён текущей датой), `titlePg_firstPageHeader`, `vMergeCell_spansRows`, `sdtContent_rendered`, `drawingTextBox_textPrinted`, `ommlMath_drawnAsVectors` (пиксели: +150 тёмных px@150dpi сверх текста), `highlightAndShading_backgroundDrawn` (жёлтые px >0 против baseline 0), аудит [MS-DOC] моста 2026-11: `GrpprlTest#tInsertOperand_skippedBySpra`/`tInsertOperand_truncated_aborts` (sprmTInsert — 4 байта, хвост TAP не рассинхронизирован), `TablesTest#cellPadding_*` + `DocToDocxFormattingTest#cellMargins_becomeTcMar` ↔ `WordPdfConverterTest#tableTcMar_textInsetLikeWord` (CSSA→w:tcMar, пайплайн красит поля ячейки как tblCellMar — текст на margin+padding), `StylesTest#characterStyle_stk3_chainViaCharChain`/`charChain_nonCharacterStk_empty` + `DocToDocxFormattingTest#charStyle_viaIstd_mergesUnderDirect` (sprmCIstd: символьная chpx-цепочка между стилевой и прямыми, direct wins), `DocToDocxFormattingTest#runHighlightAndShading_inRPr`/`runShadingPattern_degradesToBackFill`/`paraShd_inPPrBeforeJc` ↔ `docHighlightAndShading_yellowPixels` (Ico→ST_HighlightColor; w:shd в форме FOP val="clear"+fill; паттерн→cvBack), `SectionsTest#titlePage_flagFromSepx` + `DocToDocxFormattingTest#titlePage_emittedAfterCols` ↔ `docTitlePage_firstHeaderOnlyFirstPage` (sprmSFTitlePage + first-слоты Plcfhdd → headerReference type="first", первая страница — только first-шапка)..
- Синтетика через общий хелпер `docx(docXmlns, body, sect, rels, overrides, parts)`: AUDIT-FIX-2↔`movedRevision_textPrinted`/`bdoDir_textPrinted` (фикстур нет — синтетический docx через общий хелпер `docx(docXmlns, body, sect, rels, overrides, parts)`); пиннинг аудита .docx↔`footnote_rendersAtPageBottom`, `endnote_rendersAtDocumentEnd`, `docxHyperlink_uriAnnotation`, `pageRefField_liveNotCached` (кэш 9001/7777 заменён живым номером), `dateField_notStaleCache` (кэш 01.02.2003 заменён текущей датой), `titlePg_firstPageHeader`, `vMergeCell_spansRows`, `sdtContent_rendered`, `drawingTextBox_textPrinted`, `ommlMath_renderedAsPng` (пиксели: +150 тёмных px@150dpi сверх текста, текст формулы не извлекается), `ommlMathUnsupported_flattenedToText`, `highlightAndShading_backgroundDrawn` (жёлтые px >0 против baseline 0), аудит [MS-DOC] моста 2026-11: `GrpprlTest#tInsertOperand_skippedBySpra`/`tInsertOperand_truncated_aborts` (sprmTInsert — 4 байта, хвост TAP не рассинхронизирован), `TablesTest#cellPadding_*` + `DocToDocxFormattingTest#cellMargins_becomeTcMar` ↔ `WordPdfConverterTest#tableTcMar_textInsetLikeWord` (CSSA→w:tcMar, пайплайн красит поля ячейки как tblCellMar — текст на margin+padding), `StylesTest#characterStyle_stk3_chainViaCharChain`/`charChain_nonCharacterStk_empty` + `DocToDocxFormattingTest#charStyle_viaIstd_mergesUnderDirect` (sprmCIstd: символьная chpx-цепочка между стилевой и прямыми, direct wins), `DocToDocxFormattingTest#runHighlightAndShading_inRPr`/`runShadingPattern_degradesToBackFill`/`paraShd_inPPrBeforeJc` ↔ `docHighlightAndShading_yellowPixels` (Ico→ST_HighlightColor; w:shd в форме FOP val="clear"+fill; паттерн→cvBack), `SectionsTest#titlePage_flagFromSepx` + `DocToDocxFormattingTest#titlePage_emittedAfterCols` ↔ `docTitlePage_firstHeaderOnlyFirstPage` (sprmSFTitlePage + first-слоты Plcfhdd → headerReference type="first", первая страница — только first-шапка)..
- App-регрессии: `requestLimitParams_areIgnored`, `nonPositiveLimits_failStartup`, `unknownPath_notFound`, `concurrentRequests_bothSucceed`, `corruptNotAZip_rejected`, `plainZipNotDocx_rejected`, `junkInsideValidZip_conversionError` (500 на валидном .docx-контейнере с мусором), `nonDocxFilename_rejected`, `oversizedOverCoreLimit_rejected`, `drawingsAlwaysRendered`, `cyrillicAndPathInFilename_sanitizedResponseName`, `docsOpenWithoutKey`/`forwardedPrefix_healthStaysOpen`/`forwardedPrefix_docsOpenWithoutKey`, `dotSegmentOpenPrefix_rejected`, `errorFlagNotBoolean_rejected`, `methodNotSupportedReturns405`/`badContentTypeReturns415`.
+1 -1
View File
@@ -103,7 +103,7 @@ instk == 1 && /^ *\]/ {
app = ""
for (i = 1; i <= nf; i++) {
c = cls(fr[i])
if (c !~ /^(java|javax|jdk|sun|com\.sun|org\.apache|org\.docx4j|org\.springframework|org\.springdoc|org\.w3c|org\.xml|net\.sf|org\.jeuclid|org\.slf4j|ch\.qos)/) {
if (c !~ /^(java|javax|jdk|sun|com\.sun|org\.apache|org\.docx4j|org\.springframework|org\.springdoc|org\.w3c|org\.xml|net\.sf|org\.slf4j|ch\.qos)/) {
app = fr[i]
break
}
+18
View File
@@ -29,6 +29,24 @@
<dependency>
<groupId>org.docx4j</groupId>
<artifactId>docx4j-export-fo</artifactId>
<!-- JEuclid (MathML-рендер FOP) исключён: формулы OMML больше не
доходят до FO — DrawingPreRenderer заменяет каждую math-узел
собственным растером (MathModel/MathRenderer) или текстом, а
MathFallbackNormalizer (правило 6) срезает unsupported до
загрузки. Jeuclid тянул AWT-менеджер шрифтов (fontconfig —
падение на без-fontconfig хостах) и системные шрифты в вывод;
инвариант «шрифты только бандла» пинит
FontsBundledOnlyInvariantTest. -->
<exclusions>
<exclusion>
<groupId>de.rototor.jeuclid</groupId>
<artifactId>jeuclid-fop</artifactId>
</exclusion>
<exclusion>
<groupId>de.rototor.jeuclid</groupId>
<artifactId>jeuclid-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- Простой логгер в консоль (slf4j). Обязателен: без него docx4j
пишет предупреждение прямо в выходной PDF. -->
@@ -0,0 +1,106 @@
package ru.pjandro.wordpdf.fonts;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
/**
* Таблица алиасов имён шрифтов и обратное имя для {@code w:rFonts}.
*
* Почему это вынесено из {@link BundledFontMapper}: обращение к статикам
* маппера (чарты, GlyphCoverageNormalizer, MathModel) по правилам JVM
* инициализирует и суперкласс {@code BestMatchingMapper}, чей
* {@code <clinit>} сканирует classpath-джары в реестр {@code PhysicalFonts};
* системный скан гейтится свойствами {@code docx4j.fonts.discover*},
* которые выставляет {@code WordPdfConverter.<clinit>}, — и при раннем
* обращении к мапперу скан мог пройти без гейта. У этого класса нет
* наследования, его статика безопасна при любом порядке загрузки.
* Экземпляр {@code BundledFontMapper} создаётся только в конвейере
* {@code WordPdfConverter} — всегда после его {@code <clinit>}.
*/
public final class BundledFontAliases {
/**
* Алиасы: имя шрифта из документа (lowercase) -> бандл-семейство (lowercase).
* Croscore (Arimo/Tinos/Cousine) и crosextra (Carlito/Caladea) шрифты
* метрически совместимы с соответствующими MS-шрифтами и содержат
* кириллицу.
*/
static final Map<String, String> ALIASES;
static {
Map<String, String> m = new HashMap<>();
// Частые MS-шрифты -> open-source аналоги
m.put("calibri", "carlito");
m.put("calibri light", "carlito");
m.put("cambria", "caladea");
m.put("arial", "arimo");
m.put("times new roman", "tinos");
m.put("courier new", "cousine");
// Бандл-шрифты сами по себе (на случай, если документ прямо
// указывает одно из них)
m.put("carlito", "carlito");
m.put("caladea", "caladea");
m.put("arimo", "arimo");
m.put("tinos", "tinos");
m.put("cousine", "cousine");
m.put("dejavu sans", "dejavu sans");
m.put("dejavu serif", "dejavu serif");
// Покрывающие шрифты (в документе обычно не встречаются, но если
// встречаться — маппятся на себя, а не в DejaVu-фолбэк)
m.put("noto naskh arabic", "noto naskh arabic");
m.put("noto sans armenian", "noto sans armenian");
ALIASES = Map.copyOf(m);
}
/** Финальный fallback: шрифт с гарантированной кириллицей. */
private static final String FALLBACK_FAMILY = BundledFonts.FALLBACK_FAMILY;
/**
* Имя семейства для записи в {@code w:rFonts} (ключ — lowercase-семейство).
* Нужно {@code GlyphCoverageNormalizer}: он пишет в разрезанный ран
* человекочитаемое имя, а {@code BundledFontMapper.populateFontMappings}
* маппит его обратно на TTF.
*/
private static final Map<String, String> DISPLAY_NAMES = Map.of(
"dejavu sans", "DejaVu Sans",
"dejavu serif", "DejaVu Serif",
"noto naskh arabic", "Noto Naskh Arabic",
"noto sans armenian", "Noto Sans Armenian");
/**
* Имя, которое docx4j {@code RunFontSelector} запрашивает у маппера для
* символов диапазона U+2000–U+2EFF (em-dash «—», кавычки «„», многоточие
* «…»), если шрифт ранa не содержит глифа. Это виртуальное имя (в
* документе его нет), поэтому маппим его на {@link #FALLBACK_FAMILY}:
* без записи символ остаётся без font-family в FO и рендерится системным
* неembedded-шрифтом (Helvetica).
*/
static final String SYMBOL_FONT = "Segoe UI Symbol";
private BundledFontAliases() {
}
/**
* Бандл-семейство для имени шрифта из документа (таблица алиасов)
* или финальный fallback. Используется пре-рендером диаграмм и формул
* (internal/chart), которому нужен тот же шрифт, что и у текста PDF.
*/
public static String bundledFamily(String docFontName) {
String family = ALIASES.get(docFontName.toLowerCase(Locale.ROOT));
return family != null && BundledFonts.regular(family) != null
? family
: FALLBACK_FAMILY;
}
/**
* Имя шрифта, которое можно поставить в {@code w:rFonts}, чтобы получить
* бандл-семейство {@code family}: {@code GlyphCoverageNormalizer} пишет
* его в разрезанные раны. Обратная к {@link #bundledFamily} операция —
* имена берутся из таблицы алиасов, поэтому маппинг гарантированно
* возвращается к тому же семейству.
*/
public static String documentFontName(String family) {
return DISPLAY_NAMES.getOrDefault(family, family);
}
}
@@ -4,10 +4,8 @@ import org.docx4j.fonts.BestMatchingMapper;
import org.docx4j.fonts.PhysicalFont;
import org.docx4j.wml.Fonts;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
/**
@@ -15,7 +13,8 @@ import java.util.Set;
*
* Стратегия (см. {@link #populateFontMappings}):
* 1. Частые MS-шрифты заменяются метрически совместимыми open-source
* аналогами (таблица алиасов) — они есть в jar и содержат кириллицу.
* аналогами (таблица алиасов {@link BundledFontAliases}) — они есть в
* jar и содержат кириллицу.
* 2. Нераспознанные шрифты передаются родительскому
* {@link BestMatchingMapper} (совпадение по Panose-кодам среди
* доступных шрифтов).
@@ -31,91 +30,15 @@ import java.util.Set;
* запускает обнаружение системных шрифтов, которые могут занять те же
* имена в реестре docx4j. Поэтому {@code BundledFonts.init()} нужно
* вызывать ПОСЛЕ создания маппера, чтобы бандл-шрифты оказались в
* реестре поверх системных.
* реестре поверх системных. Таблица алиасов вынесена в
* {@link BundledFontAliases}, чтобы обращение к ней не инициировало этот
* класс до гейта {@code WordPdfConverter.<clinit>}.
*/
public class BundledFontMapper extends BestMatchingMapper {
/**
* Алиасы: имя шрифта из документа (lowercase) -> бандл-семейство (lowercase).
* Croscore (Arimo/Tinos/Cousine) и crosextra (Carlito/Caladea) шрифты
* метрически совместимы с соответствующими MS-шрифтами и содержат
* кириллицу.
*/
private static final Map<String, String> ALIASES;
/** Финальный fallback: шрифт с гарантированной кириллицей. */
private static final String FALLBACK_FAMILY = BundledFonts.FALLBACK_FAMILY;
/**
* Имя семейства для записи в {@code w:rFonts} (ключ — lowercase-семейство).
* Нужно {@code GlyphCoverageNormalizer}: он пишет в разрезанный ран
* человекочитаемое имя, а {@link #populateFontMappings} маппит его
* обратно на TTF.
*/
private static final Map<String, String> DISPLAY_NAMES = Map.of(
"dejavu sans", "DejaVu Sans",
"dejavu serif", "DejaVu Serif",
"noto naskh arabic", "Noto Naskh Arabic",
"noto sans armenian", "Noto Sans Armenian");
/**
* Имя, которое docx4j {@code RunFontSelector} запрашивает у маппера для
* символов диапазона U+2000–U+2EFF (em-dash «—», кавычки «„», многоточие
* «…»), если шрифт ранa не содержит глифа. Это виртуальное имя (в
* документе его нет), поэтому маппим его на {@link #FALLBACK_FAMILY}:
* без записи символ остаётся без font-family в FO и рендерится системным
* неembedded-шрифтом (Helvetica).
*/
static final String SYMBOL_FONT = "Segoe UI Symbol";
static {
Map<String, String> m = new HashMap<>();
// Частые MS-шрифты -> open-source аналоги
m.put("calibri", "carlito");
m.put("calibri light", "carlito");
m.put("cambria", "caladea");
m.put("arial", "arimo");
m.put("times new roman", "tinos");
m.put("courier new", "cousine");
// Бандл-шрифты сами по себе (на случай, если документ прямо
// указывает одно из них)
m.put("carlito", "carlito");
m.put("caladea", "caladea");
m.put("arimo", "arimo");
m.put("tinos", "tinos");
m.put("cousine", "cousine");
m.put("dejavu sans", "dejavu sans");
m.put("dejavu serif", "dejavu serif");
// Покрывающие шрифты (в документе обычно не встречаются, но если
// встречаться — маппятся на себя, а не в DejaVu-фолбэк)
m.put("noto naskh arabic", "noto naskh arabic");
m.put("noto sans armenian", "noto sans armenian");
ALIASES = Map.copyOf(m);
}
/**
* Бандл-семейство для имени шрифта из документа (таблица алиасов)
* или финальный fallback. Используется пре-рендером диаграмм
* (internal/chart), которому нужен тот же шрифт, что и у текста PDF.
*/
public static String bundledFamily(String docFontName) {
String family = ALIASES.get(docFontName.toLowerCase(Locale.ROOT));
return family != null && BundledFonts.regular(family) != null
? family
: FALLBACK_FAMILY;
}
/**
* Имя шрифта, которое можно поставить в {@code w:rFonts}, чтобы получить
* бандл-семейство {@code family}: {@code GlyphCoverageNormalizer} пишет
* его в разрезанные раны. Обратная к {@link #bundledFamily} операция —
* имена берутся из таблицы алиасов, поэтому маппинг гарантированно
* возвращается к тому же семейству.
*/
public static String documentFontName(String family) {
return DISPLAY_NAMES.getOrDefault(family, family);
}
/**
* Вызывается docx4j при {@code package.setFontMapper(...)}: для каждого
* имени шрифта, использованного в документе, нужно определить, каким
@@ -126,21 +49,21 @@ public class BundledFontMapper extends BestMatchingMapper {
*/
@Override
public void populateFontMappings(Set<String> documentFontNames, Fonts wmlFonts) throws Exception {
// Виртуальное имя для символов U+2000–U+2EFF (см. SYMBOL_FONT):
// Виртуальное имя для символов U+2000–U+2EFF (см. BundledFontAliases.SYMBOL_FONT):
// маппим сразу, чтобы оно не попало в remaining и родительский
// BestMatchingMapper не пытался искать его в fontTable (и не логировал
// "Font Segoe UI Symbol not found in font table!").
if (BundledFonts.regular(FALLBACK_FAMILY) != null) {
mapFamily(SYMBOL_FONT, FALLBACK_FAMILY);
mapFamily(BundledFontAliases.SYMBOL_FONT, FALLBACK_FAMILY);
}
Set<String> remaining = new LinkedHashSet<>();
for (String docFontName : documentFontNames) {
if (SYMBOL_FONT.equalsIgnoreCase(docFontName)) {
if (BundledFontAliases.SYMBOL_FONT.equalsIgnoreCase(docFontName)) {
// уже маппировано выше
continue;
}
String family = ALIASES.get(docFontName.toLowerCase(Locale.ROOT));
String family = BundledFontAliases.ALIASES.get(docFontName.toLowerCase(Locale.ROOT));
if (family == null || BundledFonts.regular(family) == null) {
// Нет алиаса (или init() не вызван) — доверимся родителю
remaining.add(docFontName);
@@ -16,9 +16,11 @@ import org.apache.commons.compress.utils.SeekableInMemoryByteChannel;
* Единый zip-проход переписывания XML-частей (.docx) вместо отдельных
* проходов нормализаторов: к каждой записи {@code word/*.xml} применяются
* все одиннадцать рерайтов в фиксированном порядке
* Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby→MathFallback.
* Strict→OnOff→Symbol→Field→Invisible→MathFallback→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby.
* Порядок значим: Strict первым — дальше части в transitional-виде
* (TableIndent читает transitional-атрибуты {@code w:}); GlyphCoverage
* (TableIndent читает transitional-атрибуты {@code w:}); MathFallback
* шестым — flatten unsupported-формул даёт обычный текст ранов, который
* следующий GlyphCoverage покрывает кириллицей бандла; GlyphCoverage
* режет раны по финальному тексту рана (после Symbol/Invisible); Hidden
* девятым — вырезает уже финальные раны (после Symbol/GLYPH-разбиений),
* а его OnOff-форма vanish читается после правила 2. Каждый
@@ -114,6 +116,10 @@ public final class DocxRewritePipeline {
if (next != null) {
cur = next;
}
next = MathFallbackNormalizer.rewrite(cur);
if (next != null) {
cur = next;
}
next = GlyphCoverageNormalizer.rewrite(cur);
if (next != null) {
cur = next;
@@ -134,10 +140,6 @@ public final class DocxRewritePipeline {
if (next != null) {
cur = next;
}
next = MathFallbackNormalizer.rewrite(cur);
if (next != null) {
cur = next;
}
if (!cur.equals(xml)) {
changed = true;
rewritten = cur.getBytes(StandardCharsets.UTF_8);
@@ -1,6 +1,6 @@
package ru.pjandro.wordpdf.internal;
import ru.pjandro.wordpdf.fonts.BundledFontMapper;
import ru.pjandro.wordpdf.fonts.BundledFontAliases;
import ru.pjandro.wordpdf.fonts.BundledFonts;
import ru.pjandro.wordpdf.fonts.GlyphFont;
@@ -38,7 +38,7 @@ import java.util.concurrent.ConcurrentHashMap;
* Делаем то, что должен был сделать рендер: ран, в тексте которого есть
* знаки без глифа, разрезается на части, и каждой части явно назначается
* бандл-семейство, где глиф есть ({@link #targetFamily}). Имя пишется в
* {@code w:rFonts}, дальше {@link BundledFontMapper} маппит его на TTF,
* {@code w:rFonts}, дальше {@code BundledFontMapper} маппит его на TTF,
* а {@link FopFallbackFonts} декларирует его в FOP-конфиге.
*
* Правила, ограничивающие вмешательство:
@@ -406,7 +406,7 @@ final class GlyphCoverageNormalizer {
if (!m.find()) {
return null;
}
return BundledFontMapper.bundledFamily(m.group(2));
return BundledFontAliases.bundledFamily(m.group(2));
}
/**
@@ -414,7 +414,7 @@ final class GlyphCoverageNormalizer {
* {@code w:rFonts}, а если их нет — вставляет элемент первым ребёнком.
*/
private static String forceFont(String rPr, String family) {
String name = BundledFontMapper.documentFontName(family);
String name = BundledFontAliases.documentFontName(family);
String fonts = "<w:rFonts w:ascii=\"" + name + "\" w:hAnsi=\"" + name + "\"/>";
if (rPr.isEmpty()) {
return "<w:rPr>" + fonts + "</w:rPr>";
@@ -1,90 +1,265 @@
package ru.pjandro.wordpdf.internal;
import ru.pjandro.wordpdf.internal.chart.MathModel;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Деградация OMML-формул (§22.1) в текст на хостах без fontconfig.
* Байтовый скан формул OMML (§22.1): блок {@code m:oMathPara}/{@code m:oMath},
* содержащий math-элемент вне {@link MathModel#SUPPORTED}, заменяется раном с
* конкатенацией текста {@code m:t} (как штатный фолбэк docx4j
* {@code XsltFOFunctions.mathText}) — формула видна текстом, а не теряется.
*
* <p>docx4j превращает {@code m:oMath}/{@code m:oMathPara} в
* {@code fo:instream-foreign-object} с MathML, а FOP рисует его через
* jeuclid-fop. JEuclid при первой формуле обращается к AWT-менеджеру шрифтов,
* которому на Linux нужен fontconfig; без него конвертация падает
* {@code InternalError: Fontconfig head is null} (репро: arm64 без /etc/fonts;
* контейнерный рантайм проекта тоже без fontconfig — Containerfile).
* Поэтому до загрузки docx4j формулы заменяются обычными ранами с текстом
* {@code m:t} (конкатенация, как в штатном фолбэке docx4j
* {@code XsltFOFunctions.mathText}) — формула видна, приложение не падает.
* <p>Зачем скан до загрузки docx4j: собственный растер формул
* ({@code MathModel}/{@code MathRenderer} в {@code DrawingPreRenderer})
* уронил бы unsupported-конструкцию в {@code MathUnsupportedException} и
* деградировал тем же текстом — но скан даёт детерминизм «формула целиком
* текстом» для байтового уровня пайплайна и не зависит от JAXB-биндинга.
* Рантайм-деградация остаётся второй сетью (биндинг может не смонтировать
* неизвестный элемент, который скан увидел).
*
* <p>На хосте с fontconfig рерайт не срабатывает (возвращается {@code null},
* пайплайн отдаёт тот же массив). Позиция в цепочке — после Ruby (правило 10),
* одиннадцатый рерайт:
* {@code m:oMathPara} содержит {@code m:oMath}, поэтому блок para заменяется
* первым, иначе остался бы несбалансированный каркас. Префикс {@code m:}
* предполагается (Word и strict-OOXML используют его; StrictOoxmlNormalizer
* его не переименовывает).
* <p>Скан namespace-aware: префиксы, привязанные к math-URI на корневом
* элементе (+ переопределения {@code xmlns} внутри блока), — unsupported
* проверяется только для тегов в math-namespace; префиксы чужих namespace'ов
* ( {@code w:rPr} внутри рана формулы) игнорируются. Непривязанный/отсутствующий
* map объявлений при наличии {@code :oMath} — консервативная обработка «как
* math» (риск потерять контент при недобитом биндинге сильнее избыточной
* деградации).
*
* <p>Регрессия — WordPdfConverterTest#ommlMath_drawnAsVectors.
* <p>Позиция в цепочке — шестое правило, перед GlyphCoverage: flatten даёт
* обычный текст ранов, который следующий рерайт покрывает кириллицей бандла
* (раньше формулы с {@code &#x043C;} теряли глифы именно из-за порядка —
* GlyphCoverage не видел текст внутри OMML). Блок para заменяется первым:
* {@code m:oMathPara} содержит {@code m:oMath}, иначе остался бы
* несбалансированный каркас.
*/
final class MathFallbackNormalizer {
/** {@code m:oMathPara} ... {@code </m:oMathPara>} — блок формулы. */
private static final Pattern MATH_PARA = Pattern.compile(
"<m:oMathPara(?:\\s[^>]*)?>.*?</m:oMathPara>", Pattern.DOTALL);
/** Закрывающий символ открывающего тега (скан конца корня формулы). */
private static final char TAG_END = '>';
/** Самозакрывающийся {@code <m:oMathPara/>}. */
private static final Pattern MATH_PARA_SELF = Pattern.compile(
"<m:oMathPara(?:\\s[^>]*)?/>");
/** Math-namespace OMML (§22.1). */
private static final String MATH_NS =
"http://schemas.openxmlformats.org/officeDocument/2006/math";
/** {@code m:oMath} ... {@code </m:oMath>} — встроенная формула. */
private static final Pattern MATH_INLINE = Pattern.compile(
"<m:oMath(?:\\s[^>]*)?>.*?</m:oMath>", Pattern.DOTALL);
/** Объявление {@code xmlns:prefix="uri"} (значение без кавычек). */
private static final Pattern XMLNS = Pattern.compile(
"xmlns:([A-Za-z_][\\w.-]*)=\"([^\"]*)\"");
/** Самозакрывающийся {@code <m:oMath/>}. */
private static final Pattern MATH_INLINE_SELF = Pattern.compile(
"<m:oMath(?:\\s[^>]*)?/>");
/** Начало блока формулы; префикс обязателен (без него {@code :oMath} нет). */
private static final Pattern MATH_BLOCK = Pattern.compile(
"<([A-Za-z_][\\w.-]*):oMath(Para)?(?=[\\s/>])");
/** Текстовый узел OMML; содержимое — уже экранированный XML-текст. */
/** Элементный тег с префиксом {@code <p:name>} / {@code </p:name>}. */
private static final Pattern PREFIXED_TAG = Pattern.compile(
"</?([A-Za-z_][\\w.-]*):([A-Za-z_][\\w.-]*)");
/** Текстовый узел {@code <p:t>}; содержимое — уже экранированный XML. */
private static final Pattern MATH_TEXT = Pattern.compile(
"<m:t(?:\\s[^>]*)?>(.*?)</m:t>", Pattern.DOTALL);
"<([A-Za-z_][\\w.-]*):t(?:\\s[^>]*)?>(.*?)</\\1:t>", Pattern.DOTALL);
private MathFallbackNormalizer() {
}
/**
* Рерайт одной XML-части: формулы → текст, если AWT-шрифтов нет.
* Формул нет / шрифты есть / ничего не изменилось → {@code null}.
* Рерайт одной XML-части: unsupported-формулы → текст. Формул нет /
* все поддерживаются / ничего не изменилось → {@code null}
* (пайплайн отдаёт тот же массив).
*/
static String rewrite(String xml) {
if (!xml.contains("<m:oMath")) {
if (!xml.contains(":oMath")) {
return null;
}
return MathMlSupport.awtFontsAvailable() ? null : flatten(xml);
Map<String, String> rootNs = rootNamespaces(xml);
StringBuilder out = new StringBuilder();
int pos = 0;
boolean changed = false;
Matcher m = MATH_BLOCK.matcher(xml);
int search = 0;
while (m.find(search)) {
String prefix = m.group(1);
boolean para = m.group(2) != null;
int start = m.start();
int tagEnd = tagEnd(xml, start);
if (tagEnd < 0) {
break; // незакрытый тег — дело валидатора, скан останавливаем
}
Map<String, String> ns = mergedNamespaces(rootNs, xml.substring(start, tagEnd));
if (!isMath(ns, prefix)) {
search = tagEnd;
continue; // чужой namespace — не формула
}
int blockEnd;
int before = tagEnd - 2;
while (before > start && Character.isWhitespace(xml.charAt(before))) {
before--;
}
boolean selfClosing = xml.charAt(before) == '/';
if (selfClosing) {
blockEnd = tagEnd;
} else {
String closing = "</" + prefix + ":oMath" + (para ? "Para" : "") + ">";
int close = xml.indexOf(closing, tagEnd);
if (close < 0) {
break; // битый каркас — валидатор его и отвергнет
}
blockEnd = close + closing.length();
}
String block = xml.substring(start, blockEnd);
if (hasUnsupported(ns, block)) {
out.append(xml, pos, start).append(run(text(ns, block)));
pos = blockEnd;
changed = true;
search = blockEnd;
continue;
}
search = tagEnd;
}
if (!changed) {
return null;
}
return out.append(xml, pos, xml.length()).toString();
}
/**
* Замена всех формул на раны с текстом (без проверки доступности шрифтов).
* Формул нет → {@code null}. Package-private — прямой юнит-тест
* детерминирован на любом хосте.
* Объявления {@code xmlns:} фактического корневого элемента: пролог
* ({@code <?xml ...?>}, комментарии, DOCTYPE) пропускается — иначе
* карта осталась бы пустой на реальном XML-файле части, а пустая карта
* консервативно считает каждый префикс math-тегом и срезает боевые
* формулы (внутри {@code m:r}/{@code m:ctrlPr} Word пишет
* {@code w:rPr}/{@code w:rFonts} — имена вне SUPPORTED).
*/
static String flatten(String xml) {
String out = MATH_PARA.matcher(xml).replaceAll(m -> run(text(m.group())));
out = MATH_PARA_SELF.matcher(out).replaceAll("");
out = MATH_INLINE.matcher(out).replaceAll(m -> run(text(m.group())));
out = MATH_INLINE_SELF.matcher(out).replaceAll("");
return out.equals(xml) ? null : out;
private static Map<String, String> rootNamespaces(String xml) {
Map<String, String> map = new HashMap<>();
int pos = 0;
while (pos < xml.length()) {
int open = xml.indexOf('<', pos);
if (open < 0) {
return map;
}
if (xml.startsWith("<?", open)) {
int end = xml.indexOf("?>", open);
pos = end < 0 ? xml.length() : end + 2;
continue;
}
if (xml.startsWith("<!--", open)) {
int end = xml.indexOf("-->", open);
pos = end < 0 ? xml.length() : end + 3;
continue;
}
if (xml.startsWith("<!", open)) {
int end = xml.indexOf('>', open);
pos = end < 0 ? xml.length() : end + 1;
continue;
}
int end = tagEnd(xml, open);
if (end < 0) {
return map;
}
Matcher m = XMLNS.matcher(xml.substring(open, end));
while (m.find()) {
map.put(m.group(1), m.group(2));
}
return map;
}
return map;
}
/** Текст формулы: конкатенация содержимого всех {@code m:t} (как docx4j mathText). */
private static String text(String block) {
Matcher m = MATH_TEXT.matcher(block);
StringBuilder sb = new StringBuilder();
/** Корневые объявления + переопределения из заголовка блока. */
private static Map<String, String> mergedNamespaces(Map<String, String> root,
String openTag) {
Matcher m = XMLNS.matcher(openTag);
if (!m.find()) {
return root;
}
Map<String, String> map = new HashMap<>(root);
m.reset();
while (m.find()) {
sb.append(m.group(1));
map.put(m.group(1), m.group(2));
}
return map;
}
/**
* Привязан ли префикс к math-namespace: явная привязка — да; привязка к
* другому URI — нет; префикс не объявлен нигде — да (консервативно, см.
* javadoc класса), если только вообще нет ни одного объявления xmlns
* (тогда это не XML с map префиксов, а мусор — тоже «как math»).
*/
private static boolean isMath(Map<String, String> ns, String prefix) {
String bound = ns.get(prefix);
if (MATH_NS.equals(bound)) {
return true;
}
return bound == null;
}
/** Есть ли в блоке тег math-namespace вне {@link MathModel#SUPPORTED}. */
private static boolean hasUnsupported(Map<String, String> ns, String block) {
List<String> mathPrefixes = new ArrayList<>();
for (Map.Entry<String, String> e : ns.entrySet()) {
if (MATH_NS.equals(e.getValue())) {
mathPrefixes.add(e.getKey());
}
}
Matcher m = PREFIXED_TAG.matcher(block);
while (m.find()) {
String prefix = m.group(1);
String name = m.group(2);
boolean mathTag = mathPrefixes.contains(prefix)
|| (mathPrefixes.isEmpty() && !ns.containsKey(prefix));
if (mathTag && !MathModel.SUPPORTED.contains(name)) {
return true;
}
}
return false;
}
/** Текст формулы: конкатенация {@code m:t} math-префиксов (как mathText). */
private static String text(Map<String, String> ns, String block) {
Set<String> mathPrefixes = new HashSet<>();
for (Map.Entry<String, String> e : ns.entrySet()) {
if (MATH_NS.equals(e.getValue())) {
mathPrefixes.add(e.getKey());
}
}
StringBuilder sb = new StringBuilder();
Matcher m = MATH_TEXT.matcher(block);
while (m.find()) {
String prefix = m.group(1);
if (mathPrefixes.contains(prefix)
|| (mathPrefixes.isEmpty() && !ns.containsKey(prefix))) {
sb.append(m.group(2));
}
}
return sb.toString();
}
/** Конец открывающего тега (индекс после {@code >}), кавычки-осведомлённый. */
private static int tagEnd(String xml, int start) {
char quote = 0;
for (int i = start + 1; i < xml.length(); i++) {
char c = xml.charAt(i);
if (quote != 0) {
if (c == quote) {
quote = 0;
}
} else if (c == '"' || c == '\'') {
quote = c;
} else if (c == TAG_END) {
return i + 1;
}
}
return -1;
}
/** Ран с текстом формулы; пустая формула удаляется. */
private static String run(String text) {
return text.isEmpty() ? ""
@@ -1,48 +0,0 @@
package ru.pjandro.wordpdf.internal;
import java.awt.GraphicsEnvironment;
import java.util.logging.Logger;
/**
* Проба доступности AWT-шрифтового менеджера (fontconfig) в текущем JVM.
*
* <p>JEuclid (jeuclid-fop), которым docx4j рисует OMML (§22.1), при первой
* отрисовке формулы вызывает {@code GraphicsEnvironment.getAvailableFontFamilyNames()}.
* На Linux без libfontconfig/конфигурации шрифтов это падает
* {@code InternalError → RuntimeException: Fontconfig head is null}
* (репро: arm64 без /etc/fonts). Проба выполняется лениво и один раз:
* результат определяет, оставлять ли MathML (вектор) или деградировать
* формулу в текст в {@link MathFallbackNormalizer}.
*
* <p>Проба намеренно ловит {@link Throwable}: отказ приходит как
* {@code java.lang.InternalError}, а не RuntimeException.
*
* <p>Регрессия — WordPdfConverterTest#ommlMath_drawnAsVectors.
*/
final class MathMlSupport {
private static final Logger LOGGER = Logger.getLogger(MathMlSupport.class.getName());
private MathMlSupport() {
}
/** Доступен ли AWT-менеджер шрифтов (fontconfig); проба — один раз на JVM. */
static boolean awtFontsAvailable() {
return Holder.AVAILABLE;
}
private static final class Holder {
private static final boolean AVAILABLE = probe();
}
private static boolean probe() {
try {
GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();
return true;
} catch (Throwable t) {
LOGGER.info("AWT-менеджер шрифтов недоступен (нет fontconfig): "
+ "OMML-формулы будут отрисованы текстом: " + t);
return false;
}
}
}
@@ -7,7 +7,7 @@ import org.docx4j.dml.CTTextParagraph;
import org.docx4j.dml.CTTextParagraphProperties;
import org.docx4j.dml.CTTextSpacing;
import org.docx4j.dml.TextFont;
import ru.pjandro.wordpdf.fonts.BundledFontMapper;
import ru.pjandro.wordpdf.fonts.BundledFontAliases;
import ru.pjandro.wordpdf.fonts.BundledFonts;
import ru.pjandro.wordpdf.fonts.GlyphFont;
@@ -23,7 +23,7 @@ import java.util.List;
* (a:defRPr / a:rPr: sz, b, i, solidFill, latin) и разбивка на строки.
*
* Шрифты берутся из того же бандла, что и у текста PDF
* ({@link BundledFontMapper#bundledFamily}), поэтому подпись диаграммы
* ({@link BundledFontAliases#bundledFamily}), поэтому подпись диаграммы
* рисуется тем же Carlito/Tinos, что и абзацы документа.
*/
final class DrawMlText {
@@ -84,7 +84,7 @@ final class DrawMlText {
String fallbackFam, double fallbackSize, Color fallbackColor) {
Style base = new Style(fallbackSize, false, false, fallbackColor,
fallbackFam == null ? BundledFonts.FALLBACK_FAMILY
: BundledFontMapper.bundledFamily(fallbackFam));
: BundledFontAliases.bundledFamily(fallbackFam));
if (txPr == null || txPr.getP().isEmpty()) {
return base;
}
@@ -170,7 +170,7 @@ final class DrawMlText {
case "+mj-lt", "+mj-ea", "+mj-cs" -> colors.majorFontName();
default -> typeface;
};
return BundledFontMapper.bundledFamily(name != null ? name : fallbackFam);
return BundledFontAliases.bundledFamily(name != null ? name : fallbackFam);
}
/**
@@ -22,6 +22,8 @@ import org.docx4j.dml.diagram2008.CTDrawing;
import org.docx4j.dml.picture.Pic;
import org.docx4j.dml.wordprocessingDrawing.Anchor;
import org.docx4j.dml.wordprocessingDrawing.Inline;
import org.docx4j.math.CTOMath;
import org.docx4j.math.CTOMathPara;
import org.docx4j.openpackaging.contenttype.ContentTypes;
import org.docx4j.openpackaging.exceptions.Docx4JException;
import org.docx4j.openpackaging.exceptions.InvalidFormatException;
@@ -32,7 +34,15 @@ import org.docx4j.openpackaging.parts.PartName;
import org.docx4j.openpackaging.parts.ThemePart;
import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
import org.docx4j.openpackaging.parts.relationships.RelationshipsPart;
import org.docx4j.wml.CTSignedHpsMeasure;
import org.docx4j.wml.Drawing;
import org.docx4j.wml.Jc;
import org.docx4j.wml.JcEnumeration;
import org.docx4j.wml.P;
import org.docx4j.wml.PPr;
import org.docx4j.wml.R;
import org.docx4j.wml.RPr;
import org.docx4j.wml.Text;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.pjandro.wordpdf.ChartsFoundException;
@@ -41,10 +51,13 @@ import ru.pjandro.wordpdf.ConversionException;
import ru.pjandro.wordpdf.SmartArtFoundException;
import javax.imageio.ImageIO;
import javax.xml.namespace.QName;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
@@ -62,6 +75,17 @@ import java.util.Set;
* пакета и до создания FOSettings, иначе FOP увидит исходные chart/diagram
* и молча их выбросит (notImplemented в шаблоне).
*
* <p>Третий объект — формулы OMML (§22.1): {@code m:oMathPara}/{@code m:oMath}
* доходят сюда нетронутыми (docx2fo.xslt кладёт их в
* {@code fo:instream-foreign-object} с MathML, который FOP+jeuclid на
* без-fontconfig хостах роняет конвертацию, а на остальных рисует чужими
* системными шрифтами). Каждая формула рендерится своим растером
* ({@link MathModel} → {@link MathRenderer}) и заменяется inline-картинкой
* на месте; unsupported/битая формула деградирует раном с текстом
* {@code m:t}. Байтовый скан {@code MathFallbackNormalizer} (правило 6)
* срезает unsupported-конструкции до загрузки docx4j — этот путь остаётся
* безопасной сетью.
*
* Error-флаги {@link ConvertOptions}: при выключенном render-флаге и
* включённом error-флаге находка объекта — {@link ChartsFoundException} или
* {@link SmartArtFoundException}
@@ -81,6 +105,15 @@ public final class DrawingPreRenderer {
"http://schemas.openxmlformats.org/drawingml/2006/picture";
private static final String DIAGRAM_DRAWING_REL =
"http://schemas.microsoft.com/office/2007/relationships/diagramDrawing";
/** {@code m:} — namespace OMML (§22.1); {@code w:} — wordprocessingML. */
private static final String MATH_URI =
"http://schemas.openxmlformats.org/officeDocument/2006/math";
/** Local name элемента {@code m:oMath} (диспетч JAXBElement по имени тега). */
private static final String LOCAL_OMATH = "oMath";
/** Local name элемента {@code m:oMathPara} (формула отдельным абзацем). */
private static final String LOCAL_OMATH_PARA = "oMathPara";
private static final String WML_URI =
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
/**
* Верхняя граница {@code wp:extent} в EMU: максимальная страница Word —
@@ -147,7 +180,8 @@ public final class DrawingPreRenderer {
if (content.isEmpty()) {
continue;
}
walk(p, content, pkg, colors, idSeq, pngTotal, maxPngBytesTotal, options, visitedContents);
walk(p, content, pkg, colors, idSeq, pngTotal, maxPngBytesTotal, options,
visitedContents, null);
}
}
@@ -175,26 +209,59 @@ public final class DrawingPreRenderer {
private static void walk(Part part, List<?> content, WordprocessingMLPackage pkg,
DrawMlColor colors, int[] idSeq, long[] pngTotal,
long maxPngBytesTotal, ConvertOptions options,
Set<List<?>> visitedContents) {
Set<List<?>> visitedContents, P ownerPara) {
// Посещённые списки — по идентичности (IdentityHashMap): рефлексивный
// getContent (ребёнок возвращает список родителя) не зацикливает обход.
// Сравнение списков через ==/!= запрещено PMD CompareObjectsWithEquals.
if (!visitedContents.add(content)) {
return;
}
for (Object o : content) {
for (int i = 0; i < content.size(); i++) {
Object o = content.get(i);
Object v = o instanceof JAXBElement ? ((JAXBElement<?>) o).getValue() : o;
if (v instanceof Drawing drawing) {
replaceDrawing(part, drawing, pkg, colors, idSeq, pngTotal, maxPngBytesTotal, options);
replaceDrawing(part, drawing, pkg, colors, idSeq, pngTotal,
maxPngBytesTotal, options);
continue;
}
if (o instanceof JAXBElement<?> el && el.getName() != null
&& MATH_URI.equals(el.getName().getNamespaceURI())) {
String local = el.getName().getLocalPart();
if (LOCAL_OMATH.equals(local) && v instanceof CTOMath math) {
i = splice(content, i, mathReplacements(math, false, part, pkg,
idSeq, pngTotal, maxPngBytesTotal));
continue;
}
if (LOCAL_OMATH_PARA.equals(local) && v instanceof CTOMathPara para) {
i = splice(content, i, mathParaReplacements(para, ownerPara, part,
pkg, idSeq, pngTotal, maxPngBytesTotal));
continue;
}
}
P para = v instanceof P p ? p : ownerPara;
List<?> nested = invokeList(v, "getContent");
if (!nested.isEmpty()) {
walk(part, nested, pkg, colors, idSeq, pngTotal, maxPngBytesTotal, options, visitedContents);
walk(part, nested, pkg, colors, idSeq, pngTotal, maxPngBytesTotal,
options, visitedContents, para);
}
}
}
/**
* In-place замена элемента {@code index} живого списка дерева на {@code reps}
* (формула → картинка/текст). Живые списки docx4j — изменяемые
* {@code ArrayList}; немодифицируемый список (нетипичный биндинг) —
* {@link UnsupportedOperationException}, который вызывающий не ловит:
* это ошибка программы, а не враждебный вход (валидатор пропускает только
* OOXML-валидные пакеты). Raw-сигнатура — единственный способ mutate
* {@code List<?>} без {@code @SuppressWarnings}.
*/
private static int splice(List content, int index, List reps) {
content.remove(index);
content.addAll(index, reps);
return index + reps.size() - 1;
}
private static List<?> invokeList(Object target, String getter) {
try {
Method m = target.getClass().getMethod(getter);
@@ -269,6 +336,165 @@ public final class DrawingPreRenderer {
}
}
/**
* Одна {@code m:oMath} → замены на позиции формулы: inline
* {@code w:drawing} с pic:pic (успех) или ран с конкатенацией
* {@code m:t} (деградация: unsupported-конструкция — безопасная сеть
* после байтового скана MathFallbackNormalizer, пустая/битая формула,
* переполнение бюджета PNG). OOM — {@link ConversionException}, не
* деградация (тот же контракт, что у графиков).
*/
private static List<Object> mathReplacements(CTOMath math, boolean display,
Part part, WordprocessingMLPackage pkg,
int[] idSeq, long[] pngTotal,
long maxPngBytesTotal) {
try {
MathRenderer.MathImage mi = MathRenderer.render(MathModel.build(math, display));
if (mi.image() == null) {
return textRuns(MathModel.mathText(math));
}
byte[] png;
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ImageIO.write(mi.image(), "png", bos);
png = bos.toByteArray();
} finally {
mi.image().flush();
}
if (png.length == 0) {
LOG.warn("PNG формулы пуст — формула деградирована в текст");
return textRuns(MathModel.mathText(math));
}
if (pngTotal[0] + png.length > maxPngBytesTotal) {
LOG.warn("суммарный размер PNG превысил {} байт — формула деградирована в текст",
maxPngBytesTotal);
return textRuns(MathModel.mathText(math));
}
pngTotal[0] += png.length;
String relId = addChartMedia(pkg, part, png);
long cx = Math.round(mi.widthPt() * 12700.0);
long cy = Math.round(mi.heightPt() * 12700.0);
Drawing pic = mathPicture(idSeq, relId, cx, cy);
if (display) {
return List.of(pic);
}
// FOP ставит инлайн-картинку НИЖНИМ краем на базовую линию
// строки, поэтому формула «всплывала» на descent+PAD над
// текстом. Word роняет базовую линию формулы на базовую
// линию строки — компенсируем смещением ранa вниз:
// w:rPr/w:position (полупункты, отрицательное опускает,
// §17.3.2.24) через AUDIT-FIX baseline-shift вендорного
// XSLT. belowBaselinePt > PAD всегда (канва ≥ габариту +
// 2·PAD), нулевого смещения не бывает. Регрессия —
// WordPdfConverterTest#ommlMathInline_sitsOnTextBaseline.
R run = new R();
RPr rpr = new RPr();
CTSignedHpsMeasure pos = new CTSignedHpsMeasure();
pos.setVal(BigInteger.valueOf(-Math.round(2 * mi.belowBaselinePt())));
rpr.setPosition(pos);
run.setRPr(rpr);
run.getContent().add(pic);
return List.of(run);
} catch (MathUnsupportedException e) {
LOG.info("формула не поддерживается рендером — деградация в текст: {}",
e.getMessage());
return textRuns(MathModel.mathText(math));
} catch (OutOfMemoryError e) {
LOG.error("память исчерпана при рендере формулы", e);
throw new ConversionException("Память исчерпана при рендере формулы", e);
} catch (Docx4JException | IOException | RuntimeException e) {
LOG.warn("рендер формулы упал: {}", e.toString());
return textRuns(MathModel.mathText(math));
}
}
/**
* Блок {@code m:oMathPara} (§22.1.3.13): все формулы блока — display.
* Word кладёт {@code oMathPara} либо в блок-контейнер (§22.1.3 —
* наблюдаемая раскладка Word-файлов), либо в {@code w:p}; в первом
* случае формулы заворачиваются в новый центрированный {@code w:p},
* во втором — вставляются на место блока, а содержащему абзацу
* выставляется {@code jc=center} (семантика центрированной
* формулы-абзаца; prose в том же абзаце — враждебный вход, центрируется
* тоже — зарегистрированная деградация).
*/
private static List<Object> mathParaReplacements(CTOMathPara para, P ownerPara,
Part part, WordprocessingMLPackage pkg,
int[] idSeq, long[] pngTotal,
long maxPngBytesTotal) {
List<Object> inner = new ArrayList<>();
for (CTOMath m : para.getOMath()) {
inner.addAll(mathReplacements(m, true, part, pkg, idSeq, pngTotal,
maxPngBytesTotal));
}
if (ownerPara != null) {
centerParagraph(ownerPara);
return inner;
}
if (inner.isEmpty()) {
return List.of();
}
P p = new P();
PPr ppr = new PPr();
Jc jc = new Jc();
jc.setVal(JcEnumeration.CENTER);
ppr.setJc(jc);
p.setPPr(ppr);
p.getContent().addAll(inner);
return List.of(p);
}
/** {@code jc=center} на абзаце (создаёт {@code w:pPr}, если нет). */
private static void centerParagraph(P para) {
PPr ppr = para.getPPr();
if (ppr == null) {
ppr = new PPr();
para.setPPr(ppr);
}
Jc jc = new Jc();
jc.setVal(JcEnumeration.CENTER);
ppr.setJc(jc);
}
/** Inline {@code w:drawing} с pic:Pic заданного размера (EMU). */
private static Drawing mathPicture(int[] idSeq, String relId, long cx, long cy) {
Drawing drawing = new Drawing();
Inline inline = new Inline();
inline.setDistT(0L);
inline.setDistB(0L);
inline.setDistL(0L);
inline.setDistR(0L);
CTPositiveSize2D extent = new CTPositiveSize2D();
extent.setCx(cx);
extent.setCy(cy);
inline.setExtent(extent);
CTNonVisualDrawingProps docPr = new CTNonVisualDrawingProps();
docPr.setId(idSeq[0]++);
docPr.setName("Формула " + docPr.getId());
inline.setDocPr(docPr);
Graphic graphic = new Graphic();
GraphicData gd = new GraphicData();
gd.setUri(PICTURE_URI);
gd.getAny().add(buildPic(idSeq, relId, cx, cy, "Формула"));
graphic.setGraphicData(gd);
inline.setGraphic(graphic);
drawing.getAnchorOrInline().add(inline);
return drawing;
}
/** Ран с текстом (деградация формулы); пустой текст — пустой список. */
private static List<Object> textRuns(String text) {
if (text.isEmpty()) {
return List.of();
}
R run = new R();
Text t = new Text();
t.setValue(text);
t.setSpace("preserve");
run.getContent().add(new JAXBElement<>(new QName(WML_URI, "t"), Text.class, t));
return List.of(run);
}
private static BufferedImage renderChart(Part part, CTRelId ref,
DrawMlColor colors, long cx, long cy) {
Part target = resolve(part, ref.getId());
@@ -384,11 +610,25 @@ public final class DrawingPreRenderer {
return;
}
Pic pic = buildPic(idSeq, relId, cx, cy, "Диаграмма");
gd.setUri(PICTURE_URI);
gd.getAny().clear();
gd.getAny().add(pic);
}
/**
* {@code pic:pic} на готовый media-r:id: id/имя из счётчика {@code idSeq}
* (общего для картинок диаграмм и формул), геометрия — входной extent
* (EMU), превью не нужно.
*/
private static Pic buildPic(int[] idSeq, String relId, long cx, long cy,
String namePrefix) {
Pic pic = new Pic();
org.docx4j.dml.picture.CTPictureNonVisual nv = new org.docx4j.dml.picture.CTPictureNonVisual();
CTNonVisualDrawingProps props = new CTNonVisualDrawingProps();
props.setId(idSeq[0]++);
props.setName("Диаграмма " + props.getId());
props.setName(namePrefix + " " + props.getId());
nv.setCNvPr(props);
nv.setCNvPicPr(new CTNonVisualPictureProperties());
pic.setNvPicPr(nv);
@@ -418,10 +658,7 @@ public final class DrawingPreRenderer {
geom.setAvLst(new CTGeomGuideList());
spPr.setPrstGeom(geom);
pic.setSpPr(spPr);
gd.setUri(PICTURE_URI);
gd.getAny().clear();
gd.getAny().add(pic);
return pic;
}
/**
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,75 @@
package ru.pjandro.wordpdf.internal.chart;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
/**
* Растеризация разобранной формулы: дерево {@link MathModel.Box} → PNG
* в координатах pt×dpi/72 (тот же растер-контракт, что у график:
* {@link ChartRenderer#DPI}, понижение dpi по {@link ChartRenderer#fitDpi}
* при превышении площади). Фон прозрачный (ARGB), сглаживание включено —
* глифы рисуются контурами fontbox, шрифтов хоста не касается.
*
* <p>Пустая формула (нулевые метрики) → {@link MathImage} с нулевыми
* размерами и {@code image == null}: вызывающий заменяет её текстом
* {@code m:t} либо убирает вовсе. {@code OutOfMemoryError} при раздутии
* битмапа НЕ перехватывается — это {@code ConversionException} (500) выше
* по стеку, не деградация (контракт chart-модели).
*/
final class MathRenderer {
/** Минимальный размер растра формулы, pt (тонкий индекс не «схлопнется»). */
static final double MIN_WIDTH_PT = 4.0;
/** Минимальная высота растра формулы, pt. */
static final double MIN_HEIGHT_PT = 12.0;
/** Отступ вокруг габарита формулы, pt (обрезка сглаженных краёв). */
static final double PAD_PT = 1.0;
private MathRenderer() {
}
/**
* Растр формулы: PNG-носитель, габарит в pt (для extcx/extcy) и
* {@code belowBaselinePt} — расстояние от базовой линии формулы до
* нижнего края растра (высота минус верхний отступ и ascent; при
* клампе к MIN_HEIGHT — с запасом снизу).
*/
record MathImage(BufferedImage image, double widthPt, double heightPt,
double belowBaselinePt) {
}
/** Растр бокса; пустой бокс → {@code image == null}, размеры 0. */
static MathImage render(MathModel.Box root) {
if (root.isEmpty()) {
return new MathImage(null, 0, 0, 0);
}
double widthPt = Math.max(MIN_WIDTH_PT, root.width + 2 * PAD_PT);
double heightPt = Math.max(MIN_HEIGHT_PT, root.ascent + root.descent + 2 * PAD_PT);
double dpi = ChartRenderer.fitDpi(widthPt, heightPt);
int w = Math.max(1, (int) Math.round(widthPt * dpi / 72.0));
int h = Math.max(1, (int) Math.round(heightPt * dpi / 72.0));
BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
Graphics2D g = img.createGraphics();
try {
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
RenderingHints.VALUE_STROKE_PURE);
g.setColor(new Color(0, 0, 0, 0));
double k = dpi / 72.0;
g.scale(k, k);
double x = (widthPt - root.width) / 2.0;
double baseline = PAD_PT + root.ascent;
root.paint(g, x, baseline);
} finally {
g.dispose();
}
return new MathImage(img, widthPt, heightPt, heightPt - PAD_PT - root.ascent);
}
}
@@ -0,0 +1,20 @@
package ru.pjandro.wordpdf.internal.chart;
/**
* Конструкция OMML, которую формульный рендер не раскладывает: math-элемент
* вне {@link MathModel#SUPPORTED}, math-узел не JAXBElement или структурная
* поломка (например, {@code w:br} внутри math-рана).
*
* <p>Сигнал деградации, не отказа: {@code DrawingPreRenderer} заменяет
* формулу её текстом {@code m:t} вместо растра (контент не теряется).
* Бросается на разборе ({@link MathModel#build}), тем же критерием
* срезается раньше — на байтовом уровне в {@code MathFallbackNormalizer}.
*/
final class MathUnsupportedException extends RuntimeException {
private static final long serialVersionUID = 1L;
MathUnsupportedException(String what) {
super(what);
}
}
@@ -0,0 +1,191 @@
package ru.pjandro.wordpdf;
import org.apache.pdfbox.Loader;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDResources;
import org.apache.pdfbox.pdmodel.font.PDFont;
import org.apache.pdfbox.cos.COSName;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Инвариант «шрифты только бандла» после выноса JEuclid из класса путей:
* MathML-рендер FOP (jeuclid-fop) обращался к AWT-менеджеру шрифтов и
* тащил в вывод системные гарнитуры; формулы теперь рисуются собственным
* растером из jar-шрифтов (fontbox), поэтому JEuclid в classpath и
* протёкших системных имён в PDF быть не должно ни на одном хосте (в т.ч. без
* fontconfig — CI-образ). Регрессия — удаление jeuclid, 2026-11.
*/
class FontsBundledOnlyInvariantTest {
private static final String M_NS =
"http://schemas.openxmlformats.org/officeDocument/2006/math";
private static final String W_NS =
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
/**
* JEuclid обязан отсутствовать в классе путей (exclusion в pom):
* реальные FQCN обоих артефактов форка de.rototor (сверены по jar'ам
* 3.1.14) — вымышленное имя дало бы зелёный тест и без exclusion.
*/
@Test
void jeuclidAbsentFromClasspath() {
assertThrows(ClassNotFoundException.class,
() -> Class.forName("net.sourceforge.jeuclid.MathMLParserSupport"));
assertThrows(ClassNotFoundException.class,
() -> Class.forName("net.sourceforge.jeuclid.fop.JEuclidElementMapping"));
}
/**
* Исходники main не обращаются к AWT-шрифтам: ни {@code java.awt.Font},
* ни {@code GraphicsEnvironment}, ни {@code createFont(} вне комментариев
* и строк. Любое такое обращение инициализирует AWT-менеджер шрифтов
* (fontconfig на хосте) и рвёт инвариант «только бандл» — детект по
* тексту исходников работает и на хосте с шрифтами, и в CI-контейнере
* без fontconfig.
*/
@Test
void sourcesFreeOfAwtFonts() throws IOException {
Path root = Files.isDirectory(Path.of("src/main/java"))
? Path.of("src/main/java")
: Path.of("wordpdf-core/src/main/java");
assertTrue(Files.isDirectory(root), "нет каталога исходников: " + root.toAbsolutePath());
java.util.regex.Pattern createFont =
java.util.regex.Pattern.compile("\\bcreateFont\\s*\\(");
Set<String> hits = new HashSet<>();
try (var walk = Files.walk(root)) {
for (Path p : (Iterable<Path>) walk.filter(f -> f.toString().endsWith(".java"))::iterator) {
String effective = stripCommentsAndStrings(
new String(Files.readAllBytes(p), StandardCharsets.UTF_8));
if (effective.contains("java.awt.Font")
|| effective.contains("java.awt.GraphicsEnvironment")
|| createFont.matcher(effective).find()) {
hits.add(root.relativize(p).toString());
}
}
}
assertTrue(hits.isEmpty(), "AWT-шрифты в исходниках: " + hits);
}
/** Выкидывает комментарии и строковые/символьные литералы — остаётся код. */
private static String stripCommentsAndStrings(String src) {
StringBuilder out = new StringBuilder(src.length());
int i = 0;
int n = src.length();
while (i < n) {
char c = src.charAt(i);
if (c == '/' && i + 1 < n && src.charAt(i + 1) == '/') {
while (i < n && src.charAt(i) != '\n') {
i++;
}
} else if (c == '/' && i + 1 < n && src.charAt(i + 1) == '*') {
i += 2;
while (i + 1 < n && !(src.charAt(i) == '*' && src.charAt(i + 1) == '/')) {
i++;
}
i += 2;
} else if (c == '"' || c == '\'') {
char q = c;
i++;
while (i < n && src.charAt(i) != q) {
i += src.charAt(i) == '\\' ? 2 : 1;
}
i++;
out.append(' ');
} else {
out.append(c);
i++;
}
}
return out.toString();
}
/**
* Формула Word-кегля с {@code w:rFonts w:ascii="Cambria Math"}: растр
* рисуется бандлом, в PDF нет ни «Cambria Math», ни иного имени с
* Math-маркером (AWT-цепочка недоступна на без-fontconfig хостах в
* CI — тест одинаков на любом хосте).
*/
@Test
void mathEmbeddedFonts_bundledOnly() throws IOException {
String body = "<w:p><w:r><w:t>ТЕКСТ</w:t></w:r>"
+ "<m:oMath xmlns:m=\"" + M_NS + "\">"
+ "<m:r><w:rPr><w:rFonts w:ascii=\"Cambria Math\"/></w:rPr>"
+ "<m:t>∑x²</m:t></m:r></m:oMath></w:p>";
byte[] pdf = WordPdfConverter.convert(mathDocx(body), "тест",
new ConvertOptions(false, false, false, 5, 100));
Path out = Files.createTempFile("fonts-invariant-", ".pdf");
try {
Files.write(out, pdf);
Set<String> names = embeddedFontNames(out);
for (String n : names) {
assertTrue(!n.contains("Cambria") && !n.contains("Math"),
"системный math-шрифт встроился в PDF: " + n + " ⊆ " + names);
}
} finally {
Files.deleteIfExists(out);
}
}
/** Минимальный docx с формулой (идеома модуля: ZipOutputStream из литералов). */
private static byte[] mathDocx(String bodyXml) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
try (ZipOutputStream zos = new ZipOutputStream(out)) {
putZip(zos, "[Content_Types].xml",
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+ "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">"
+ "<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>"
+ "<Default Extension=\"xml\" ContentType=\"application/xml\"/>"
+ "<Override PartName=\"/word/document.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\"/>"
+ "</Types>");
putZip(zos, "_rels/.rels",
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+ "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">"
+ "<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"word/document.xml\"/>"
+ "</Relationships>");
putZip(zos, "word/document.xml",
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+ "<w:document xmlns:w=\"" + W_NS + "\"><w:body>"
+ bodyXml
+ "<w:sectPr><w:pgSz w:w=\"11906\" w:h=\"16838\"/></w:sectPr>"
+ "</w:body></w:document>");
}
return out.toByteArray();
}
private static void putZip(ZipOutputStream zos, String name, String xml)
throws IOException {
zos.putNextEntry(new ZipEntry(name));
zos.write(xml.getBytes(StandardCharsets.UTF_8));
zos.closeEntry();
}
/** Имена встроенных шрифтов PDF (дублируется намеренно: утилит нет). */
private static Set<String> embeddedFontNames(Path pdf) throws IOException {
Set<String> names = new HashSet<>();
try (PDDocument doc = Loader.loadPDF(pdf.toFile())) {
for (org.apache.pdfbox.pdmodel.PDPage page : doc.getPages()) {
PDResources res = page.getResources();
for (COSName name : res.getFontNames()) {
PDFont font = res.getFont(name);
if (font != null) {
names.add(font.getName());
}
}
}
}
return names;
}
}
@@ -2394,17 +2394,6 @@ class WordPdfConverterTest {
}
}
/** Доступен ли AWT-менеджер шрифтов (fontconfig) — та же проба, что в ядре. */
private static boolean awtFontsAvailable() {
try {
java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment()
.getAvailableFontFamilyNames();
return true;
} catch (Throwable t) {
return false;
}
}
/**
* Скрытый текст не выводится: правило 9 (HiddenTextNormalizer) вырезает
* раны с прямым truthy vanish и с rStyle на vanish-стиль; falsy vanish
@@ -2693,31 +2682,149 @@ class WordPdfConverterTest {
}
/**
* OMML-формула (§22.1): на хосте с fontconfig рисуется вектором
* (jeuclid-fop) — чернила страницы с дробью a/b заметно плотнее чернил
* того же текста без формулы (замер аудита: +150 px при 150 dpi; текст
* формулы из PDF не извлекается). Без fontconfig (контейнерный рантайм,
* arm64-хост без /etc/fonts) JEuclid недоступен: формула обязана
* деградировать в текст (MathFallbackNormalizer), а не валить конвертацию
* InternalError'ом — чернил становится больше, чем у маркера.
* Формула внутри текстового бокса ({@code w:txbxContent}): обход
* {@code DrawingPreRenderer} в drawing-нагрузку не спускается, формула
* доходит до FO, а там docx4j без JEuclid штатно фолбэкает
* {@code XsltFOFunctions.mathText} — конвертация обязана пройти, текст
* бокса напечатан, падения FOP (нет MathML-рендера) нет. Регрессия —
* удаление jeuclid без sweep'а, 2026-11.
*/
@Test
void ommlMath_drawnAsVectors() throws IOException {
String marker = "<w:p><w:r><w:t>МАТЕМАРКЕР</w:t></w:r></w:p>";
String math = marker + "<w:p><m:oMath"
+ " xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\">"
void drawingTextBoxMath_convertsViaDocx4jTextFallback() throws IOException {
String body = "<w:p><w:r><w:drawing><wp:inline distT=\"0\" distB=\"0\" distL=\"0\" distR=\"0\">"
+ "<wp:extent cx=\"1000000\" cy=\"600000\"/><wp:docPr id=\"1\" name=\"b1\"/>"
+ "<a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">"
+ "<a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingShape\">"
+ "<wps:wsp xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\">"
+ "<wps:spPr><a:xfrm><a:off x=\"0\" y=\"0\"/>"
+ "<a:ext cx=\"1000000\" cy=\"600000\"/></a:xfrm>"
+ "<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom></wps:spPr>"
+ "<wps:txbx><w:txbxContent><w:p><w:r><w:t>БОКС</w:t></w:r>"
+ "<m:oMath xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\">"
+ "<m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f></m:oMath></w:p>";
int plainPx = countPixels(minimalDocx(marker), false);
int mathPx = countPixels(minimalDocx(math), false);
if (awtFontsAvailable()) {
assertTrue(mathPx - plainPx >= 100, "math=" + mathPx + " plain=" + plainPx);
} else {
assertTrue(mathPx > plainPx,
"формула не деградировала в текст: math=" + mathPx + " plain=" + plainPx);
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f></m:oMath></w:p>"
+ "</w:txbxContent></wps:txbx></wps:wsp></a:graphicData></a:graphic></wp:inline>"
+ "</w:drawing></w:r></w:p>";
byte[] doc = docx("xmlns:w=\"" + W_NS + "\""
+ " xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\"",
body, A4_SECT, null, null, null);
String t = norm(pdfText(convertPdf(doc, "тест")));
assertTrue(t.contains("БОКС"), t);
assertTrue(t.contains("ab"),
"docx4j-фолбэк обязан напечатать конкатенацию m:t формулы: " + t);
}
/**
* OMML-формула (§22.1) рисуется собственным растером (MathModel →
* MathRenderer в DrawingPreRenderer) и заменяется картинкой: inline
* {@code m:oMath} — на месте в абзаце, блок {@code m:oMathPara} —
* центрированным абзацем. Чернила формул — растровые XObject, символа
* формул в текстовом слое нет; поведение не зависит от fontconfig
* (jeuclid/AWT-шрифты в конвейере не участвуют). Регрессия —
* замена jeuclid-ветки на собственный рендер, 2026-11.
*/
@Test
void ommlMath_drawnAsRaster() throws IOException {
String mathNs = " xmlns:m=\"http://schemas.openxmlformats.org"
+ "/officeDocument/2006/math\"";
String frac = "<m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>";
String body = "<w:p><w:r><w:t>МАТЕМАРКЕР</w:t></w:r>"
+ "<m:oMath" + mathNs + ">" + frac + "</m:oMath></w:p>"
+ "<m:oMathPara" + mathNs + "><m:oMath>" + frac
+ "</m:oMath></m:oMathPara>";
Path pdf = convertPdf(minimalDocx(body), "тест");
assertEquals(2, distinctImageCount(pdf),
"обе формулы (inline и display) обязаны стать растрами");
String t = norm(pdfText(pdf));
assertTrue(t.contains("МАТЕМАРКЕР"), t);
assertFalse(t.contains("a b") || t.contains("ab"),
"формула протекла в текстовый слой: " + t);
}
/**
* Inline-формула стоит на базовой линии строки, как в Word: FOP
* роняет нижний край инлайн-картинки на базовую линию, поэтому
* {@code DrawingPreRenderer} опускает ран с картинкой через
* {@code w:rPr/w:position} на её нижний запас (descent+PAD). Замер —
* попиксельно (144 dpi): чернила знаменателя без спуска (цифры)
* обязаны кончаться на строке базовой линии текста (±2 px). Без
* компенсации формула висела на ~3 pt выше базы. Регрессия —
* собственный рендер OMML, 2026-11.
*/
@Test
void ommlMathInline_sitsOnTextBaseline() throws IOException {
String body = "<w:p><w:r><w:t>ZZZ</w:t></w:r>"
+ "<m:oMath xmlns:m=\"http://schemas.openxmlformats.org"
+ "/officeDocument/2006/math\">"
+ "<m:f><m:num><m:r><m:t>7</m:t></m:r></m:num>"
+ "<m:den><m:r><m:t>1</m:t></m:r></m:den></m:f></m:oMath>"
+ "<w:r><w:t>YYY</w:t></w:r></w:p>";
Path pdf = convertPdf(minimalDocx(body), "тест");
final double[] baseY = {Double.NaN};
final double[] zEnd = {0};
final double[] yStart = {99999};
PDFTextStripper stripper = new PDFTextStripper() {
@Override
protected void writeString(String s,
List<org.apache.pdfbox.text.TextPosition> positions) {
for (org.apache.pdfbox.text.TextPosition tp : positions) {
if ("Z".equals(tp.getUnicode())) {
baseY[0] = tp.getYDirAdj();
zEnd[0] = Math.max(zEnd[0], tp.getXDirAdj() + tp.getWidth());
} else if ("Y".equals(tp.getUnicode())) {
yStart[0] = Math.min(yStart[0], tp.getXDirAdj());
}
}
}
};
float scale = 2f;
try (PDDocument doc = Loader.loadPDF(pdf.toFile())) {
stripper.setStartPage(1);
stripper.setEndPage(1);
stripper.getText(doc);
java.awt.image.BufferedImage raster =
new PDFRenderer(doc).renderImage(0, scale);
int x0 = (int) (zEnd[0] * scale) + 2;
int x1 = (int) (yStart[0] * scale) - 2;
int baselineRow = (int) Math.round(baseY[0] * scale);
int inkBottom = -1;
final int inkMask = 0xFFFFFF;
final int inkMax = 0x808080;
for (int y = 0; y < raster.getHeight(); y++) {
for (int x = x0; x < x1; x++) {
if ((raster.getRGB(x, y) & inkMask) < inkMax) {
inkBottom = y;
break;
}
}
}
assertTrue(inkBottom > 0, "чернил формулы между ZZZ и YYY нет");
assertTrue(Math.abs(inkBottom - baselineRow) <= 2,
"низ чернил формулы row=" + inkBottom
+ " против базовой строки row=" + baselineRow);
}
}
/**
* Неизвестная math-конструкция (вне {@code MathModel.SUPPORTED}):
* MathFallbackNormalizer (правило 6) срезает блок в конкатенацию
* {@code m:t} ещё до загрузки docx4j — текст выводится (кириллица —
* бандлом, GlyphCoverage видит уже расплющенный ран), растра нет.
*/
@Test
void ommlUnsupported_degradesToText() throws IOException {
String body = "<w:p><m:oMath"
+ " xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\">"
+ "<m:fooBar><m:r><m:t>ФОРМУЛАДЕГРАД</m:t></m:r></m:fooBar>"
+ "</m:oMath></w:p>";
Path pdf = convertPdf(minimalDocx(body), "тест");
String t = norm(pdfText(pdf));
assertTrue(t.contains("ФОРМУЛАДЕГРАД"), t);
assertEquals(0, distinctImageCount(pdf),
"unsupported-формула не обязана давать растр");
}
/**
* {@code w:highlight} и run-{@code w:shd} (§17.3.2.16/.29) рисуют фон —
* вопреки прежней записи аудита о «фоном не обладающем fo:inline»
@@ -0,0 +1,71 @@
package ru.pjandro.wordpdf.fonts;
import org.docx4j.fonts.PhysicalFont;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.*;
/**
* Таблица алиасов шрифтов (BundledFontAliases): прямое и обратное
* имя, fallback. Состояние «бандл не инициализирован» моделируется
* сохранением и восстановлением статического реестра BundledFonts.
*
* Класс намеренно не наследует BestMatchingMapper: обращение к его
* статикам не должно сканировать реестр шрифтов (см. javadoc класса).
*/
class BundledFontAliasesTest {
/** Выполнить body в состоянии «шрифты бандла не зарегистрированы», затем восстановить. */
private static void withoutBundledInit(Runnable body) throws Exception {
Field initedField = BundledFonts.class.getDeclaredField("inited");
initedField.setAccessible(true);
// VARIANTS package-private (тот же пакет) — снимок/очистка напрямую,
// типизированно, без reflection-каста.
Map<String, Map<String, PhysicalFont>> savedVariants = new HashMap<>(BundledFonts.VARIANTS);
boolean savedInited = initedField.getBoolean(null);
BundledFonts.VARIANTS.clear();
initedField.setBoolean(null, false);
try {
body.run();
} finally {
BundledFonts.VARIANTS.clear();
BundledFonts.VARIANTS.putAll(savedVariants);
initedField.setBoolean(null, savedInited);
}
}
/** Алиас + зарегистрированное семейство -> бандл-семейство (имя в любом регистре). */
@Test
void bundledFamilyKnownAliasMapsToBundle() {
BundledFonts.init();
assertEquals("carlito", BundledFontAliases.bundledFamily("Calibri"));
assertEquals("tinos", BundledFontAliases.bundledFamily("Times New Roman"));
assertEquals("dejavu sans", BundledFontAliases.bundledFamily("DejaVu Sans"));
}
/** Имени нет в таблице алиасов -> финальный fallback. */
@Test
void bundledFamilyUnknownFallsBack() {
BundledFonts.init();
assertEquals("dejavu sans", BundledFontAliases.bundledFamily("Zzz Not A Font"));
}
/** Алиас есть, но бандл не зарегистрирован (init() не вызван) -> fallback. */
@Test
void bundledFamilyWithoutInitFallsBack() throws Exception {
withoutBundledInit(() ->
assertEquals("dejavu sans", BundledFontAliases.bundledFamily("Calibri")));
}
/** Имя бандл-семейства для w:rFonts: отображаемое имя или само семейство. */
@Test
void documentFontNameMapsDisplayNames() {
assertEquals("DejaVu Sans", BundledFontAliases.documentFontName("dejavu sans"));
assertEquals("carlito", BundledFontAliases.documentFontName("carlito"),
"семейство без отображаемого имени возвращается как есть");
}
}
@@ -1,5 +1,6 @@
package ru.pjandro.wordpdf.fonts;
import org.docx4j.Docx4jProperties;
import org.docx4j.fonts.PhysicalFont;
import org.docx4j.wml.Fonts;
import org.junit.jupiter.api.Test;
@@ -20,6 +21,22 @@ import static org.junit.jupiter.api.Assertions.*;
*/
class BundledFontMapperTest {
/**
* Гейт сканов docx4j: тот же, что {@code WordPdfConverter.<clinit>}
* (строки 85–86). Тест грузит {@code BundledFontMapper} напрямую, а
* инициализация класса-подкласса по JLS тянет {@code <clinit>}
* {@code BestMatchingMapper} — без арминга скан прошёл бы ungated.
* Package-private: PMD UnusedPrivateField не видит побочных эффектов
* инициализации, обращение к полю не нужно ни одному тесту.
*/
static final boolean ARMED = arm();
private static boolean arm() {
Docx4jProperties.setProperty("docx4j.fonts.discoverPhysicalFonts.enabled", "false");
Docx4jProperties.setProperty("docx4j.fonts.discoverJarFonts.enabled", "false");
return true;
}
/** Тело теста, кидающее checked-исключение (populateFontMappings throws Exception). */
private interface TestBody {
void run() throws Exception;
@@ -44,29 +61,6 @@ class BundledFontMapperTest {
}
}
/** Алиас + зарегистрированное семейство -> бандл-семейство (имя в любом регистре). */
@Test
void bundledFamilyKnownAliasMapsToBundle() {
BundledFonts.init();
assertEquals("carlito", BundledFontMapper.bundledFamily("Calibri"));
assertEquals("tinos", BundledFontMapper.bundledFamily("Times New Roman"));
assertEquals("dejavu sans", BundledFontMapper.bundledFamily("DejaVu Sans"));
}
/** Имени нет в таблице алиасов -> финальный fallback. */
@Test
void bundledFamilyUnknownFallsBack() {
BundledFonts.init();
assertEquals("dejavu sans", BundledFontMapper.bundledFamily("Zzz Not A Font"));
}
/** Алиас есть, но бандл не зарегистрирован (init() не вызван) -> fallback. */
@Test
void bundledFamilyWithoutInitFallsBack() throws Exception {
withoutBundledInit(() ->
assertEquals("dejavu sans", BundledFontMapper.bundledFamily("Calibri")));
}
/**
* Имя документа == SYMBOL_FONT маппится сразу (до родительского поиска),
* алиасы — на бандл, нераспознанное — в fallback DejaVu Sans.
@@ -105,12 +99,4 @@ class BundledFontMapperTest {
"без init() алиасованный шрифт не должен попасть и в fallback");
});
}
/** Имя бандл-семейства для w:rFonts: отображаемое имя или само семейство. */
@Test
void documentFontNameMapsDisplayNames() {
assertEquals("DejaVu Sans", BundledFontMapper.documentFontName("dejavu sans"));
assertEquals("carlito", BundledFontMapper.documentFontName("carlito"),
"семейство без отображаемого имени возвращается как есть");
}
}
@@ -4,56 +4,168 @@ 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.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** Юниты правила 11: OMML → текст без fontconfig (MathFallbackNormalizer). */
/**
* Юниты правила 6: unsupported-формулы OMML → текст (MathFallbackNormalizer).
* Скан namespace-aware: чужие префиксы не триггерят, unsupported-имя в
* math-namespace — срезает весь блок в конкатенацию {@code m:t}.
*/
class MathFallbackNormalizerTest {
private static final String M_NS =
"http://schemas.openxmlformats.org/officeDocument/2006/math";
private static final String W_NS =
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
private static final String ROOT = "<w:document xmlns:w=\"" + W_NS
+ "\" xmlns:m=\"" + M_NS + "\"><w:body>";
/** Unsupported-имя в math-namespace — блок целиком становится раном. */
@Test
void flatten_inlineMath_becomesRunWithText() {
String xml = "<w:p><w:r><w:t>ДО</w:t></w:r><m:oMath xmlns:m=\"" + M_NS + "\">"
+ "<m:r><m:t>x</m:t></m:r><m:sSup><m:e><m:r><m:t>y</m:t></m:r></m:e>"
+ "<m:sup><m:r><m:t>2</m:t></m:r></m:sup></m:sSup></m:oMath>"
+ "<w:r><w:t>ПОСЛЕ</w:t></w:r></w:p>";
assertEquals("<w:p><w:r><w:t>ДО</w:t></w:r>"
+ "<w:r><w:t xml:space=\"preserve\">xy2</w:t></w:r>"
+ "<w:r><w:t>ПОСЛЕ</w:t></w:r></w:p>",
MathFallbackNormalizer.flatten(xml));
void unsupportedMathTag_flattensToText() {
String xml = ROOT + "<w:p><m:oMath><m:fooBar/>"
+ "<m:r><m:t>a/b</m:t></m:r></m:oMath></w:p></w:body></w:document>";
String out = MathFallbackNormalizer.rewrite(xml);
assertEquals(ROOT + "<w:p><w:r><w:t xml:space=\"preserve\">a/b</w:t></w:r>"
+ "</w:p></w:body></w:document>", out);
}
/**
* Боевой XML начинается с {@code <?xml ...?>}: карта root-ных xmlns
* обязана браться с фактического корневого элемента, а {@code w:rPr}/
* {@code w:rFonts} внутри math-рана — чужой namespace, не unsupported.
* Иначе пустая карта консервативно срезала бы каждую Word-формулу.
*/
@Test
void flatten_mathPara_removedBeforeInline() {
String xml = "<w:p><m:oMathPara xmlns:m=\"" + M_NS + "\"><m:oMath>"
+ "<m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>"
+ "</m:oMath></m:oMathPara></w:p>";
String out = MathFallbackNormalizer.flatten(xml);
assertEquals("<w:p><w:r><w:t xml:space=\"preserve\">ab</w:t></w:r></w:p>", out);
assertFalse(out.contains("m:oMath"), out);
void xmlPrologueAndWmlRPrInMath_unchanged() {
String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+ "<w:document xmlns:w=\"" + W_NS + "\" xmlns:m=\"" + M_NS + "\">"
+ "<w:body><w:p><m:oMath><m:r><w:rPr><w:rFonts w:ascii=\"Cambria\"/>"
+ "<w:sz w:val=\"22\"/></w:rPr><m:t>a</m:t></m:r></m:oMath></w:p>"
+ "</w:body></w:document>";
assertNull(MathFallbackNormalizer.rewrite(xml));
}
/** Поддерживаемая конструкция (дробь) — массив не меняется (null). */
@Test
void flatten_selfClosingMath_removed() {
assertEquals("ДОПОСЛЕ",
MathFallbackNormalizer.flatten("ДО<m:oMath/>ПОСЛЕ"));
void supportedMath_unchanged() {
String xml = ROOT + "<w:p><m:oMath><m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f></m:oMath></w:p>"
+ "</w:body></w:document>";
assertNull(MathFallbackNormalizer.rewrite(xml));
}
/** Неизвестный тег ЧУЖОГО namespace внутри формулы — не unsupported. */
@Test
void flatten_emptyMath_removed() {
assertEquals("ДОПОСЛЕ",
MathFallbackNormalizer.flatten("ДО<m:oMath></m:oMath>ПОСЛЕ"));
void foreignNamespaceIgnored() {
String xml = ROOT + "<w:p><m:oMath><w:someWmlForeign/><m:r><m:t>x</m:t></m:r>"
+ "</m:oMath></w:p></w:body></w:document>";
assertNull(MathFallbackNormalizer.rewrite(xml));
}
/** {@code m:oMathPara} с unsupported внутри — срезается весь блок, каркас сбалансирован. */
@Test
void flatten_noMath_returnsNull() {
assertNull(MathFallbackNormalizer.flatten("<w:r><w:t>ТЕКСТ</w:t></w:r>"));
void mathParaBlockReplacedWhole() {
String xml = ROOT + "<m:oMathPara><m:oMath><m:nope/><m:r><m:t>X</m:t></m:r>"
+ "</m:oMath></m:oMathPara>";
String out = MathFallbackNormalizer.rewrite(xml);
assertEquals(ROOT + "<w:r><w:t xml:space=\"preserve\">X</w:t></w:r>", out);
assertFalse(out.contains("oMath"), "каркас формулы остался: " + out);
}
/** Самозакрывающийся пустой блок формул — supported, без изменений. */
@Test
void rewrite_noMath_returnsNullWithoutProbe() {
assertNull(MathFallbackNormalizer.rewrite("<w:r><w:t>ТЕКСТ</w:t></w:r>"));
void selfClosingEmpty_unchanged() {
String xml = ROOT + "<m:oMathPara/><w:p><m:oMath/></w:p></w:body></w:document>";
assertNull(MathFallbackNormalizer.rewrite(xml));
}
/** Inline-формула перед unsupported-пара — блок inline не «склеивается» с парой. */
@Test
void inlineAndParaBlocksIndependent() {
String xml = ROOT + "<w:p><m:oMath><m:r><m:t>OK</m:t></m:r></m:oMath></w:p>"
+ "<m:oMathPara><m:oMath><m:bad/></m:oMath></m:oMathPara>";
String out = MathFallbackNormalizer.rewrite(xml);
assertTrue(out.contains("<m:oMath><m:r><m:t>OK</m:t></m:r></m:oMath>"),
"supported inline-формула не должна была меняться: " + out);
assertFalse(out.contains("m:bad"), out);
assertFalse(out.contains("oMathPara"), out);
}
/** Без объявленных xmlns вообще — консервативно: unknown имя режет блок. */
@Test
void noNamespaceMap_conservativeFlatten() {
String xml = "ДО<m:oMath><m:weird/></m:oMath>ПОСЛЕ";
String out = MathFallbackNormalizer.rewrite(xml);
assertEquals("ДОПОСЛЕ", out, "пустая формула удаляется без следа");
}
/** Формул нет / формула без префикса math — {@code null} (тот же массив). */
@Test
void noMathBlocks_null() {
assertNull(MathFallbackNormalizer.rewrite(
"<w:r xmlns:w=\"" + W_NS + "\"><w:t>ТЕКСТ</w:t></w:r>"));
assertNull(MathFallbackNormalizer.rewrite("<doc><oMath/>мусор</doc>"));
}
/** Переопределение {@code xmlns:m} на чужой URI внутри блока — не формула. */
@Test
void blockLocalNamespaceOverride_skipped() {
String xml = ROOT + "<w:p><q:oMath xmlns:q=\"urn:custom\">"
+ "<q:whatever/><q:t>x</q:t></q:oMath></w:p></w:body></w:document>";
assertNull(MathFallbackNormalizer.rewrite(xml));
}
/**
* Битый каркас (незакрытый тег, нет закрывающего {@code </m:oMath...>})
* — скан останавливается без изменений: чинять XML — дело валидатора.
*/
@Test
void brokenFrames_stopScan() {
assertNull(MathFallbackNormalizer.rewrite(ROOT + "<w:p><m:oMath"));
assertNull(MathFallbackNormalizer.rewrite(
ROOT + "<w:p><m:oMath><m:fooBar/></w:p></w:body></w:document>"));
assertNull(MathFallbackNormalizer.rewrite(
ROOT + "<m:oMathPara><m:oMath><m:bad/>"));
}
/** tagEnd кавычки-осведомлён: {@code >}/кавычки внутри значения атрибута тег не заканчивают. */
@Test
void quoteAwareTagEnd_flattens() {
String out = MathFallbackNormalizer.rewrite(ROOT
+ "<w:p><m:oMath><m:bad m:val=\"a>'b\"/>"
+ "<m:r><m:t>Q</m:t></m:r></m:oMath></w:p></w:body></w:document>");
assertNotNull(out, "символ > в кавычках ошибочно закончил тег");
assertTrue(out.contains(">Q<") && !out.contains("m:bad"), out);
}
/**
* Незакрытые пролог-объявления (PI/комментарий/DOCTYPE) — карта xmlns
* пустая, консервативный срез (как в {@link #noNamespaceMap_conservativeFlatten});
* закрытые варианты — обычный путь.
*/
@Test
void unterminatedPrologues_conservativeFlatten() {
assertTrue(MathFallbackNormalizer.rewrite(
"<?xml<m:oMath><m:bad/><m:r><m:t>Т</m:t></m:r></m:oMath>")
.contains(">Т<"), "блок не срезан");
assertTrue(MathFallbackNormalizer.rewrite(
"<!-- p<m:oMath><m:bad/><m:r><m:t>ТК</m:t></m:r></m:oMath>")
.contains(">ТК<"), "блок не срезан");
assertTrue(MathFallbackNormalizer.rewrite(
"<!D<m:oMath><m:bad/><m:r><m:t>ТЕ</m:t></m:r></m:oMath>")
.contains(">ТЕ<"), "блок не срезан");
assertTrue(MathFallbackNormalizer.rewrite(
"<!-- c --><!D d><m:oMath><m:bad/><m:r><m:t>Ы</m:t></m:r></m:oMath>")
.contains(">Ы<"), "блок не срезан");
}
/** Пробелы перед {@code />} самозакрывающегося блока — габарит-петля не сбивает self-closing. */
@Test
void whitespaceBeforeSelfClosing_unchanged() {
assertNull(MathFallbackNormalizer.rewrite(
ROOT + "<w:p><m:oMath /></w:p></w:body></w:document>"));
}
}
@@ -0,0 +1,540 @@
package ru.pjandro.wordpdf.internal.chart;
import jakarta.xml.bind.JAXBElement;
import org.docx4j.math.CTOMath;
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
import org.junit.jupiter.api.Test;
import ru.pjandro.wordpdf.fonts.BundledFonts;
import ru.pjandro.wordpdf.fonts.GlyphFont;
import javax.xml.namespace.QName;
import java.awt.Color;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;
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.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Разбор OMML в боксы и растеризация (MathModel/MathRenderer) на
* синтетическом docx (ZipOutputStream из литеральных XML — идеома модуля)
* и синтетических JAXB-элементах.
*/
class MathModelTest {
private static final String M_NS =
"http://schemas.openxmlformats.org/officeDocument/2006/math";
private static final String W_NS =
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
/** Дробь a/b внутри inline-формулы. */
private static final String FRAC = "<m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>";
// ------------------------------------------------------------------
// Метрики и растер дроби
// ------------------------------------------------------------------
/** Дробь: ненулевые метрики; растер — с чернилами и минимумом габарита. */
@Test
void fraction_measuresAndRenders() throws IOException {
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ FRAC + "</m:oMath></w:p>"));
MathModel.Box box = MathModel.build(math, false);
assertTrue(box.width > 0, "нулевая ширина дроби");
assertTrue(box.ascent > 0, "нулевой подъём дроби");
assertTrue(box.descent > 0, "нулевой спуск дроби");
MathRenderer.MathImage img = MathRenderer.render(box);
assertNotNull(img.image(), "пустой растр при неразрешённой дроби");
assertTrue(img.widthPt() >= MathRenderer.MIN_WIDTH_PT, "ширина ниже минимума");
assertTrue(img.heightPt() >= MathRenderer.MIN_HEIGHT_PT, "высота ниже минимума");
assertTrue(hasInk(img.image()), "растр дроби без единого непрозрачного пикселя");
}
/** Конкатенация {@code m:t} (контракт деградации): num+den без разделителя. */
@Test
void mathText_collectsNestedRuns() throws IOException {
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ FRAC + "</m:oMath></w:p>"));
assertEquals("ab", MathModel.mathText(math));
}
/** Пустая формула: {@code image == null}, габариты нулевые (вызывающий удалит блок). */
@Test
void emptyMath_rendersNullImage() throws IOException {
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ "</m:oMath></w:p>"));
MathRenderer.MathImage img = MathRenderer.render(MathModel.build(math, false));
assertNull(img.image(), "пустая формула не обязана рисоваться");
assertEquals(0, img.widthPt(), 0.0001);
assertEquals(0, img.heightPt(), 0.0001);
}
/** Надстрочный индекс добавляет ширину и не режет верх базы (подъём ≥ базы). */
@Test
void superscript_addsScriptWidth() throws IOException {
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ "<m:sSup><m:e><m:r><m:t>x</m:t></m:r></m:e>"
+ "<m:sup><m:r><m:t>2</m:t></m:r></m:sup></m:sSup></m:oMath></w:p>"));
MathModel.Box sup = MathModel.build(math, false);
GlyphFont plain = GlyphFont.of(BundledFonts.FALLBACK_FAMILY, BundledFonts.V_REGULAR);
MathModel.Box run = new MathModel.RunBox("x", plain,
MathModel.DEFAULT_SIZE_PT, Color.BLACK);
assertTrue(sup.width > run.width,
"индекс не добавил ширины: " + sup.width + " <= " + run.width);
assertTrue(sup.ascent >= run.ascent,
"индекс срезал верх базы: " + sup.ascent + " < " + run.ascent);
}
/**
* Канва растра обязана вмещать пределы (undOvr-пределы nary и стопку
* sPre) целиком: метрики бокса равны габариту paint, поэтому чернила
* не касаются верхней/нижней границы канвы (PAD-отступ снаружи).
* До пересчёта метрик ascent/descent NaryBox/PreScriptBox не учитывали
* полную высоту пределов — чернила резались по краю канвы (тот же
* зелёный «есть чернила», но подрезанный растер). Регрессия — 2026-11.
*/
@Test
void limits_notClippedByCanvas() throws IOException {
String nary = "<m:nary><m:naryPr><m:chr m:val=\"∑\"/>"
+ "<m:limLoc m:val=\"undOvr\"/></m:naryPr>"
+ "<m:sub><m:r><m:t>abc</m:t></m:r></m:sub>"
+ "<m:sup><m:r><m:t>def</m:t></m:r></m:sup>"
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:nary>";
String pre = "<m:sPre><m:e><m:r><m:t>B</m:t></m:r></m:e>"
+ "<m:sub><m:r><m:t>i+j</m:t></m:r></m:sub>"
+ "<m:sup><m:r><m:t>m-n</m:t></m:r></m:sup></m:sPre>";
for (String xmlBody : new String[] {nary, pre}) {
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ xmlBody + "</m:oMath></w:p>"));
MathRenderer.MathImage img = MathRenderer.render(MathModel.build(math, false));
assertNotNull(img.image(), "пустой растр");
java.awt.image.BufferedImage raster = img.image();
int h = raster.getHeight();
assertTrue(!rowInk(raster, 0) && !rowInk(raster, 1)
&& !rowInk(raster, h - 1) && !rowInk(raster, h - 2),
"чернила пределов обрезаны краем канвы (h=" + h + ")");
}
}
/** Есть ли непрозрачный пиксель в строке растра. */
private static boolean rowInk(java.awt.image.BufferedImage img, int y) {
for (int x = 0; x < img.getWidth(); x++) {
if ((img.getRGB(x, y) >>> 24) != 0) {
return true;
}
}
return false;
}
/**
* Свойства конструкций (§22.1.2): нестандартные значения идут теми же
* ветками диспетчера, что и документ-образец — bot-позиции bar/groupChr,
* произвольные m:chr, пустой m:chr, show=on у phantom, явный тип дроби,
* begChr/endChr/sepChr разделителя (в т.ч. разделитель между аргументами),
* degHide радикала, chr/limLoc=subSup у nary, rPr ранa (m:sty, w:sz,
* w:color валидный/битый, w:rFonts, m:t без значения), limLow с пустым
* lim, малый разделитель без масштабирования скобок.
*/
@Test
void propertyVariants_render() throws IOException {
assertRendered("<m:bar><m:barPr><m:pos m:val=\"bot\"/></m:barPr>"
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:bar>");
assertRendered("<m:acc><m:accPr><m:chr m:val=\"~\"/></m:accPr>"
+ "<m:e><m:r><m:t>y</m:t></m:r></m:e></m:acc>");
assertRendered("<m:groupChr><m:groupChrPr><m:chr m:val=\"⏝\"/>"
+ "<m:pos m:val=\"bot\"/></m:groupChrPr>"
+ "<m:e><m:r><m:t>abc</m:t></m:r></m:e></m:groupChr>");
assertRendered("<m:groupChr><m:groupChrPr><m:chr m:val=\"\"/></m:groupChrPr>"
+ "<m:e><m:r><m:t>de</m:t></m:r></m:e></m:groupChr>");
assertRendered("<m:groupChr><m:groupChrPr><m:chr m:val=\"&#xE123;\"/></m:groupChrPr>"
+ "<m:e><m:r><m:t>fg</m:t></m:r></m:e></m:groupChr>");
assertRendered("<m:phant><m:phantPr><m:show m:val=\"on\"/></m:phantPr>"
+ "<m:e><m:r><m:t>z</m:t></m:r></m:e></m:phant>");
assertRendered("<m:f><m:fPr><m:type m:val=\"bar\"/></m:fPr>"
+ "<m:num><m:r><m:t>a</m:t></m:r></m:num>"
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>");
assertRendered("<m:d><m:dPr><m:begChr m:val=\"[\"/><m:endChr m:val=\"]\"/>"
+ "<m:sepChr m:val=\";\"/></m:dPr>"
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e>"
+ "<m:e><m:r><m:t>b</m:t></m:r></m:e></m:d>");
assertRendered("<m:d><m:e><m:r><m:t>q</m:t></m:r></m:e></m:d>");
assertRendered("<m:d><m:e><m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f></m:e></m:d>");
assertRendered("<m:rad><m:radPr><m:degHide m:val=\"on\"/></m:radPr><m:deg/>"
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:rad>");
assertRendered("<m:nary><m:naryPr><m:chr m:val=\"∮\"/>"
+ "<m:limLoc m:val=\"subSup\"/></m:naryPr>"
+ "<m:sub><m:r><m:t>0</m:t></m:r></m:sub>"
+ "<m:sup><m:r><m:t>1</m:t></m:r></m:sup>"
+ "<m:e><m:r><m:t>f</m:t></m:r></m:e></m:nary>");
assertRendered("<m:limLow><m:lim/><m:e><m:r><m:t>u</m:t></m:r></m:e></m:limLow>");
assertRendered("<m:limLow><m:lim><m:r><m:t>n→∞</m:t></m:r></m:lim>"
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e></m:limLow>");
assertRendered("<m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr>"
+ "<w:rPr><w:sz w:val=\"20\"/><w:color w:val=\"#FF0000\"/>"
+ "<w:rFonts w:ascii=\"Arial\"/></w:rPr>"
+ "<m:t>Q</m:t></m:r>");
assertRendered("<m:r><w:rPr><w:color w:val=\"#GG\"/></w:rPr>"
+ "<m:t>R</m:t></m:r>");
assertRendered("<m:r><w:rPr><w:color w:val=\"#GGHHII\"/></w:rPr>"
+ "<m:t>R2</m:t></m:r>");
assertRendered("<m:r><m:t></m:t></m:r><m:r><m:t>S</m:t></m:r>");
// val-пустые свойства — дефолтные цепочки (атрибут без m:val/w:val)
assertRendered("<m:acc><m:accPr><m:chr/></m:accPr>"
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:acc>");
assertRendered("<m:groupChr><m:groupChrPr><m:chr/><m:pos/></m:groupChrPr>"
+ "<m:e><m:r><m:t>yz</m:t></m:r></m:e></m:groupChr>");
assertRendered("<m:bar><m:barPr><m:pos/></m:barPr>"
+ "<m:e><m:r><m:t>u</m:t></m:r></m:e></m:bar>");
assertRendered("<m:nary><m:naryPr><m:chr/><m:limLoc/></m:naryPr>"
+ "<m:sub><m:r><m:t>0</m:t></m:r></m:sub><m:sup/>"
+ "<m:e><m:r><m:t>g</m:t></m:r></m:e></m:nary>");
assertRendered("<m:d><m:dPr><m:begChr/><m:endChr/><m:sepChr/></m:dPr>"
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e>"
+ "<m:e><m:r><m:t>b</m:t></m:r></m:e></m:d>");
assertRendered("<m:f><m:fPr><m:type/></m:fPr>"
+ "<m:num><m:r><m:t>a</m:t></m:r></m:num>"
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>");
assertRendered("<m:r><w:rPr><w:sz/><w:color/></w:rPr>"
+ "<m:t>Z</m:t></m:r>");
assertRendered("<m:r><w:rPr><w:rFonts w:ascii=\"\"/></w:rPr>"
+ "<m:t>W</m:t></m:r>");
assertRendered("<m:rad><m:deg/><m:e><m:r><m:t>x</m:t></m:r></m:e></m:rad>");
}
/** {@code w:br} внутри math-рана — unsupported (деградация в текст, не PD-падение). */
@Test
void brInMathRun_unsupported() throws IOException {
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ "<m:r><w:br/><m:t>x</m:t></m:r></m:oMath></w:p>"));
assertThrows(MathUnsupportedException.class, () -> MathModel.build(math, false));
}
// ------------------------------------------------------------------
// Unsupported и безопасная сеть
// ------------------------------------------------------------------
/** Неизвестный math-элемент — {@link MathUnsupportedException} (не падение PDF). */
@Test
void unsupportedElement_throws() {
CTOMath math = new CTOMath();
math.getEGOMathElements().add(new JAXBElement<>(
new QName(M_NS, "fooBar"), String.class, "any"));
MathUnsupportedException e = assertThrows(MathUnsupportedException.class,
() -> MathModel.build(math, false));
assertTrue(e.getMessage().contains("fooBar"), e.getMessage());
}
// ------------------------------------------------------------------
// Охват всех поддерживаемых конструкций (метки веток диспетчера)
// ------------------------------------------------------------------
/** Конструкция разобрана и отрисована (с чернилами), ширина ненулевая. */
private static void assertRendered(String inlineMath) throws IOException {
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ inlineMath + "</m:oMath></w:p>"));
MathModel.Box box = MathModel.build(math, false);
MathRenderer.MathImage img = MathRenderer.render(box);
assertNotNull(img.image(), "нет растера: " + inlineMath);
assertTrue(hasInk(img.image()), "растр без чернил: " + inlineMath);
}
/** Скобки: свой набор символов, разнеситель, пустые скобки, рост под контентом. */
@Test
void delimiters_bracketsSeparatorsGrowth() throws IOException {
assertRendered("<m:d><m:dPr><m:begChr m:val=\"[\"/><m:endChr m:val=\"]\"/>"
+ "<m:sepChr m:val=\"/\"/></m:dPr>"
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e>"
+ "<m:e><m:r><m:t>b</m:t></m:r></m:e></m:d>");
assertRendered("<m:d><m:dPr><m:begChr m:val=\"\"/><m:endChr m:val=\"\"/></m:dPr>"
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:d>");
// высокая дробь внутри — глиф скобки растягивается (k > 1)
assertRendered("<m:d><m:e>" + FRAC + "</m:e></m:d>");
}
/** Радикал: со степенью, без степени (degHide), под корнем — дробь (растяжение). */
@Test
void radicals_degreeDegHideTallContent() throws IOException {
assertRendered("<m:rad><m:deg><m:r><m:t>3</m:t></m:r></m:deg>"
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:rad>");
assertRendered("<m:rad><m:radPr><m:degHide m:val=\"on\"/></m:radPr><m:deg/>"
+ "<m:e>" + FRAC + "</m:e></m:rad>");
}
/** N-арный оператор: пределы над/под, subSup-форма, subHide/supHide, свой символ. */
@Test
void nary_limitsFormsHidingChar() throws IOException {
assertRendered("<m:nary><m:naryPr><m:chr m:val=\"∫\"/>"
+ "<m:limLoc m:val=\"undOvr\"/><m:subHide m:val=\"on\"/></m:naryPr>"
+ "<m:sub/><m:sup><m:r><m:t>∞</m:t></m:r></m:sup>"
+ "<m:e><m:r><m:t>f</m:t></m:r></m:e></m:nary>");
assertRendered("<m:nary><m:naryPr><m:limLoc m:val=\"subSup\"/></m:naryPr>"
+ "<m:sub><m:r><m:t>i</m:t></m:r></m:sub>"
+ "<m:sup><m:r><m:t>n</m:t></m:r></m:sup>"
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e></m:nary>");
assertRendered("<m:nary><m:naryPr><m:supHide m:val=\"on\"/></m:naryPr>"
+ "<m:sub><m:r><m:t>1</m:t></m:r></m:sub><m:sup/>"
+ "<m:e><m:r><m:t>u</m:t></m:r></m:e></m:nary>");
}
/** Функция и пределы limLow/limUpp. */
@Test
void funcAndLimits_render() throws IOException {
assertRendered("<m:func><m:fName><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr>"
+ "<m:t>sin</m:t></m:r></m:fName>"
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:func>");
assertRendered("<m:limLow><m:e><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr>"
+ "<m:t>lim</m:t></m:r></m:e>"
+ "<m:lim><m:r><m:t>x→0</m:t></m:r></m:lim></m:limLow>");
assertRendered("<m:limUpp><m:e><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr>"
+ "<m:t>max</m:t></m:r></m:e>"
+ "<m:lim><m:r><m:t>S</m:t></m:r></m:lim></m:limUpp>");
}
/** Черта сверху/снизу, акцент (символ по умолчанию и явный). */
@Test
void barAndAccent_render() throws IOException {
assertRendered("<m:bar><m:e><m:r><m:t>x</m:t></m:r></m:e></m:bar>");
assertRendered("<m:bar><m:barPr><m:pos m:val=\"bot\"/></m:barPr>"
+ "<m:e><m:r><m:t>y</m:t></m:r></m:e></m:bar>");
assertRendered("<m:acc><m:e><m:r><m:t>a</m:t></m:r></m:e></m:acc>");
assertRendered("<m:acc><m:accPr><m:chr m:val=\"~\"/></m:accPr>"
+ "<m:e><m:r><m:t>b</m:t></m:r></m:e></m:acc>");
}
/** Групповая скобка: низ/верх, дефолтный ⏞ и глиф вне бандла (fits=false). */
@Test
void groupChr_positionsAndGlyphFallback() throws IOException {
assertRendered("<m:groupChr><m:groupChrPr><m:chr m:val=\"_\"/>"
+ "<m:pos m:val=\"bot\"/></m:groupChrPr>"
+ "<m:e><m:r><m:t>abc</m:t></m:r></m:e></m:groupChr>");
assertRendered("<m:groupChr><m:groupChrPr><m:chr m:val=\"﹏\"/></m:groupChrPr>"
+ "<m:e><m:r><m:t>def</m:t></m:r></m:e></m:groupChr>");
assertRendered("<m:groupChr><m:e><m:r><m:t>ghi</m:t></m:r></m:e></m:groupChr>");
}
/** Матрица (сетка), пустая матрица, eqArr. */
@Test
void matrixAndEqArr_render() throws IOException {
CTOMath matrix = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ "<m:m><m:mr><m:e><m:r><m:t>1</m:t></m:r></m:e>"
+ "<m:e><m:r><m:t>2</m:t></m:r></m:e></m:mr>"
+ "<m:mr><m:e><m:r><m:t>3</m:t></m:r></m:e>"
+ "<m:e><m:r><m:t>4</m:t></m:r></m:e></m:mr></m:m></m:oMath></w:p>"));
MathModel.Box grid = MathModel.build(matrix, false);
MathRenderer.MathImage img = MathRenderer.render(grid);
assertTrue(grid.width > 0 && hasInk(img.image()), "матрица не отрисована");
CTOMath emptyMatrix = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ "<m:m/></m:oMath></w:p>"));
assertEquals(0, MathModel.build(emptyMatrix, false).width, 0.0001,
"пустая матрица обязана иметь нулевую ширину");
assertRendered("<m:eqArr><m:e><m:r><m:t>a</m:t></m:r></m:e>"
+ "<m:e><m:r><m:t>b</m:t></m:r></m:e></m:eqArr>");
}
/** m:box: контент боксируется без рамки. */
@Test
void box_rendersContent() throws IOException {
assertRendered("<m:box><m:e><m:r><m:t>bb</m:t></m:r></m:e></m:box>");
}
/** m:phant: невидим, но место занимает; {@code show=on} — обычный контент. */
@Test
void phantom_invisibleSpacingShowVisible() throws IOException {
CTOMath phant = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ "<m:r><m:t>x</m:t></m:r>"
+ "<m:phant><m:e><m:r><m:t>WWWWWWWWWW</m:t></m:r></m:e></m:phant>"
+ "</m:oMath></w:p>"));
MathModel.Box with = MathModel.build(phant, false);
CTOMath bare = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ "<m:r><m:t>x</m:t></m:r></m:oMath></w:p>"));
MathModel.Box without = MathModel.build(bare, false);
assertTrue(with.width > without.width,
"phant не занял место: " + with.width + " <= " + without.width);
MathRenderer.MathImage img = MathRenderer.render(with);
assertNotNull(img.image(), "phant не обязан падать");
CTOMath shown = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ "<m:phant><m:phantPr><m:show m:val=\"on\"/></m:phantPr>"
+ "<m:e><m:r><m:t>WWWWWWWWWW</m:t></m:r></m:e></m:phant></m:oMath></w:p>"));
assertTrue(hasInk(MathRenderer.render(MathModel.build(shown, false)).image()),
"show=on обязан рисовать содержимое");
}
/** Типы дроби: bar явный, skw/lin/noBar — через слэш. */
@Test
void fractionTypes_render() throws IOException {
for (String type : List.of("bar", "skw", "lin", "noBar")) {
assertRendered("<m:f><m:fPr><m:type m:val=\"" + type + "\"/></m:fPr>"
+ "<m:num><m:r><m:t>n</m:t></m:r></m:num>"
+ "<m:den><m:r><m:t>d</m:t></m:r></m:den></m:f>");
}
}
/** display-режим: дефолт дроби — bar, дефолт nary — пределы над/под. */
@Test
void displayMode_defaultsBarFractionAndNaryLimits() throws IOException {
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ FRAC + "<m:nary><m:sub><m:r><m:t>1</m:t></m:r></m:sub><m:sup/>"
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e></m:nary></m:oMath></w:p>"));
MathModel.Box box = MathModel.build(math, true);
assertTrue(box.width > 0 && box.ascent > 0 && box.descent > 0);
assertTrue(hasInk(MathRenderer.render(box).image()), "display-формула без чернил");
}
/** sPre / sSubSup / sSub. */
@Test
void scriptForms_render() throws IOException {
assertRendered("<m:sPre><m:e><m:r><m:t>B</m:t></m:r></m:e>"
+ "<m:sub><m:r><m:t>i</m:t></m:r></m:sub>"
+ "<m:sup><m:r><m:t>n</m:t></m:r></m:sup></m:sPre>");
assertRendered("<m:sSubSup><m:e><m:r><m:t>x</m:t></m:r></m:e>"
+ "<m:sub><m:r><m:t>i</m:t></m:r></m:sub>"
+ "<m:sup><m:r><m:t>2</m:t></m:r></m:sup></m:sSubSup>");
assertRendered("<m:sSub><m:e><m:r><m:t>y</m:t></m:r></m:e>"
+ "<m:sub><m:r><m:t>j</m:t></m:r></m:sub></m:sSub>");
}
/** Начертания и оформление рана: sty=b/i/bi, цвет, кегль, переменная-кириллица. */
@Test
void runStyles_render() throws IOException {
assertRendered("<m:r><m:rPr><m:sty m:val=\"b\"/></m:rPr>"
+ "<m:t>B</m:t></m:r>");
assertRendered("<m:r><m:rPr><m:sty m:val=\"i\"/></m:rPr>"
+ "<m:t>i</m:t></m:r>");
assertRendered("<m:r><m:rPr><m:sty m:val=\"bi\"/></m:rPr>"
+ "<w:rPr xmlns:w=\"" + W_NS + "\"><w:sz w:val=\"32\"/>"
+ "<w:color w:val=\"FF0000\"/></w:rPr>"
+ "<m:t>Q</m:t></m:r>");
assertRendered("<m:r><m:t>абв</m:t></m:r>");
}
/** Перенос внутри math-рана — unsupported (текстовая деградация на интеграции). */
@Test
void runWithBreak_unsupported() throws IOException {
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
+ "<m:r><m:t>a</m:t><w:br xmlns:w=\"" + W_NS + "\"/><m:t>b</m:t></m:r>"
+ "</m:oMath></w:p>"));
assertThrows(MathUnsupportedException.class, () -> MathModel.build(math, false));
}
/** Контент-узел не JAXBElement — unsupported (защита диспетчера). */
@Test
void rawObjectContent_unsupported() {
CTOMath math = new CTOMath();
math.getEGOMathElements().add("не узел");
assertThrows(MathUnsupportedException.class, () -> MathModel.build(math, false));
}
/**
* Текст извлекается из произвольного каркаса (в т.ч. неизвестных узлов):
* docx4j при unmarshal неизвестный m:*-элемент теряет, поэтому «сеть»
* проверяется синтетическим деревом — та же форма, что оставляет
* байтовый скан перед flatten.
*/
@Test
void unsupportedElement_textStillCollects() {
CTOMath math = new CTOMath();
org.docx4j.math.CTText t = new org.docx4j.math.CTText();
t.setValue("СЕТЬ");
math.getEGOMathElements().add(new JAXBElement<>(
new QName(M_NS, "fooBar"), Object.class, t));
assertEquals("СЕТЬ", MathModel.mathText(math));
}
// ------------------------------------------------------------------
// Каркас
// ------------------------------------------------------------------
/** docx с телом, содержащим формулу; оMath ищется в дереве после загрузки. */
private static byte[] mathDocx(String bodyXml) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
try (ZipOutputStream zos = new ZipOutputStream(out)) {
putZip(zos, "[Content_Types].xml",
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+ "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">"
+ "<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>"
+ "<Default Extension=\"xml\" ContentType=\"application/xml\"/>"
+ "<Override PartName=\"/word/document.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\"/>"
+ "</Types>");
putZip(zos, "_rels/.rels",
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+ "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">"
+ "<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"word/document.xml\"/>"
+ "</Relationships>");
putZip(zos, "word/document.xml",
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+ "<w:document xmlns:w=\"" + W_NS + "\"><w:body>"
+ bodyXml
+ "<w:sectPr><w:pgSz w:w=\"11906\" w:h=\"16838\"/></w:sectPr>"
+ "</w:body></w:document>");
}
return out.toByteArray();
}
private static void putZip(ZipOutputStream zos, String name, String xml)
throws IOException {
zos.putNextEntry(new ZipEntry(name));
zos.write(xml.getBytes(StandardCharsets.UTF_8));
zos.closeEntry();
}
/** Первый {@code m:oMath} дерева документа (формулы лежат в content-списках). */
private static CTOMath firstMath(byte[] docx) throws IOException {
try {
WordprocessingMLPackage pkg =
WordprocessingMLPackage.load(new ByteArrayInputStream(docx));
CTOMath found = findMath(
pkg.getMainDocumentPart().getJaxbElement().getBody().getContent());
assertNotNull(found, "oMath не найден в дереве docx4j");
return found;
} catch (org.docx4j.openpackaging.exceptions.Docx4JException e) {
throw new IOException(e);
}
}
private static CTOMath findMath(List<?> content) {
for (Object o : content) {
Object v = o instanceof JAXBElement<?> el ? el.getValue() : o;
if (v instanceof CTOMath m) {
return m;
}
if (v instanceof org.docx4j.wml.Body b) {
CTOMath m = findMath(b.getContent());
if (m != null) {
return m;
}
}
if (v instanceof org.docx4j.wml.P p) {
CTOMath m = findMath(p.getContent());
if (m != null) {
return m;
}
}
}
return null;
}
/** Есть ли в ARGB-растре непрозрачный пиксель. */
private static boolean hasInk(java.awt.image.BufferedImage img) {
for (int y = 0; y < img.getHeight(); y++) {
for (int x = 0; x < img.getWidth(); x++) {
if ((img.getRGB(x, y) >>> 24) > 0) {
return true;
}
}
}
return false;
}
}