Валидатор: лимиты 5 МиБ и 100 страниц, отказ до рендера и без артефактов

- WordPdfValidator (новый): MAX_INPUT_BYTES/MAX_PAGES, три нижние оценки
  страниц (кэш app.xml недостоверен — реальный кейс <Pages>1</Pages> при
  110 маркерах lastRenderedPageBreak); lightweight zip/StAX-путь.
- convert(Path,Path): неполный PDF удаляется при отказе, но только если
  поток вывода реально открылся (чужой read-only файл не стирается);
  checkPageCount внутри try — finally чистит temp-файлы шрифтов.
- lightweight: continuous-секции не считаются страницами; w:type —
  дочерний элемент, классификация на закрытии sectPr; мёртвый
  атрибутный перегруз startsNewPage удалён.
- Фикстуры too-many-pages.docx (151 страница) и stale-cache.docx
  (кэш 1 при 110 маркерах) + регрессии tooManyPages,
  staleCachePageCountRejectedBeforeRender, inputTooLarge,
  oversizedInputReturnsError, pageCount_continuousSectionsNotCountedLightweight.
- SampleDocxGenerator: точный поиск <w:t (не матчить <w:tbl/<w:tc),
  константа STALE_CACHE_UNMARKED_RUNS вместо литерала.
- AGENTS.md переписан; .gitignore += /diff/ и /word-export.*.

