tessl/maven-org-apache-groovy--groovy-xml
Groovy XML support library providing comprehensive XML processing capabilities including parsing, manipulation, and generation of XML documents using Groovy's native XML handling features, XmlSlurper, and XmlParser APIs
—
Pending
namespace-support.mddocs/
Namespace Support
Comprehensive XML namespace support including namespace builders, QName factories, and namespace-aware parsing and generation across all processing modes.
Capabilities
Namespace
Simple helper class acting as a factory for QName instances, providing an easy way to work with namespaced XML elements and attributes.
/**
* Default constructor for empty namespace
*/
Namespace()
/**
* Constructor with namespace URI
* @param uri - Namespace URI
*/
Namespace(String uri)
/**
* Constructor with URI and prefix
* @param uri - Namespace URI
* @param prefix - Namespace prefix
*/
Namespace(String uri, String prefix)
/**
* Create QName for local name in this namespace
* @param localName - Local name for the QName
* @return QName with namespace URI and local name
*/
QName get(String localName)
/**
* Get namespace prefix
* @return Namespace prefix string
*/
String getPrefix()
/**
* Get namespace URI
* @return Namespace URI string
*/
String getUri()Usage Examples:
import groovy.xml.Namespace
import groovy.namespace.QName
// Create namespaces
def xhtml = new Namespace("http://www.w3.org/1999/xhtml", "html")
def atom = new Namespace("http://www.w3.org/2005/Atom")
def empty = new Namespace()
// Create QNames
QName htmlDiv = xhtml.div // QName with XHTML namespace
QName atomEntry = atom.entry // QName with Atom namespace
QName plainElement = empty.test // QName with no namespace
// Access namespace properties
println xhtml.getUri() // "http://www.w3.org/1999/xhtml"
println xhtml.getPrefix() // "html"
println atom.getUri() // "http://www.w3.org/2005/Atom"
println atom.getPrefix() // null (no prefix specified)
// Use in XML building
def builder = new MarkupBuilder()
builder."${xhtml.html}"("xmlns:html": xhtml.getUri()) {
"${xhtml.head}" {
"${xhtml.title}"("Sample XHTML")
}
"${xhtml.body}" {
"${xhtml.p}"("Hello, namespaced world!")
}
}NamespaceBuilder
Helper class for creating namespaces in GroovyMarkup builders, providing a fluent API for namespace declaration and usage.
/**
* Constructor with parent builder
* @param builder - Parent BuilderSupport instance
*/
NamespaceBuilder(BuilderSupport builder)
/**
* Create namespace support with URI
* @param builder - Parent BuilderSupport instance
* @param uri - Namespace URI
* @return NamespaceBuilderSupport instance
*/
static NamespaceBuilderSupport newInstance(BuilderSupport builder, String uri)
/**
* Create namespace support with default settings
* @param builder - Parent BuilderSupport instance
* @return NamespaceBuilderSupport instance
*/
static NamespaceBuilderSupport newInstance(BuilderSupport builder)
/**
* Create namespace support with URI and prefix
* @param builder - Parent BuilderSupport instance
* @param uri - Namespace URI
* @param prefix - Namespace prefix
* @return NamespaceBuilderSupport instance
*/
static NamespaceBuilderSupport newInstance(BuilderSupport builder, String uri, String prefix)
/**
* Create namespace support with namespace map
* @param nsMap - Map of namespace declarations
* @param builder - Parent BuilderSupport instance
* @return NamespaceBuilderSupport instance
*/
static NamespaceBuilderSupport newInstance(Map nsMap, BuilderSupport builder)
/**
* Create namespace for URI
* @param uri - Namespace URI
* @return NamespaceBuilderSupport for the namespace
*/
NamespaceBuilderSupport namespace(String uri)
/**
* Create namespace with URI and prefix
* @param uri - Namespace URI
* @param prefix - Namespace prefix
* @return NamespaceBuilderSupport for the namespace
*/
NamespaceBuilderSupport namespace(String uri, String prefix)
/**
* Declare multiple namespaces
* @param ns - Map of prefix to URI mappings
* @return NamespaceBuilderSupport with declared namespaces
*/
NamespaceBuilderSupport declareNamespace(Map ns)NamespaceBuilderSupport
Helper class extending BuilderSupport for creating namespaced GroovyMarkup with comprehensive namespace management.
/**
* Constructor with parent builder
* @param builder - Parent BuilderSupport instance
*/
NamespaceBuilderSupport(BuilderSupport builder)
/**
* Constructor with builder and namespace URI
* @param builder - Parent BuilderSupport instance
* @param uri - Default namespace URI
*/
NamespaceBuilderSupport(BuilderSupport builder, String uri)
/**
* Constructor with builder, URI, and prefix
* @param builder - Parent BuilderSupport instance
* @param uri - Default namespace URI
* @param prefix - Default namespace prefix
*/
NamespaceBuilderSupport(BuilderSupport builder, String uri, String prefix)
/**
* Constructor with full configuration
* @param builder - Parent BuilderSupport instance
* @param uri - Default namespace URI
* @param prefix - Default namespace prefix
* @param autoPrefix - Automatically generate prefixes
*/
NamespaceBuilderSupport(BuilderSupport builder, String uri, String prefix, boolean autoPrefix)
/**
* Constructor with namespace map
* @param builder - Parent BuilderSupport instance
* @param nsMap - Map of namespace declarations
*/
NamespaceBuilderSupport(BuilderSupport builder, Map nsMap)
/**
* Create namespace support for URI
* @param namespaceURI - Namespace URI
* @return NamespaceBuilderSupport for the namespace
*/
NamespaceBuilderSupport namespace(String namespaceURI)
/**
* Create namespace support with URI and prefix
* @param namespaceURI - Namespace URI
* @param prefix - Namespace prefix
* @return NamespaceBuilderSupport for the namespace
*/
NamespaceBuilderSupport namespace(String namespaceURI, String prefix)
/**
* Declare multiple namespaces
* @param nsMap - Map of namespace declarations
* @return NamespaceBuilderSupport with declared namespaces
*/
NamespaceBuilderSupport declareNamespace(Map nsMap)Usage Examples:
import groovy.xml.*
// Basic namespace usage with MarkupBuilder
def writer = new StringWriter()
def xml = new MarkupBuilder(writer)
def ns = new NamespaceBuilder(xml)
def xhtml = ns.namespace("http://www.w3.org/1999/xhtml", "html")
def atom = ns.namespace("http://www.w3.org/2005/Atom")
// Build namespaced XML
xhtml.html {
xhtml.head {
xhtml.title("Mixed Namespace Document")
}
xhtml.body {
xhtml.h1("Blog Entries")
atom.feed {
atom.title("My Blog")
atom.entry {
atom.title("First Post")
atom.content("Hello World!")
}
}
}
}
println writer.toString()
// Using static factory methods
def builder = new MarkupBuilder()
def nsSupport = NamespaceBuilder.newInstance(builder, "http://example.org/data", "data")
nsSupport.root {
item(id: "1", "First Item")
item(id: "2", "Second Item")
}
// Multiple namespace declarations
def multiNs = NamespaceBuilder.newInstance([
"soap": "http://schemas.xmlsoap.org/soap/envelope/",
"data": "http://example.org/data"
], builder)
multiNs."soap:Envelope" {
"soap:Header" {
"data:AuthToken"("secret123")
}
"soap:Body" {
"data:GetUserRequest" {
"data:UserId"("12345")
}
}
}
// Complex namespace example with StreamingMarkupBuilder
def streamBuilder = new StreamingMarkupBuilder()
def markup = streamBuilder.bind {
mkp.xmlDeclaration(version: "1.0", encoding: "UTF-8")
namespaces << [
"rss": "http://purl.org/rss/1.0/",
"content": "http://purl.org/rss/1.0/modules/content/",
"dc": "http://purl.org/dc/elements/1.1/"
]
"rss:RDF" {
"rss:channel"("rdf:about": "http://example.org/rss") {
"rss:title"("My RSS Feed")
"rss:description"("Sample RSS with namespaces")
"dc:creator"("John Doe")
}
"rss:item"("rdf:about": "http://example.org/item1") {
"rss:title"("First Article")
"rss:link"("http://example.org/article1")
"content:encoded" {
mkp.yieldUnescaped("<p>Article content with <strong>HTML</strong></p>")
}
"dc:date"("2023-01-01")
"dc:creator"("Jane Smith")
}
}
}
// DOM building with namespaces
def domBuilder = DOMBuilder.newInstance(false, true) // namespace aware
def nsBuilder = new NamespaceBuilder(domBuilder)
def mathml = nsBuilder.namespace("http://www.w3.org/1998/Math/MathML", "m")
def doc = mathml.math {
mathml.mrow {
mathml.mi("x")
mathml.mo("+")
mathml.mi("y")
mathml.mo("=")
mathml.mn("5")
}
}
// Working with existing namespace declarations
def existingXml = '''
<soap:Envelope
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:web="http://www.webserviceX.NET/">
<soap:Body>
<web:GetWeather>
<web:CityName>London</web:CityName>
</web:GetWeather>
</soap:Body>
</soap:Envelope>
'''
// Parse with namespace awareness
def slurper = new XmlSlurper(false, true)
def parsed = slurper.parseText(existingXml)
// Access namespaced elements
println parsed.name() // "Envelope"
println parsed.Body.GetWeather.CityName.text() // "London"
// Declare namespaces for GPath access
def nsAwareParsed = parsed.declareNamespace([
"soap": "http://schemas.xmlsoap.org/soap/envelope/",
"web": "http://www.webserviceX.NET/"
])
// Use namespace-aware navigation (implementation-dependent)Advanced Namespace Patterns
Namespace-Aware Parsing Configuration
// Configure parsers for namespace awareness
XmlParser parser = new XmlParser(
false, // validating
true // namespace aware
)
XmlSlurper slurper = new XmlSlurper(
false, // validating
true // namespace aware
)
// Parse namespace-aware documents
def nsDoc = parser.parseText('''
<root xmlns="http://default.org"
xmlns:prefix="http://prefixed.org">
<child>default namespace</child>
<prefix:child>prefixed namespace</prefix:child>
</root>
''')Working with QNames in Parsed Documents
import groovy.namespace.QName
// When working with namespace-aware parsed documents
def element = nsDoc // from namespace-aware parsing
// Access namespace information
String namespaceURI = element.namespaceURI()
String localName = element.localName()
String prefix = element.prefix()
// Create QNames for comparison
def expectedQName = new QName("http://example.org", "element")
def actualQName = new QName(element.namespaceURI(), element.localName())
if (expectedQName == actualQName) {
println "Namespace match!"
}Namespace Context in XPath
import groovy.xml.dom.DOMCategory
import javax.xml.xpath.*
// Using namespaces with XPath in DOM processing
use(DOMCategory) {
def doc = // ... namespace-aware DOM document
// XPath with namespace context
def xpath = XPathFactory.newInstance().newXPath()
xpath.setNamespaceContext(new NamespaceContext() {
String getNamespaceURI(String prefix) {
switch(prefix) {
case "html": return "http://www.w3.org/1999/xhtml"
case "atom": return "http://www.w3.org/2005/Atom"
default: return null
}
}
String getPrefix(String namespaceURI) { /* implementation */ }
Iterator getPrefixes(String namespaceURI) { /* implementation */ }
})
// Use namespaced XPath
def result = xpath.evaluate("//html:p[@class='content']", doc)
def nodeSet = xpath.evaluate("//atom:entry/atom:title", doc, XPathConstants.NODESET)
}Complete Namespace Example:
import groovy.xml.*
// Create a complex namespaced document
def writer = new StringWriter()
def xml = new MarkupBuilder(writer)
// Set up namespaces
def ns = new NamespaceBuilder(xml)
def soap = ns.namespace("http://schemas.xmlsoap.org/soap/envelope/", "soap")
def wsse = ns.namespace("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", "wsse")
def app = ns.namespace("http://myapp.com/services", "app")
// Build SOAP envelope with multiple namespaces
soap.Envelope {
soap.Header {
wsse.Security {
wsse.UsernameToken {
wsse.Username("testuser")
wsse.Password("testpass")
}
}
}
soap.Body {
app.GetUserRequest {
app.UserId("12345")
app.IncludeDetails("true")
}
}
}
def soapXml = writer.toString()
println soapXml
// Parse and process the namespaced XML
def slurper = new XmlSlurper(false, true)
def parsed = slurper.parseText(soapXml)
// Navigate using GPath (namespace-aware)
def userId = parsed.Body.GetUserRequest.UserId.text()
def username = parsed.Header.Security.UsernameToken.Username.text()
println "User ID: $userId"
println "Username: $username"Install with Tessl CLI
npx tessl i tessl/maven-org-apache-groovy--groovy-xml