You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by pa...@apache.org on 2026/04/13 05:01:18 UTC
(groovy) 01/06: GROOVY-7633: Add constructor with Map for SAXOptions to XmlSlurper
This is an automated email from the ASF dual-hosted git repository.
paulk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git
commit 59a9b97d672a4bed3a87f84e6de6f894053a6411
Author: Paul King <pa...@asert.com.au>
AuthorDate: Mon Apr 13 13:55:55 2026 +1000
GROOVY-7633: Add constructor with Map for SAXOptions to XmlSlurper
---
.../src/main/java/groovy/xml/XmlSlurper.java | 150 ++++++++++++++++++---
.../test/groovy/groovy/xml/XmlSlurperTest.groovy | 26 ++++
2 files changed, 154 insertions(+), 22 deletions(-)
diff --git a/subprojects/groovy-xml/src/main/java/groovy/xml/XmlSlurper.java b/subprojects/groovy-xml/src/main/java/groovy/xml/XmlSlurper.java
index 3925a53352..9236c94ff1 100644
--- a/subprojects/groovy-xml/src/main/java/groovy/xml/XmlSlurper.java
+++ b/subprojects/groovy-xml/src/main/java/groovy/xml/XmlSlurper.java
@@ -85,22 +85,29 @@ import static groovy.xml.XmlUtil.setFeatureQuietly;
* @see GPathResult
*/
public class XmlSlurper extends DefaultHandler {
- private final XMLReader reader;
+ private XMLReader reader;
private Node currentNode = null;
private final Stack<Node> stack = new Stack<>();
private final StringBuilder charBuffer = new StringBuilder();
private final Map<String, String> namespaceTagHints = new HashMap<>();
private boolean keepIgnorableWhitespace = false;
- private boolean namespaceAware = false;
+ private boolean namespaceAware = true;
+ private boolean validating = false;
+ private boolean allowDocTypeDeclaration = false;
/**
* Creates a non-validating and namespace-aware <code>XmlSlurper</code> which does not allow DOCTYPE declarations in documents.
+ * <p>
+ * Parser options can be configured via setters before the first parse call:
+ * <pre>
+ * // Using Groovy named parameters:
+ * def slurper = new XmlSlurper(namespaceAware: false, keepIgnorableWhitespace: true)
+ * </pre>
*
* @throws ParserConfigurationException if no parser which satisfies the requested configuration can be created.
* @throws SAXException for SAX errors.
*/
public XmlSlurper() throws ParserConfigurationException, SAXException {
- this(false, true);
}
/**
@@ -127,21 +134,47 @@ public class XmlSlurper extends DefaultHandler {
* @throws SAXException for SAX errors.
*/
public XmlSlurper(final boolean validating, final boolean namespaceAware, boolean allowDocTypeDeclaration) throws ParserConfigurationException, SAXException {
+ this.validating = validating;
+ this.namespaceAware = namespaceAware;
+ this.allowDocTypeDeclaration = allowDocTypeDeclaration;
+ }
+
+ public XmlSlurper(final XMLReader reader) {
+ this.reader = reader;
+ }
+
+ public XmlSlurper(final SAXParser parser) throws SAXException {
+ this(parser.getXMLReader());
+ }
+
+ private void initReader() throws ParserConfigurationException, SAXException {
SAXParserFactory factory = FactorySupport.createSaxParserFactory();
factory.setNamespaceAware(namespaceAware);
- this.namespaceAware = namespaceAware;
factory.setValidating(validating);
setFeatureQuietly(factory, XMLConstants.FEATURE_SECURE_PROCESSING, true);
setFeatureQuietly(factory, "http://apache.org/xml/features/disallow-doctype-decl", !allowDocTypeDeclaration);
reader = factory.newSAXParser().getXMLReader();
}
- public XmlSlurper(final XMLReader reader) {
- this.reader = reader;
+ private XMLReader getReader() throws ParserConfigurationException, SAXException {
+ if (reader == null) {
+ initReader();
+ }
+ return reader;
}
- public XmlSlurper(final SAXParser parser) throws SAXException {
- this(parser.getXMLReader());
+ private XMLReader ensureReader() {
+ try {
+ return getReader();
+ } catch (ParserConfigurationException | SAXException e) {
+ throw new RuntimeException("Failed to initialize XML reader", e);
+ }
+ }
+
+ private void checkNotInitialized(String property) {
+ if (reader != null) {
+ throw new IllegalStateException(property + " must be set before parsing");
+ }
}
/**
@@ -169,6 +202,74 @@ public class XmlSlurper extends DefaultHandler {
return keepIgnorableWhitespace;
}
+ /**
+ * Determine if namespace handling is enabled.
+ *
+ * @return true if namespace handling is enabled
+ */
+ public boolean isNamespaceAware() {
+ return namespaceAware;
+ }
+
+ /**
+ * Enable and/or disable namespace handling.
+ * Must be set before the first parse call.
+ *
+ * @param namespaceAware the new desired value
+ * @throws IllegalStateException if called after parsing has started
+ * @since 6.0.0
+ */
+ public void setNamespaceAware(boolean namespaceAware) {
+ checkNotInitialized("namespaceAware");
+ this.namespaceAware = namespaceAware;
+ }
+
+ /**
+ * Determine if the parser validates documents.
+ *
+ * @return true if validation is enabled
+ * @since 6.0.0
+ */
+ public boolean isValidating() {
+ return validating;
+ }
+
+ /**
+ * Enable and/or disable validation.
+ * Must be set before the first parse call.
+ *
+ * @param validating the new desired value
+ * @throws IllegalStateException if called after parsing has started
+ * @since 6.0.0
+ */
+ public void setValidating(boolean validating) {
+ checkNotInitialized("validating");
+ this.validating = validating;
+ }
+
+ /**
+ * Determine if DOCTYPE declarations are allowed.
+ *
+ * @return true if DOCTYPE declarations are allowed
+ * @since 6.0.0
+ */
+ public boolean isAllowDocTypeDeclaration() {
+ return allowDocTypeDeclaration;
+ }
+
+ /**
+ * Enable and/or disable DOCTYPE declaration support.
+ * Must be set before the first parse call.
+ *
+ * @param allowDocTypeDeclaration the new desired value
+ * @throws IllegalStateException if called after parsing has started
+ * @since 6.0.0
+ */
+ public void setAllowDocTypeDeclaration(boolean allowDocTypeDeclaration) {
+ checkNotInitialized("allowDocTypeDeclaration");
+ this.allowDocTypeDeclaration = allowDocTypeDeclaration;
+ }
+
/**
* @return The GPathResult instance created by consuming a stream of SAX events
* Note if one of the parse methods has been called then this returns null
@@ -196,9 +297,14 @@ public class XmlSlurper extends DefaultHandler {
* or character stream supplied by the application.
*/
public GPathResult parse(final InputSource input) throws IOException, SAXException {
- reader.setContentHandler(this);
- reader.parse(input);
- return getDocument();
+ try {
+ XMLReader r = getReader();
+ r.setContentHandler(this);
+ r.parse(input);
+ return getDocument();
+ } catch (ParserConfigurationException e) {
+ throw new SAXException(e);
+ }
}
/**
@@ -299,49 +405,49 @@ public class XmlSlurper extends DefaultHandler {
* @see org.xml.sax.XMLReader#getDTDHandler()
*/
public DTDHandler getDTDHandler() {
- return reader.getDTDHandler();
+ return ensureReader().getDTDHandler();
}
/* (non-Javadoc)
* @see org.xml.sax.XMLReader#getEntityResolver()
*/
public EntityResolver getEntityResolver() {
- return reader.getEntityResolver();
+ return ensureReader().getEntityResolver();
}
/* (non-Javadoc)
* @see org.xml.sax.XMLReader#getErrorHandler()
*/
public ErrorHandler getErrorHandler() {
- return reader.getErrorHandler();
+ return ensureReader().getErrorHandler();
}
/* (non-Javadoc)
* @see org.xml.sax.XMLReader#getFeature(java.lang.String)
*/
public boolean getFeature(final String uri) throws SAXNotRecognizedException, SAXNotSupportedException {
- return reader.getFeature(uri);
+ return ensureReader().getFeature(uri);
}
/* (non-Javadoc)
* @see org.xml.sax.XMLReader#getProperty(java.lang.String)
*/
public Object getProperty(final String uri) throws SAXNotRecognizedException, SAXNotSupportedException {
- return reader.getProperty(uri);
+ return ensureReader().getProperty(uri);
}
/* (non-Javadoc)
* @see org.xml.sax.XMLReader#setDTDHandler(org.xml.sax.DTDHandler)
*/
public void setDTDHandler(final DTDHandler dtdHandler) {
- reader.setDTDHandler(dtdHandler);
+ ensureReader().setDTDHandler(dtdHandler);
}
/* (non-Javadoc)
* @see org.xml.sax.XMLReader#setEntityResolver(org.xml.sax.EntityResolver)
*/
public void setEntityResolver(final EntityResolver entityResolver) {
- reader.setEntityResolver(entityResolver);
+ ensureReader().setEntityResolver(entityResolver);
}
/**
@@ -350,7 +456,7 @@ public class XmlSlurper extends DefaultHandler {
* @param base The URL used to resolve relative URLs
*/
public void setEntityBaseUrl(final URL base) {
- reader.setEntityResolver((publicId, systemId) -> {
+ ensureReader().setEntityResolver((publicId, systemId) -> {
try {
return new InputSource(base.toURI().resolve(systemId).toURL().openStream());
} catch (URISyntaxException e) {
@@ -363,21 +469,21 @@ public class XmlSlurper extends DefaultHandler {
* @see org.xml.sax.XMLReader#setErrorHandler(org.xml.sax.ErrorHandler)
*/
public void setErrorHandler(final ErrorHandler errorHandler) {
- reader.setErrorHandler(errorHandler);
+ ensureReader().setErrorHandler(errorHandler);
}
/* (non-Javadoc)
* @see org.xml.sax.XMLReader#setFeature(java.lang.String, boolean)
*/
public void setFeature(final String uri, final boolean value) throws SAXNotRecognizedException, SAXNotSupportedException {
- reader.setFeature(uri, value);
+ ensureReader().setFeature(uri, value);
}
/* (non-Javadoc)
* @see org.xml.sax.XMLReader#setProperty(java.lang.String, java.lang.Object)
*/
public void setProperty(final String uri, final Object value) throws SAXNotRecognizedException, SAXNotSupportedException {
- reader.setProperty(uri, value);
+ ensureReader().setProperty(uri, value);
}
// ContentHandler interface
diff --git a/subprojects/groovy-xml/src/test/groovy/groovy/xml/XmlSlurperTest.groovy b/subprojects/groovy-xml/src/test/groovy/groovy/xml/XmlSlurperTest.groovy
index 63d4e13beb..f12863b7a8 100644
--- a/subprojects/groovy-xml/src/test/groovy/groovy/xml/XmlSlurperTest.groovy
+++ b/subprojects/groovy-xml/src/test/groovy/groovy/xml/XmlSlurperTest.groovy
@@ -299,4 +299,30 @@ final class XmlSlurperTest {
assert xml.message.part.lookupNamespace("undefinedPrefix") == null
xml.message.findAll { true }.each { assert it.name() == "message"}
}
+
+ @Test
+ void testNamedParameterConstruction() {
+ def xml = '<root><item name="test">value</item></root>'
+
+ // named parameters via setters
+ def slurper = new XmlSlurper(namespaceAware: false, keepIgnorableWhitespace: true)
+ def result = slurper.parseText(xml)
+ assert result.item.text() == 'value'
+ assert result.item.@name == 'test'
+
+ // setter after boolean constructor, before first parse
+ def slurper2 = new XmlSlurper(false, false)
+ slurper2.allowDocTypeDeclaration = true
+ assert slurper2.parseText(xml).item.text() == 'value'
+
+ // setter after parse should fail
+ def slurper3 = new XmlSlurper()
+ slurper3.parseText(xml)
+ try {
+ slurper3.namespaceAware = false
+ assert false, 'should have thrown'
+ } catch (IllegalStateException e) {
+ assert e.message.contains('must be set before parsing')
+ }
+ }
}