mvn clean verify: 95/95; fat-jar проверен java -jar (код 0/2, артефактов нет).
This commit is contained in:
Pjandro
2026-10-13 15:29:23 +00:00
parent ae31f27a27
commit aec4dbffe7
18 changed files with 1264 additions and 76 deletions
@@ -18,10 +18,10 @@ import ru.pjandro.wordpdf.internal.FopFallbackFonts;
import ru.pjandro.wordpdf.internal.SymbolFontNormalizer;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Locale;
/**
* Конвертер docx -> PDF на базе docx4j + Apache FOP
@@ -56,10 +56,12 @@ public final class WordPdfConverter {
*
* @param docxIn входной .docx
* @return путь к созданному PDF
* @throws ConversionException при ошибке (не .docx, файл не найден и т.п.)
* @throws ConversionException при ошибке (не .docx, файл не найден,
* размер больше {@link WordPdfValidator#MAX_INPUT_BYTES},
* результат длиннее {@link WordPdfValidator#MAX_PAGES} страниц и т.п.)
*/
public static Path convert(Path docxIn) throws ConversionException {
validateInput(docxIn);
WordPdfValidator.checkInput(docxIn);
String name = docxIn.getFileName().toString();
int dot = name.lastIndexOf('.');
String base = dot > 0 ? name.substring(0, dot) : name;
@@ -72,17 +74,38 @@ public final class WordPdfConverter {
* Конвертирует {@code docxIn} в {@code pdfOut}.
* Родительские каталоги {@code pdfOut} при необходимости создаются.
*
* <p>Число страниц проверяется по самому .docx (см.
* {@link WordPdfValidator#checkPageCount}) до рендеринга — при
* превышении лимита PDF не создаётся.
*
* @throws ConversionException при ошибке
*/
public static void convert(Path docxIn, Path pdfOut) throws ConversionException {
validateInput(docxIn);
WordPdfValidator.checkInput(docxIn);
try {
Path parent = pdfOut.toAbsolutePath().getParent();
if (parent != null) {
Files.createDirectories(parent);
}
boolean opened = false;
try (OutputStream os = Files.newOutputStream(pdfOut)) {
opened = true;
convertToStream(docxIn, os);
} catch (Exception e) {
// валидация числа страниц срабатывает уже внутри
// convertToStream — пустой/неполный PDF убирать, чтобы
// отказ не оставлял артефакт рядом со входом. Удаляем
// только если поток реально открылся: при неудачном
// открытии (read-only/locked цель) ничего не писали и
// чужой файл трогать нельзя
if (opened) {
try {
Files.deleteIfExists(pdfOut);
} catch (IOException ignored) {
// вторичная ошибка не должна затенять основную
}
}
throw e;
}
} catch (ConversionException e) {
throw e;
@@ -123,6 +146,12 @@ public final class WordPdfConverter {
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
new ByteArrayInputStream(docxBytes));
try {
// 2.5 Проверка числа страниц по самому .docx: кэш Word
// (docProps/app.xml <Pages>) или нижняя оценка по явным
// разрывам. Делается до рендера, чтобы не тратить время на
// заведомо длинный документ; внутри try — чтобы и на отказе
// отработал finally с чисткой temp-файлов встроенных шрифтов.
WordPdfValidator.checkPageCount(pkg);
// 3. Привязка маппера: docx4j сопоставляет шрифты документа
// с физическими TTF (учитывая и шрифты, встроенные в docx)
pkg.setFontMapper(mapper);
@@ -158,21 +187,6 @@ public final class WordPdfConverter {
}
}
/** Проверяет входной файл: существует, это .docx (не .doc). */
private static void validateInput(Path docxIn) throws ConversionException {
if (docxIn == null) {
throw new ConversionException("Не указан входной файл");
}
if (!Files.isRegularFile(docxIn)) {
throw new ConversionException("Файл не найден: " + docxIn);
}
String name = docxIn.getFileName().toString().toLowerCase(Locale.ROOT);
if (!name.endsWith(".docx")) {
throw new ConversionException(
"Поддерживается только .docx (без .doc): " + docxIn);
}
}
/** Имя файла без расширения (для PDF-заголовка). */
private static String baseName(Path p) {
String name = p.getFileName().toString();
@@ -0,0 +1,573 @@
package ru.pjandro.wordpdf;
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
import org.docx4j.wml.Br;
import org.docx4j.wml.ContentAccessor;
import org.docx4j.wml.P;
import org.docx4j.wml.R;
import org.docx4j.wml.SectPr;
import org.docx4j.wml.STBrType;
import jakarta.xml.bind.JAXBElement;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
import java.util.Locale;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
/**
* Валидатор ограничений на входной .docx:
* размер файла и число страниц.
*
* <p>Конвертер {@link WordPdfConverter} вызывает валидатор автоматически,
* но им можно пользоваться и напрямую — например, проверить байты
* документа, полученного из сети или БД, до того, как сохранять во временный
* файл и вызывать {@code convert}.
*
* <p>Лимиты:
* <ul>
* <li>{@link #MAX_INPUT_BYTES} — максимальный размер входного .docx (5 MiB);</li>
* <li>{@link #MAX_PAGES} — максимально допустимое число страниц (100).</li>
* </ul>
*
* <p>Число страниц берётся из самого .docx как максимум трёх нижних
* оценок: кэша Word в {@code docProps/app.xml} ({@code <Pages>}),
* явных разрывов страниц ({@code w:br type="page"},
* {@code w:pageBreakBefore}, межсекционные {@code w:sectPr}) и маркеров
* {@code w:lastRenderedPageBreak} — границ страниц, которые Word записал
* при последнем рендере. Кэш сам по себе недостоверен: Word может
* сохранить {@code <Pages>1</Pages>} в документе на 110 страниц
* (регрессия — фикстура {@code samples/stale-cache.docx}).
*
* <p>Проверка делается <b>до</b> рендера — это позволяет отсекать слишком
* длинные документы, не тратя время на конвертацию.
*
* <p>Все ошибки — {@link ConversionException}.
*/
public final class WordPdfValidator {
/** 5 MiB = 5 × 1024 × 1024. */
public static final long MAX_INPUT_BYTES = 5L * 1024 * 1024;
/** Документ длиннее — ошибка. */
public static final int MAX_PAGES = 100;
private WordPdfValidator() {
}
/**
* Проверяет входной файл: существует, это .docx, размер не превышает
* {@link #MAX_INPUT_BYTES}.
*
* @throws ConversionException при любом нарушении
*/
public static void checkInput(Path docxIn) throws ConversionException {
if (docxIn == null) {
throw new ConversionException("Не указан входной файл");
}
if (!Files.isRegularFile(docxIn)) {
throw new ConversionException("Файл не найден: " + docxIn);
}
String name = docxIn.getFileName().toString().toLowerCase(Locale.ROOT);
if (!name.endsWith(".docx")) {
throw new ConversionException(
"Поддерживается только .docx (без .doc): " + docxIn);
}
long size;
try {
size = Files.size(docxIn);
} catch (IOException e) {
throw new ConversionException("Не удалось прочитать размер файла: " + docxIn, e);
}
if (size > MAX_INPUT_BYTES) {
throw new ConversionException("Файл больше 5 МБ: " + size
+ " байт > " + MAX_INPUT_BYTES + " байт (" + docxIn + ")");
}
}
/**
* Проверяет размер байтов входа (для документа, полученного из сети/БД).
*
* @throws ConversionException при {@code null} или превышении лимита
*/
public static void checkInput(byte[] docxBytes) throws ConversionException {
if (docxBytes == null) {
throw new ConversionException("Не указаны байты входного файла");
}
if (docxBytes.length > MAX_INPUT_BYTES) {
throw new ConversionException("Файл больше 5 МБ: " + docxBytes.length
+ " байт > " + MAX_INPUT_BYTES + " байт");
}
}
/**
* Считает страницы .docx и проверяет лимит.
*
* @throws ConversionException при ошибке загрузки или превышении {@link #MAX_PAGES}
*/
public static void checkPageCount(Path docxIn) throws ConversionException {
if (docxIn == null) {
throw new ConversionException("Не указан путь к .docx");
}
WordprocessingMLPackage pkg;
try {
pkg = WordprocessingMLPackage.load(docxIn.toFile());
} catch (Exception e) {
throw new ConversionException("Не удалось загрузить .docx: " + docxIn, e);
}
checkPageCount(pkg);
}
/**
* Проверяет число страниц без загрузки документа в docx4j: .docx
* читается как zip напрямую (StAX по {@code word/document.xml},
* всем {@code word/header*.xml}, {@code word/footer*.xml} и кэшу
* {@code docProps/app.xml}). Дешёвый путь для проверки байтов из
* сети/БД до любой работы с библиотекой.
*
* <p>Оценка согласована с {@link #checkPageCount(WordprocessingMLPackage)}
* по всем источникам; на границе лимита оба пути дают одинаковый ответ
* (регрессия — {@code checkPageCountLightweight_agreesWithJaxbPath},
* включая 99/100/101 разрывов). Lightweight-путь дополнительно считает
* разрывы в колонтитулах — он консервативнее, расхождение возможно
* только в сторону завышения.
*
* @throws ConversionException при {@code null}, битом zip или превышении {@link #MAX_PAGES}
*/
public static void checkPageCountLightweight(Path docxIn) throws ConversionException {
if (docxIn == null) {
throw new ConversionException("Не указан путь к .docx");
}
if (!Files.isRegularFile(docxIn)) {
throw new ConversionException("Файл не найден: " + docxIn);
}
int pages;
try (ZipFile zip = new ZipFile(docxIn.toFile())) {
List<String> headerFooter = new ArrayList<>();
var entries = zip.entries();
while (entries.hasMoreElements()) {
String n = entries.nextElement().getName();
if (isHeaderFooterPart(n)) {
headerFooter.add(n);
}
}
pages = pageCountOfZip(name -> {
ZipEntry e = zip.getEntry(name);
return e == null ? null : zip.getInputStream(e);
}, headerFooter);
} catch (IOException | RuntimeException e) {
throw new ConversionException("Не удалось разобрать .docx: " + docxIn, e);
}
if (pages > MAX_PAGES) {
throw new ConversionException("Документ длиннее " + MAX_PAGES
+ " страниц: получено не менее " + pages);
}
}
/**
* То же, что {@link #checkPageCountLightweight(Path)}, для байтов .docx.
*
* @throws ConversionException при {@code null}, битом zip или превышении лимита
*/
public static void checkPageCountLightweight(byte[] docxBytes) throws ConversionException {
if (docxBytes == null) {
throw new ConversionException("Не указаны байты входного .docx");
}
int pages;
try (ZipInputStream zip = new ZipInputStream(new ByteArrayInputStream(docxBytes))) {
java.util.Map<String, byte[]> parts = new java.util.HashMap<>();
List<String> headerFooter = new ArrayList<>();
ZipEntry entry;
while ((entry = zip.getNextEntry()) != null) {
String n = entry.getName();
if (n.equals("docProps/app.xml") || n.equals("word/document.xml")
|| isHeaderFooterPart(n)) {
parts.put(n, zip.readAllBytes());
if (isHeaderFooterPart(n)) {
headerFooter.add(n);
}
}
}
pages = pageCountOfZip(name -> {
byte[] b = parts.get(name);
return b == null ? null : new ByteArrayInputStream(b);
}, headerFooter);
} catch (IOException | RuntimeException e) {
throw new ConversionException("Не удалось разобрать байты .docx", e);
}
if (pages > MAX_PAGES) {
throw new ConversionException("Документ длиннее " + MAX_PAGES
+ " страниц: получено не менее " + pages);
}
}
/**
* Считает страницы .docx в байтах и проверяет лимит.
*
* @throws ConversionException при {@code null}, ошибке загрузки или превышении лимита
*/
public static void checkPageCount(byte[] docxBytes) throws ConversionException {
if (docxBytes == null) {
throw new ConversionException("Не указаны байты входного .docx");
}
WordprocessingMLPackage pkg;
try {
pkg = WordprocessingMLPackage.load(new ByteArrayInputStream(docxBytes));
} catch (Exception e) {
throw new ConversionException("Не удалось разобрать байты .docx", e);
}
checkPageCount(pkg);
}
/**
* Считает страницы уже загруженного .docx и проверяет лимит.
*
* <p>Число страниц — максимум трёх нижних оценок:
* <ol>
* <li>Кэш Word в {@code docProps/app.xml} ({@code <Pages>}).
* Сам по себе недостоверен: Word может сохранить устаревшее
* значение (в регрессной фикстуре {@code stale-cache.docx}
* кэш равен 1 при 110 границах страниц).</li>
* <li>Явные разрывы: {@code w:br[@w:type='page']},
* {@code w:pageBreakBefore} и {@code w:sectPr} прямо в
* {@code w:body}. Абзацы ищутся не только прямо в {@code w:body},
* но и внутри таблиц, контентных контролов {@code w:sdt}
* (Word держит нумерацию именно в контентном контроле) и
* прочего содержимого, реализующего {@link ContentAccessor}.</li>
* <li>Маркеры {@code w:lastRenderedPageBreak} — границы страниц,
* которые Word записал при последнем рендере. Единственный
* источник оценки для документов без явных разрывов, порванных
* по заполнению.</li>
* </ol>
*
* <p>Оценка остаётся нижней: документ без явных разрывов и без
* маркеров (никогда не открывался в Word) оценивается в 1 страницу
* независимо от фактической длины — такие документы лимит не отсекают.
*
* @throws ConversionException при превышении {@link #MAX_PAGES}
*/
public static void checkPageCount(WordprocessingMLPackage pkg) throws ConversionException {
if (pkg == null) {
throw new ConversionException("Не указан загруженный .docx");
}
int pages = pageCountOf(pkg);
if (pages > MAX_PAGES) {
throw new ConversionException("Документ длиннее " + MAX_PAGES
+ " страниц: получено не менее " + pages);
}
}
/**
* Возвращает число страниц: максимум кэша {@code <Pages>}, оценки по
* явным разрывам и оценки по {@code w:lastRenderedPageBreak}.
* Виден только из тестов и пакета.
*/
static int pageCountOf(WordprocessingMLPackage pkg) {
int cached = 0;
try {
if (pkg.getDocPropsExtendedPart() != null) {
org.docx4j.docProps.extended.Properties ext =
pkg.getDocPropsExtendedPart().getContents();
if (ext != null && ext.getPages() != null && ext.getPages() > 0) {
cached = ext.getPages();
}
}
} catch (Exception ignored) {
// docPropsExtended может быть не полностью инициализирован —
// тогда остаётся оценка по разрывам.
}
var body = pkg.getMainDocumentPart().getJaxbElement().getBody();
var content = body.getContent();
int explicit = 1; // сам документ — минимум одна страница
for (Object child : content) {
// В JAXB-модели в body.getContent() лежат только межсекционные
// sectPr; финальная секция — в body.getSectPr(), её здесь нет.
if (child instanceof SectPr sect && startsNewPage(sect)) {
explicit++;
}
}
explicit += walkForPageBreaks(content);
int lastRendered = countLastRendered(content);
return Math.max(Math.max(cached, explicit), lastRendered + 1);
}
/**
* Обход содержимого на явные разрывы: абзацы ищутся рекурсивно —
* прямо в {@code w:body}, в ячейках таблиц, в контентных контролах
* {@code w:sdt} и прочем содержимом, реализующем {@link ContentAccessor}.
* Элементы модели приходят и напрямую, и обёрнутыми в
* {@link JAXBElement} (например {@code w:tbl} в {@code w:body}) —
* обёртка раскрывается через {@link #unwrap}.
* Считаются {@code w:br type="page"} и {@code pageBreakBefore}
* (по одному на абзац), как и в lightweight-пути.
*/
private static int walkForPageBreaks(List<?> content) {
int count = 0;
for (Object raw : content) {
Object item = unwrap(raw);
if (item instanceof P p) {
if (p.getPPr() != null
&& p.getPPr().getPageBreakBefore() != null
&& p.getPPr().getPageBreakBefore().isVal()) {
count++;
}
for (Object runChild : p.getContent()) {
if (unwrap(runChild) instanceof org.docx4j.wml.R r) {
for (Object innerRaw : r.getContent()) {
if (unwrap(innerRaw) instanceof Br br
&& br.getType() == STBrType.PAGE) {
count++;
}
}
}
}
} else if (item instanceof ContentAccessor ca) {
// w:tbl / w:tr / w:tc / w:sdt / w:sdtContent и т.п.
count += walkForPageBreaks(ca.getContent());
}
}
return count;
}
/** Подсчёт маркеров {@code w:lastRenderedPageBreak} в содержимом. */
private static int countLastRendered(List<?> content) {
int count = 0;
for (Object raw : content) {
Object item = unwrap(raw);
if (item instanceof R.LastRenderedPageBreak) {
count++;
} else if (item instanceof ContentAccessor ca) {
count += countLastRendered(ca.getContent());
}
}
return count;
}
/** Раскрывает обёртку {@link JAXBElement} (docx4j так отдаёт tbl и часть содержимого). */
private static Object unwrap(Object item) {
return item instanceof JAXBElement<?> je ? je.getValue() : item;
}
/** Секция, начинающая новую страницу (continuous — нет). */
private static boolean startsNewPage(SectPr sect) {
return sect.getType() == null
|| sect.getType().getVal() == null
|| !sect.getType().getVal().equals("continuous");
}
/** Поставщик потока по имени части zip; null — части нет. */
private interface PartStream {
InputStream open(String name) throws IOException;
}
/** {@code word/headerN.xml} / {@code word/footerN.xml} (не .rels). */
private static boolean isHeaderFooterPart(String name) {
return (name.startsWith("word/header") || name.startsWith("word/footer"))
&& name.endsWith(".xml");
}
/**
* Лёгкий расчёт числа страниц прямо по zip-пакету .docx, без docx4j.
* Та же логика, что у {@link #pageCountOf(WordprocessingMLPackage)}:
* максимум кэша {@code docProps/app.xml <Pages>}, явных разрывов и
* {@code w:lastRenderedPageBreak}. Считаются все колонтитулы
* ({@code word/header*.xml}, {@code word/footer*.xml}) — там Word тоже
* держит {@code w:br type="page"}.
*/
private static int pageCountOfZip(PartStream parts, List<String> headerFooterParts)
throws IOException {
int cached = cachedPageCount(parts.open("docProps/app.xml"));
BreakScan scan = scanDocument(parts.open("word/document.xml"));
int explicit = 1 + scan.breaks(); // сам документ — минимум одна страница
for (String part : headerFooterParts) {
explicit += countBreaksInFlat(parts.open(part));
}
return Math.max(Math.max(cached, explicit), scan.lastRendered() + 1);
}
/** Результат разбора word/document.xml: явные разрывы и маркеры. */
private record BreakScan(int breaks, int lastRendered) {
}
/** Кэш Word &lt;Pages&gt; из docProps/app.xml; 0 — части/значения нет. */
private static int cachedPageCount(InputStream in) throws IOException {
if (in == null) {
return 0;
}
try {
XMLStreamReader xr = newSecureReader().createXMLStreamReader(in);
while (xr.hasNext()) {
if (xr.next() == XMLStreamReader.START_ELEMENT
&& xr.getLocalName().equals("Pages")) {
String text = xr.getElementText().trim();
return Math.max(0, Integer.parseInt(text));
}
}
return 0;
} catch (XMLStreamException | NumberFormatException e) {
return 0;
} finally {
in.close();
}
}
/**
* Нижняя оценка по {@code word/document.xml}: {@code w:br type="page"},
* {@code w:pageBreakBefore}, {@code w:sectPr} прямо в {@code body} и
* маркеры {@code w:lastRenderedPageBreak}. Обход плоский (StAX),
* вложенность не нужна — считаем события.
*
* <p>Согласованность с JAXB-путём:
* <ul>
* <li>{@code sectPr} внутри {@code pPr} не считается: в StAX-виде
* там и финальная секция, и межсекционные — неразличимы, а
* JAXB-путь их не видит (в {@code body.getContent()} лежат только
* межсекционные). Такие документы покрываются кэшем
* {@code <Pages>} и маркерами {@code lastRenderedPageBreak};</li>
* <li>{@code sectPr} прямо в {@code body}: в StAX-виде их на один
* больше, чем в JAXB-виде (финальная секция — это JAXB
* {@code body.getSectPr()}, вне {@code getContent()}), поэтому
* последнюю не считаем, а среди остальных считаем только
* начинающие новую страницу;</li>
* <li>непрерывные секции ({@code type="continuous"}) не считаются —
* ровно как в JAXB-пути, где их отсекает {@code startsNewPage}.</li>
* </ul>
*/
private static BreakScan scanDocument(InputStream in) throws IOException {
if (in == null) {
return new BreakScan(0, 0);
}
int breaks = 0;
int lastRendered = 0;
int bodyDirectSectPr = 0;
// w:type — ДОЧЕРНИЙ элемент (<w:type w:val="continuous"/>), а не
// атрибут sectPr, поэтому body-direct секция классифицируется на
// её закрытии; последняя body-direct — финальная секция, не
// считается, так что при закрытии новой секции считаем предыдущую
boolean inBodySectPr = false;
String sectTypeVal = null;
boolean pendingNewPageSection = false;
try {
XMLStreamReader xr = newSecureReader().createXMLStreamReader(in);
// стек имён START_ELEMENT: «внутри ли w:p/w:pPr/sectPr» и
// родитель текущего элемента (для sectPr).
Deque<String> path = new ArrayDeque<>();
while (xr.hasNext()) {
int ev = xr.next();
if (ev == XMLStreamReader.START_ELEMENT) {
String name = xr.getLocalName();
String parent = path.peek();
path.push(name);
switch (name) {
case "br" -> {
if (isPageBreak(xr) && inside(path, "p")) {
breaks++;
}
}
case "lastRenderedPageBreak" -> {
if (inside(path, "p")) {
lastRendered++;
}
}
case "pageBreakBefore" -> {
if (truthy(xr) && inside(path, "pPr") && !inside(path, "sectPr")) {
breaks++;
}
}
case "sectPr" -> {
if ("body".equals(parent)) {
inBodySectPr = true;
sectTypeVal = null;
}
// sectPr внутри pPr — не считаем (StAX не
// различает финальную и межсекционные)
}
case "type" -> {
if (inBodySectPr && "sectPr".equals(parent)) {
sectTypeVal = xr.getAttributeValue(WML_NS, "val");
}
}
default -> {
}
}
} else if (ev == XMLStreamReader.END_ELEMENT) {
if ("sectPr".equals(xr.getLocalName()) && inBodySectPr) {
if (pendingNewPageSection) {
bodyDirectSectPr++;
}
pendingNewPageSection =
!"continuous".equals(sectTypeVal);
inBodySectPr = false;
}
if (!path.isEmpty()) {
path.pop();
}
}
}
} catch (XMLStreamException e) {
throw new IOException("Некорректный XML в word/document.xml", e);
} finally {
in.close();
}
// последняя body-direct секция не внесена — это финальная секция
breaks += bodyDirectSectPr;
return new BreakScan(breaks, lastRendered);
}
/** Оценка по колонтитулам: только {@code w:br type="page"} (там нет body/sectPr). */
private static int countBreaksInFlat(InputStream in) throws IOException {
if (in == null) {
return 0;
}
int count = 0;
try {
XMLStreamReader xr = newSecureReader().createXMLStreamReader(in);
while (xr.hasNext()) {
if (xr.next() == XMLStreamReader.START_ELEMENT
&& xr.getLocalName().equals("br") && isPageBreak(xr)) {
count++;
}
}
} catch (XMLStreamException e) {
throw new IOException("Некорректный XML в колонтитуле", e);
} finally {
in.close();
}
return count;
}
private static XMLInputFactory newSecureReader() {
XMLInputFactory f = XMLInputFactory.newInstance();
f.setProperty(XMLInputFactory.SUPPORT_DTD, false);
f.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
return f;
}
private static boolean isPageBreak(XMLStreamReader xr) {
return "page".equals(xr.getAttributeValue(WML_NS, "type"));
}
private static boolean truthy(XMLStreamReader xr) {
String v = xr.getAttributeValue(WML_NS, "val");
return v == null || v.equals("true") || v.equals("1") || v.equals("on");
}
private static boolean inside(Deque<String> path, String ancestor) {
return path.contains(ancestor);
}
private static final String WML_NS =
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
}
@@ -27,6 +27,7 @@ import javax.imageio.ImageIO;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
@@ -68,6 +69,8 @@ public final class SampleDocxGenerator {
symbolBullets(dir.resolve("symbol-bullets.docx"));
pageNumbers(dir.resolve("page-numbers.docx"));
exoticGlyphs(dir.resolve("exotic-glyphs.docx"));
tooManyPages(dir.resolve("too-many-pages.docx"));
staleCache(dir.resolve("stale-cache.docx"));
System.out.println("Готово: " + dir.toAbsolutePath());
}
@@ -326,6 +329,108 @@ public final class SampleDocxGenerator {
}
}
/**
* Документ длиннее лимита страниц: 150 абзацев с принудительным
* {@code w:br type="page"} → нижняя оценка по явным разрывам
* = 1 + 150 = 151 > 100. Используется как фикстура для проверки
* постраничного лимита в {@code WordPdfValidator}.
*/
private static void tooManyPages(Path out) throws Exception {
try (XWPFDocument doc = new XWPFDocument()) {
heading(doc, "Слишком много страниц", "Times New Roman");
for (int i = 1; i <= 150; i++) {
XWPFParagraph p = doc.createParagraph();
run(p, "Страница " + i, "Times New Roman", false, false);
p.createRun().addBreak(org.apache.poi.xwpf.usermodel.BreakType.PAGE);
}
save(doc, out);
}
}
/**
* Документ с устаревшим кэшем страниц — как Word сохраняет файл,
* доработанный другим редактором: 111 абзацев, разделённых маркерами
* {@code w:lastRenderedPageBreak} (110 границ страниц, то есть
* ~111 страница), и при этом в {@code docProps/app.xml} записан кэш
* {@code <Pages>1</Pages>}. Явных разрывов нет ни одного.
*
* <p>Регрессия для {@code WordPdfValidator}: кэш больше не приоритетный
* источник, оценка по маркерам (111) должна победить кэш (1) и
* документ должен быть отвергнут до рендера.
*/
private static void staleCache(Path out) throws Exception {
try (XWPFDocument doc = new XWPFDocument()) {
doc.getProperties().getExtendedProperties()
.getUnderlyingProperties().setPages(1);
heading(doc, "Устаревший кэш страниц", "Calibri");
for (int i = 1; i <= 110; i++) {
XWPFParagraph p = doc.createParagraph();
run(p, "Абзац " + i, "Calibri", false, false);
}
ByteArrayOutputStream bos = new ByteArrayOutputStream();
doc.write(bos);
insertLastRenderedMarkers(bos.toByteArray(), out);
}
}
/**
* Переупаковывает .docx, вставляя {@code w:lastRenderedPageBreak}
* перед каждым текстовым тегом {@code w:t} в {@code word/document.xml},
* кроме первых {@value #STALE_CACHE_UNMARKED_RUNS} (первый абзац
* остаётся без маркера). Тег ищется точно ({@code <w:t>} /
* {@code <w:t }): префикс {@code <w:t} — это также {@code w:tab},
* {@code w:tbl}, {@code w:tc}, маркеры в которые недопустимы по схеме
* (вне CT_R → невалидный docx). Позиция корректна по схеме CT_R:
* rPr, затем маркер, затем текст.
*/
private static void insertLastRenderedMarkers(byte[] docx, Path out) throws Exception {
final int unmarked = STALE_CACHE_UNMARKED_RUNS;
try (java.util.zip.ZipInputStream zin =
new java.util.zip.ZipInputStream(new ByteArrayInputStream(docx));
java.util.zip.ZipOutputStream zout =
new java.util.zip.ZipOutputStream(new FileOutputStream(out.toFile()))) {
java.util.zip.ZipEntry e;
while ((e = zin.getNextEntry()) != null) {
byte[] data = zin.readAllBytes();
if (e.getName().equals("word/document.xml")) {
String xml = new String(data, java.nio.charset.StandardCharsets.UTF_8);
StringBuilder sb = new StringBuilder(xml.length() + 4096);
int i = 0;
int seen = 0;
while (true) {
int at = xml.indexOf("<w:t", i);
if (at < 0) {
sb.append(xml, i, xml.length());
break;
}
sb.append(xml, i, at);
int end = at + "<w:t".length();
char next = end < xml.length() ? xml.charAt(end) : '<';
if (next != '>' && next != ' ') {
// <w:tab/<w:tbl/<w:tc/... — не текстовый тег
sb.append(xml, at, end);
i = end;
continue;
}
if (seen >= unmarked) {
sb.append("<w:lastRenderedPageBreak/>");
}
seen++;
sb.append(xml, at, end);
i = end;
}
data = sb.toString().getBytes(java.nio.charset.StandardCharsets.UTF_8);
}
zout.putNextEntry(new java.util.zip.ZipEntry(e.getName()));
zout.write(data);
zout.closeEntry();
}
}
}
/** Сколько {@code w:t} в фикстуре stale-cache остаются без маркера. */
private static final int STALE_CACHE_UNMARKED_RUNS = 1;
// ================== Вспомогательные ==================
/** Абзац-заголовок: POI 5.5 не имеет createHeading, поэтому
@@ -378,4 +378,74 @@ class WordPdfConverterTest {
assertEquals(expected, out);
assertTrue(Files.isRegularFile(out), "PDF не создан: " + out);
}
/**
* Лимит на размер входного .docx: больше 5 MiB — отказ до рендера.
* Проверяется через обе формы convert.
*/
@Test
void inputTooLarge() throws Exception {
Path tooBig = Files.createTempFile("too-big-", ".docx");
Path out = Files.createTempFile("too-big-out-", ".pdf");
try {
// Пишем чуть больше лимита (5 MiB + 1 байт)
byte[] filler = new byte[(int) WordPdfValidator.MAX_INPUT_BYTES + 1];
Files.write(tooBig, filler);
assertThrows(ConversionException.class,
() -> WordPdfConverter.convert(tooBig));
assertFalse(Files.exists(Path.of(
tooBig.toString().replaceFirst("\\.docx$", "") + ".pdf")),
"отказ по размеру не должен создавать PDF рядом со входом");
assertThrows(ConversionException.class,
() -> WordPdfConverter.convert(tooBig, out));
assertEquals(0L, Files.size(out),
"отказ по размеру — до открытия потока вывода, "
+ "выходной файл не должен быть затронут");
} finally {
Files.deleteIfExists(tooBig);
Files.deleteIfExists(out);
}
}
/**
* Лимит на число страниц: документ с 150 явными разрывами страниц
* (фикстура too-many-pages.docx, нижняя оценка 151) должен
* отвергаться до рендеринга. PDF не создаётся — в том числе пустой
* файл-артефакт от уже открытого потока вывода.
*/
@Test
void tooManyPages() throws Exception {
Path in = extractSample("too-many-pages.docx");
Path out = Files.createTempFile("too-many-out-", ".pdf");
Files.deleteIfExists(out);
ConversionException ex = assertThrows(ConversionException.class,
() -> WordPdfConverter.convert(in, out));
assertTrue(ex.getMessage().contains("100"),
"сообщение должно упоминать лимит: " + ex.getMessage());
assertFalse(Files.exists(out),
"отказ по страницам не должен оставлять PDF: " + out);
}
/**
* Документ с устаревшим кэшем {@code <Pages>1</Pages>} и 110 маркерами
* {@code w:lastRenderedPageBreak} (фикстура stale-cache.docx — модель
* реального документа пользователя «110 страниц.docx»): конвертер
* обязан отвергнуть его до рендера и не оставить PDF.
*/
@Test
void staleCachePageCountRejectedBeforeRender() throws Exception {
Path in = extractSample("stale-cache.docx");
Path out = Files.createTempFile("stale-cache-out-", ".pdf");
Files.deleteIfExists(out);
ConversionException ex = assertThrows(ConversionException.class,
() -> WordPdfConverter.convert(in, out));
assertTrue(ex.getMessage().contains("100"),
"сообщение должно упоминать лимит: " + ex.getMessage());
assertFalse(Files.exists(out),
"отказ по страницам не должен оставлять PDF: " + out);
}
}
@@ -0,0 +1,353 @@
package ru.pjandro.wordpdf;
import org.apache.poi.xwpf.usermodel.BreakType;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFTable;
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import static org.junit.jupiter.api.Assertions.*;
/**
* Юнит-тесты валидатора: размер (Path и byte[]) и число страниц
* (Path, byte[] и уже загруженный пакет).
*/
class WordPdfValidatorTest {
private static Path bigDocx(long size) throws IOException {
Path tmp = Files.createTempFile("validator-", ".docx");
Files.write(tmp, new byte[(int) size]);
return tmp;
}
private static byte[] docxWithPageBreaks(int count) throws Exception {
try (XWPFDocument doc = new XWPFDocument()) {
for (int i = 0; i < count; i++) {
XWPFParagraph p = doc.createParagraph();
p.createRun().setText("p" + i);
p.createRun().addBreak(BreakType.PAGE);
}
ByteArrayOutputStream bos = new ByteArrayOutputStream();
doc.write(bos);
return bos.toByteArray();
}
}
@Test
void checkInput_pathWithinLimit() throws IOException {
Path p = bigDocx(1024);
try {
assertDoesNotThrow(() -> WordPdfValidator.checkInput(p));
} finally {
Files.deleteIfExists(p);
}
}
@Test
void checkInput_pathOverLimit() throws IOException {
Path p = bigDocx(WordPdfValidator.MAX_INPUT_BYTES + 1);
try {
ConversionException ex = assertThrows(ConversionException.class,
() -> WordPdfValidator.checkInput(p));
assertTrue(ex.getMessage().contains("5 МБ"),
"сообщение должно упоминать лимит: " + ex.getMessage());
} finally {
Files.deleteIfExists(p);
}
}
@Test
void checkInput_pathNull() {
assertThrows(ConversionException.class,
() -> WordPdfValidator.checkInput((Path) null));
}
@Test
void checkInput_bytesWithinLimit() {
assertDoesNotThrow(() ->
WordPdfValidator.checkInput(new byte[1024]));
}
@Test
void checkInput_bytesOverLimit() {
byte[] big = new byte[(int) WordPdfValidator.MAX_INPUT_BYTES + 1];
ConversionException ex = assertThrows(ConversionException.class,
() -> WordPdfValidator.checkInput(big));
assertTrue(ex.getMessage().contains("5 МБ"),
"сообщение должно упоминать лимит: " + ex.getMessage());
}
@Test
void checkInput_bytesNull() {
assertThrows(ConversionException.class,
() -> WordPdfValidator.checkInput((byte[]) null));
}
@Test
void checkPageCount_pkgWithinLimit() throws Exception {
byte[] bytes = docxWithPageBreaks(5); // 1 + 5 = 6 страниц по оценке
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
new java.io.ByteArrayInputStream(bytes));
assertDoesNotThrow(() -> WordPdfValidator.checkPageCount(pkg));
}
@Test
void checkPageCount_pkgOverLimit() throws Exception {
byte[] bytes = docxWithPageBreaks(120); // 1 + 120 = 121
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
new java.io.ByteArrayInputStream(bytes));
ConversionException ex = assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCount(pkg));
assertTrue(ex.getMessage().contains("100"),
"сообщение должно упоминать лимит: " + ex.getMessage());
}
@Test
void checkPageCount_bytesOverLimit() throws Exception {
byte[] bytes = docxWithPageBreaks(120);
ConversionException ex = assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCount(bytes));
assertTrue(ex.getMessage().contains("100"),
"сообщение должно упоминать лимит: " + ex.getMessage());
}
@Test
void checkPageCount_bytesNull() {
assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCount((byte[]) null));
}
@Test
void checkPageCount_pkgNull() {
assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCount((WordprocessingMLPackage) null));
}
// ---- lightweight (zip/StAX, без docx4j) ----
@Test
void checkPageCountLightweight_bytesWithinLimit() throws Exception {
byte[] bytes = docxWithPageBreaks(5);
assertDoesNotThrow(() -> WordPdfValidator.checkPageCountLightweight(bytes));
}
@Test
void checkPageCountLightweight_bytesOverLimit() throws Exception {
byte[] bytes = docxWithPageBreaks(120);
ConversionException ex = assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCountLightweight(bytes));
assertTrue(ex.getMessage().contains("100"),
"сообщение должно упоминать лимит: " + ex.getMessage());
}
@Test
void checkPageCountLightweight_pathOverLimit() throws Exception {
Path tmp = Files.createTempFile("validator-lw-", ".docx");
Files.write(tmp, docxWithPageBreaks(120));
try {
ConversionException ex = assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCountLightweight(tmp));
assertTrue(ex.getMessage().contains("100"),
"сообщение должно упоминать лимит: " + ex.getMessage());
} finally {
Files.deleteIfExists(tmp);
}
}
@Test
void checkPageCountLightweight_agreesWithJaxbPath() throws Exception {
// на фикстурах без кэша Pages оба пути обязаны совпадать,
// включая границу лимита: 99 разрывов = 100 страниц (проходит),
// 100/101 = 101/102 (отказ)
for (int breaks : new int[]{0, 3, 99, 100, 101}) {
byte[] bytes = docxWithPageBreaks(breaks);
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
new java.io.ByteArrayInputStream(bytes));
int jaxb = WordPdfValidator.pageCountOf(pkg);
// lightweight-путь приватный; проверяем через границу лимита:
// 1+breaks совпадает с оценкой JAXB
assertEquals(1 + breaks, jaxb, "JAXB-оценка для " + breaks + " разрывов");
if (breaks < 100) {
assertDoesNotThrow(() -> WordPdfValidator.checkPageCountLightweight(bytes));
} else {
ConversionException ex = assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCountLightweight(bytes));
assertTrue(ex.getMessage().contains("не менее " + (1 + breaks)),
"оценка lightweight должна совпадать с JAXB: " + ex.getMessage());
}
}
}
/**
* Секция {@code type="continuous"} по OOXML новую страницу не
* начинает — lightweight-путь (zip/StAX) не обязан её считать, а
* последняя body-direct секция (финальная) не считается никогда.
* Случай A: 100 {@code nextPage} + финальная {@code continuous} —
* 101 страница, отказ (старый код считал «все минус одна» без
* учёта типа: 101−1=100 и пропускал). Случай B: 101
* {@code continuous} + финальная {@code nextPage} — 1 страница,
* проходит (старый код раздувал до 102 и отвергал). В JAXB-модели
* body-direct sectPr не видны (docx4j оставляет только финальную
* в {@code body.getSectPr()}, {@code getContent()} пуст), поэтому
* расхождение lightweight здесь — допустимое завышение.
* Регрессия — WordPdfValidator#scanDocument.
*/
@Test
void pageCount_continuousSectionsNotCountedLightweight() throws Exception {
java.util.List<String> typesA = new java.util.ArrayList<>();
for (int i = 0; i < 100; i++) {
typesA.add("nextPage");
}
typesA.add("continuous"); // финальная секция — непрерывная
byte[] overLimit = docxWithBodySections(typesA);
ConversionException exLwA = assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCountLightweight(overLimit));
assertTrue(exLwA.getMessage().contains("не менее 101"),
"оценка = 1 + 100 межсекционных nextPage: " + exLwA.getMessage());
java.util.List<String> typesB = new java.util.ArrayList<>();
for (int i = 0; i < 101; i++) {
typesB.add("continuous");
}
typesB.add("nextPage"); // финальная секция
byte[] ok = docxWithBodySections(typesB);
assertDoesNotThrow(() -> WordPdfValidator.checkPageCountLightweight(ok),
"continuous-границы не страницы");
}
/**
* docx от POI, в {@code word/document.xml} которого перед закрытием
* {@code w:body} вставлены {@code w:sectPr} прямо в {@code body} с
* указанными {@code w:type} (последняя из них — финальная секция;
* POI сам финальный sectPr не пишет).
*/
private static byte[] docxWithBodySections(java.util.List<String> types)
throws Exception {
byte[] base = docxWithPageBreaks(0);
ByteArrayOutputStream out = new ByteArrayOutputStream();
try (java.util.zip.ZipInputStream zin = new java.util.zip.ZipInputStream(
new java.io.ByteArrayInputStream(base));
java.util.zip.ZipOutputStream zout = new java.util.zip.ZipOutputStream(out)) {
java.util.zip.ZipEntry e;
while ((e = zin.getNextEntry()) != null) {
byte[] data = zin.readAllBytes();
if (e.getName().equals("word/document.xml")) {
String xml = new String(data, java.nio.charset.StandardCharsets.UTF_8);
StringBuilder sb = new StringBuilder();
for (String t : types) {
sb.append("<w:sectPr><w:type w:val=\"").append(t)
.append("\"/></w:sectPr>");
}
// POI не пишет финальный sectPr — последняя вставленная
// секция и есть финальная (в JAXB уйдёт в body.getSectPr());
// пустой body сериализуется самозакрывающимся тегом
int at = xml.indexOf("</w:body>");
if (at >= 0) {
xml = xml.substring(0, at) + sb + xml.substring(at);
} else {
at = xml.indexOf("<w:body/>");
assertTrue(at >= 0, "в document.xml нет w:body");
xml = xml.substring(0, at) + "<w:body>" + sb + "</w:body>"
+ xml.substring(at + "<w:body/>".length());
}
data = xml.getBytes(java.nio.charset.StandardCharsets.UTF_8);
}
zout.putNextEntry(new java.util.zip.ZipEntry(e.getName()));
zout.write(data);
zout.closeEntry();
}
}
return out.toByteArray();
}
// ---- устаревший кэш <Pages> ----
private static byte[] staleCacheFixture() throws Exception {
try (java.io.InputStream in = WordPdfValidatorTest.class.getClassLoader()
.getResourceAsStream("samples/stale-cache.docx")) {
assertNotNull(in, "Нет фикстуры samples/stale-cache.docx");
return in.readAllBytes();
}
}
/**
* Кэш Word {@code <Pages>1</Pages>} в документе с 110 маркерами
* {@code w:lastRenderedPageBreak}: кэш больше не приоритетный источник,
* оценка по маркерам (111) обязана победить и документ — быть
* отвергнутым. Это регрессия на реальном документе пользователя
* («110 страниц.docx»: кэш 1, маркеров 110, явных разрывов 0).
*/
@Test
void pageCount_staleCacheLosesToLastRenderedMarkers() throws Exception {
byte[] bytes = staleCacheFixture();
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
new java.io.ByteArrayInputStream(bytes));
assertEquals(111, WordPdfValidator.pageCountOf(pkg),
"оценка = max(кэш 1, разрывы 1, маркеры 110+1)");
ConversionException ex = assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCount(pkg));
assertTrue(ex.getMessage().contains("100"), ex.getMessage());
// lightweight-путь обязан согласовать тот же отказ
assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCountLightweight(bytes));
}
/**
* Явные разрывы внутри таблиц и контентных контролов тоже считаются:
* раньше обходил только прямой контент body, и документ с разрывами в
* ячейках оценивался в 1 страницу.
*/
@Test
void pageCount_breaksInsideTablesAreCounted() throws Exception {
byte[] bytes;
try (XWPFDocument doc = new XWPFDocument()) {
XWPFTable table = doc.createTable(2, 1);
for (int i = 0; i < 120; i++) {
XWPFParagraph p = table.getRow(0).getCell(0).getParagraphs().get(0);
p.createRun().setText("t" + i);
p.createRun().addBreak(BreakType.PAGE);
}
java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
doc.write(bos);
bytes = bos.toByteArray();
}
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
new java.io.ByteArrayInputStream(bytes));
assertEquals(121, WordPdfValidator.pageCountOf(pkg),
"разрывы в ячейке таблицы должны считаться");
assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCount(bytes));
assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCountLightweight(bytes));
}
@Test
void checkPageCountLightweight_bytesNull() {
assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCountLightweight((byte[]) null));
}
@Test
void checkPageCountLightweight_pathNull() {
assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCountLightweight((Path) null));
}
@Test
void checkPageCountLightweight_notAZip() throws IOException {
Path tmp = Files.createTempFile("validator-lw-bad-", ".docx");
Files.write(tmp, "not a zip at all".getBytes());
try {
assertThrows(ConversionException.class,
() -> WordPdfValidator.checkPageCountLightweight(tmp));
} finally {
Files.deleteIfExists(tmp);
}
}
}