This is an automated email from the ASF dual-hosted git repository. garydgregory pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/commons-xml.git
commit 4400a7e6588f1feb6f66f8c90a22d97d8ca2cf6d Author: Gary Gregory <[email protected]> AuthorDate: Fri Aug 28 13:19:31 2026 -0400 Rename HardeningTransformer to SecureTransformer. Local build OK. --- .../java/org/apache/commons/xml/HardeningTransformerFactory.java | 8 ++++---- .../java/org/apache/commons/xml/HardeningTransformerHandler.java | 6 +++--- src/main/java/org/apache/commons/xml/HardeningXMLFilter.java | 4 ++-- src/main/java/org/apache/commons/xml/SecureTemplates.java | 4 ++-- .../xml/{HardeningTransformer.java => SecureTransformer.java} | 4 ++-- src/test/java/org/apache/commons/xml/ShadingFootprintTest.java | 2 +- 6 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/main/java/org/apache/commons/xml/HardeningTransformerFactory.java b/src/main/java/org/apache/commons/xml/HardeningTransformerFactory.java index dc72c6f..31f1a0c 100644 --- a/src/main/java/org/apache/commons/xml/HardeningTransformerFactory.java +++ b/src/main/java/org/apache/commons/xml/HardeningTransformerFactory.java @@ -195,10 +195,10 @@ private HardeningTransformerFactory() { * <p>Three layers cooperate:</p> * <ol> * <li>{@link HardeningTransformerFactory} rewrites the Source on every entry point that compiles a stylesheet or transforms a one-shot input.</li> - * <li>{@link SecureTemplates} returns a {@link HardeningTransformer} from {@link Templates#newTransformer()} so runtime source parsing is also covered, and + * <li>{@link SecureTemplates} returns a {@link SecureTransformer} from {@link Templates#newTransformer()} so runtime source parsing is also covered, and * restores the factory's URIResolver onto the produced Transformer (which the underlying implementation typically does not propagate through * {@code Templates}).</li> - * <li>{@link HardeningTransformer} rewrites the Source on every {@link Transformer#transform(Source, javax.xml.transform.Result)} call.</li> + * <li>{@link SecureTransformer} rewrites the Source on every {@link Transformer#transform(Source, javax.xml.transform.Result)} call.</li> * </ol> * * <p>The {@link SAXTransformerFactory} extension products ride the same wrappers: {@code newTransformerHandler}/{@code newTemplatesHandler} products are @@ -376,7 +376,7 @@ public TemplatesHandler newTemplatesHandler() throws TransformerConfigurationExc public Transformer newTransformer() throws TransformerConfigurationException { // Identity transformer: still parses runtime sources, so wrap it to harden Transformer.transform(Source, Result). final Transformer transformer = delegate.newTransformer(); - return transformer == null ? null : new HardeningTransformer(transformer, getURIResolver(), emptySource, overrideDefaultParser()); + return transformer == null ? null : new SecureTransformer(transformer, getURIResolver(), emptySource, overrideDefaultParser()); } /** @@ -388,7 +388,7 @@ public Transformer newTransformer() throws TransformerConfigurationException { @Override public Transformer newTransformer(final Source source) throws TransformerConfigurationException { final Transformer transformer = delegate.newTransformer(SecureSAXParserFactory.harden(source, overrideDefaultParser())); - return transformer == null ? null : new HardeningTransformer(transformer, getURIResolver(), emptySource, overrideDefaultParser()); + return transformer == null ? null : new SecureTransformer(transformer, getURIResolver(), emptySource, overrideDefaultParser()); } @Override diff --git a/src/main/java/org/apache/commons/xml/HardeningTransformerHandler.java b/src/main/java/org/apache/commons/xml/HardeningTransformerHandler.java index 0f46759..3268b54 100644 --- a/src/main/java/org/apache/commons/xml/HardeningTransformerHandler.java +++ b/src/main/java/org/apache/commons/xml/HardeningTransformerHandler.java @@ -35,7 +35,7 @@ * * <p>The handler's input is SAX events the caller drives, so it has no inner source-parsing path of its own. What needs the floor is its transformer: the * handler runs the transformation on the object {@link TransformerHandler#getTransformer()} exposes, and not every implementation seeds that transformer with - * the factory's resolver (the stock JDK's {@code newTransformerHandler(Templates)} does not). Wrapping that transformer in a {@link HardeningTransformer} at + * the factory's resolver (the stock JDK's {@code newTransformerHandler(Templates)} does not). Wrapping that transformer in a {@link SecureTransformer} at * construction installs the floor on the live instance, so runtime {@code document()} during the handler's transform is covered, and so is a caller who pulls * the transformer out through {@code getTransformer()}.</p> */ @@ -46,7 +46,7 @@ final class HardeningTransformerHandler implements TransformerHandler { /** * Wraps the handler's LIVE transformer; constructing it installs the resolver floor that the handler's own transform then runs under. */ - private final HardeningTransformer transformer; + private final SecureTransformer transformer; /** * Constructs a new instance. @@ -60,7 +60,7 @@ final class HardeningTransformerHandler implements TransformerHandler { HardeningTransformerHandler(final TransformerHandler delegate, final URIResolver uriResolver, final Supplier<Source> emptySource, final boolean overrideDefaultParser) { this.delegate = Objects.requireNonNull(delegate, "delegate"); - this.transformer = new HardeningTransformer(delegate.getTransformer(), uriResolver, emptySource, overrideDefaultParser); + this.transformer = new SecureTransformer(delegate.getTransformer(), uriResolver, emptySource, overrideDefaultParser); } @Override diff --git a/src/main/java/org/apache/commons/xml/HardeningXMLFilter.java b/src/main/java/org/apache/commons/xml/HardeningXMLFilter.java index e4bd04a..7ba554d 100644 --- a/src/main/java/org/apache/commons/xml/HardeningXMLFilter.java +++ b/src/main/java/org/apache/commons/xml/HardeningXMLFilter.java @@ -39,7 +39,7 @@ * <p>Composed from the library's own wrappers instead of delegating to the implementation's filter, because the implementation filters self-provision an * unhardened reader for the input (the stock JDK's does so as early as {@code setContentHandler}) and cast a supplied {@link javax.xml.transform.Templates} to * their own type, which a wrapped Templates is not. Here the input is parsed by the parent reader, a hardened one installed on first {@code parse} when the - * caller has not set a parent (a caller-set parent is trusted configuration, used as-is), and the transformation runs on a {@link HardeningTransformer}, so + * caller has not set a parent (a caller-set parent is trusted configuration, used as-is), and the transformation runs on a {@link SecureTransformer}, so * runtime {@code document()} sits on the resolver floor.</p> */ final class HardeningXMLFilter extends XMLFilterImpl { @@ -80,7 +80,7 @@ public void parse(final InputSource input) throws SAXException, IOException { result.setLexicalHandler((LexicalHandler) handler); } try { - // A new HardeningTransformer per parse: the floor is installed on it, and transformers are not reusable across concurrent parses. + // A new SecureTransformer per parse: the floor is installed on it, and transformers are not reusable across concurrent parses. final Transformer transformer = templates.newTransformer(); transformer.transform(new SAXSource(getParent(), input), result); } catch (final TransformerException e) { diff --git a/src/main/java/org/apache/commons/xml/SecureTemplates.java b/src/main/java/org/apache/commons/xml/SecureTemplates.java index f975028..ab656a7 100644 --- a/src/main/java/org/apache/commons/xml/SecureTemplates.java +++ b/src/main/java/org/apache/commons/xml/SecureTemplates.java @@ -28,7 +28,7 @@ import javax.xml.transform.URIResolver; /** - * {@link Templates} wrapper whose only purpose is to return a {@link HardeningTransformer} from {@link Templates#newTransformer()}, with the factory's + * {@link Templates} wrapper whose only purpose is to return a {@link SecureTransformer} from {@link Templates#newTransformer()}, with the factory's * compile-time {@link URIResolver} pre-installed. * <p> * Both Apache Xalan 2.7 and stock-JDK XSLTC fail to propagate the factory's URIResolver through {@code Templates.newTransformer()}: the produced runtime @@ -93,6 +93,6 @@ public Transformer newTransformer() throws TransformerConfigurationException { if (transformer == null) { return null; } - return new HardeningTransformer(transformer, uriResolver, emptySource, overrideDefaultParser); + return new SecureTransformer(transformer, uriResolver, emptySource, overrideDefaultParser); } } diff --git a/src/main/java/org/apache/commons/xml/HardeningTransformer.java b/src/main/java/org/apache/commons/xml/SecureTransformer.java similarity index 96% rename from src/main/java/org/apache/commons/xml/HardeningTransformer.java rename to src/main/java/org/apache/commons/xml/SecureTransformer.java index 6c07703..255637d 100644 --- a/src/main/java/org/apache/commons/xml/HardeningTransformer.java +++ b/src/main/java/org/apache/commons/xml/SecureTransformer.java @@ -40,7 +40,7 @@ * the factory's compile-time resolver, matching the just-constructed state. * </p> */ -final class HardeningTransformer extends Transformer { +final class SecureTransformer extends Transformer { private final Transformer delegate; @@ -66,7 +66,7 @@ final class HardeningTransformer extends Transformer { * @param overrideDefaultParser whether the source rewrites should use the pluggable parser lookup instead of the platform's built-in parser. * @throws NullPointerException if {@code delegate} is {@code null}. */ - HardeningTransformer(final Transformer delegate, final URIResolver uriResolver, final Supplier<Source> emptySource, final boolean overrideDefaultParser) { + SecureTransformer(final Transformer delegate, final URIResolver uriResolver, final Supplier<Source> emptySource, final boolean overrideDefaultParser) { this.delegate = Objects.requireNonNull(delegate, "delegate"); this.uriResolver = uriResolver; this.overrideDefaultParser = overrideDefaultParser; diff --git a/src/test/java/org/apache/commons/xml/ShadingFootprintTest.java b/src/test/java/org/apache/commons/xml/ShadingFootprintTest.java index 427e298..372c8d0 100644 --- a/src/test/java/org/apache/commons/xml/ShadingFootprintTest.java +++ b/src/test/java/org/apache/commons/xml/ShadingFootprintTest.java @@ -110,7 +110,7 @@ class ShadingFootprintTest { "SecureSAXParserFactory$Wrapper", "SecureTemplates", "SecureTemplatesHandler", - "HardeningTransformer", + "SecureTransformer", "HardeningTransformerFactory", "HardeningTransformerFactory$1", "HardeningTransformerFactory$Wrapper",
