XML/DOM serialization

From Rosetta Code
< XML
Task
XML/DOM serialization
You are encouraged to solve this task according to the task description, using any language you may know.

Create a simple DOM and having it serialize to:

 <?xml version="1.0" ?>
 <root>
     <element>
         Some text here
     </element>
 </root>

ABAP[edit]

 
DATA: xml_string TYPE string.
 
DATA(xml) = cl_ixml=>create( ).
DATA(doc) = xml->create_document( ).
DATA(root) = doc->create_simple_element( name = 'root'
parent = doc ).
 
doc->create_simple_element( name = 'element'
parent = root
value = 'Some text here' ).
 
DATA(stream_factory) = xml->create_stream_factory( ).
DATA(stream) = stream_factory->create_ostream_cstring( string = xml_string ).
DATA(renderer) = xml->create_renderer( document = doc
ostream = stream ).
stream->set_pretty_print( abap_true ).
renderer->render( ).
 
cl_demo_output=>display_text( xml_string ).
 

Output:

<?xml version="1.0" encoding="utf-16"?>
<root>
<element>Some text here</element>
</root>

Ada[edit]

Works with: GNAT

Uses XML/Ada from AdaCore.

with Ada.Text_IO.Text_Streams;
with DOM.Core.Documents;
with DOM.Core.Nodes;
 
procedure Serialization is
My_Implementation : DOM.Core.DOM_Implementation;
My_Document  : DOM.Core.Document;
My_Root_Node  : DOM.Core.Element;
My_Element_Node  : DOM.Core.Element;
My_Text_Node  : DOM.Core.Text;
begin
My_Document := DOM.Core.Create_Document (My_Implementation);
My_Root_Node := DOM.Core.Documents.Create_Element (My_Document, "root");
My_Root_Node := DOM.Core.Nodes.Append_Child (My_Document, My_Root_Node);
My_Element_Node := DOM.Core.Documents.Create_Element (My_Document, "element");
My_Element_Node := DOM.Core.Nodes.Append_Child (My_Root_Node, My_Element_Node);
My_Text_Node := DOM.Core.Documents.Create_Text_Node (My_Document, "Some text here");
My_Text_Node := DOM.Core.Nodes.Append_Child (My_Element_Node, My_Text_Node);
DOM.Core.Nodes.Write
(Stream => Ada.Text_IO.Text_Streams.Stream
(Ada.Text_IO.Standard_Output),
N => My_Document,
Pretty_Print => True);
end Serialization;

It can be shortened a lot by adding "use" clauses and writing the creation functions into the declaration part.

Output:

<?xml version="1.0" encoding="utf-8"?>
<root>
 <element>Some text here</element>
</root>

AutoHotkey[edit]

version = "1.0"
xmlheader := "<?xml version=" . version . "?>" . "<" . root . ">"
 
element("root", "child")
element("root", "element", "more text here")
element("root_child", "kid", "yak yak")
MsgBox % xmlheader . serialize("root")
Return
 
element(parent, name, text="")
{
Global
%parent%_children .= name . "`n"
%parent%_%name% = %parent%_%name%
%parent%_%name%_name := name
%parent%_%name%_text := text
}
 
serialize(root){
StringSplit, root, root, _
xml .= "<" . root%root0% . ">"
StringTrimRight, %root%_children, %root%_children, 1
Loop, Parse, %root%_children, `n
{
If %root%_%A_LoopField%_children
xml .= serialize(%root%_%A_LoopField%)
Else
{
element := "<" . %root%_%A_LoopField%_name . ">"
element .= %root%_%A_LoopField%_text
element .= "</" . %root%_%A_LoopField%_name . ">"
xml .= element
}
}
Return xml .= "</" . root%root0% . ">"
}

Bracmat[edit]

To produce the XML including all indentations, we can do this:

(     ("?"."xml version=\"1.0\" ")
\n
(root.,"\n " (element.,"
Some text here
") \n)
 : ?xml
& out$(toML$!xml)
);

If we do not care about indentation:

(   ("?"."xml version=\"1.0\"") (root.,(element.,"Some text here"))
 : ?xml
& out$(toML$!xml)
);

C[edit]

Library: libxml
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
 
int main()
{
const char **next;
int a;
FILE *outFile;
 
xmlDoc *doc = xmlNewDoc("1.0");
xmlNode *root = xmlNewNode(NULL, "root");
xmlDocSetRootElement(doc, root);
 
xmlNode *node = xmlNewNode(NULL, "element");
xmlAddChild(node, xmlNewText("some text here"));
xmlAddChild(root, node);
 
outFile = fopen("myfile.xml", "w");
xmlElemDump(outFile, doc, root);
fclose(outFile);
 
xmlFreeDoc(doc);
xmlCleanupParser();
 
return EXIT_SUCCESS;
}

C#[edit]

Serialization using the built-in System.Xml.Serialization library of .Net.

using System.Xml;
using System.Xml.Serialization;
[XmlRoot("root")]
public class ExampleXML
{
[XmlElement("element")]
public string element = "Some text here";
static void Main(string[] args)
{
var xmlnamespace = new XmlSerializerNamespaces();
xmlnamespace.Add("", ""); //used to stop default namespaces from printing
var writer = XmlWriter.Create("output.xml");
new XmlSerializer(typeof(ExampleXML)).Serialize(writer, new ExampleXML(), xmlnamespace);
}
//Output: <?xml version="1.0" encoding="utf-8"?><root><element>Some text here</element></root>
}

Caché ObjectScript[edit]

USER>set writer=##class(%XML.Writer).%New()
USER>set writer.Charset="UTF-8"
USER>Set writer.Indent=1
USER>Set writer.IndentChars="    "
USER>set sc=writer.OutputToString()
USER>set sc=writer.RootElement("root")
USER>set sc=writer.Element("element")
USER>set sc=writer.WriteChars("Some text here")
USER>set sc=writer.EndElement()
USER>set sc=writer.EndRootElement()
USER>Write writer.GetXMLString()

<?xml version="1.0" encoding="UTF-8"?>
<root>
    <element>Some text here</element>
</root>

Clojure[edit]

 
(require '[clojure.data.xml :as xml])
 
(def xml-example (xml/element :root {} (xml/element :element {} "Some text here")))
 
(with-open [out-file (java.io.OutputStreamWriter.
(java.io.FileOutputStream. "/tmp/output.xml") "UTF-8")]
(xml/emit xml-example out-file))
 
Output:
<?xml version="1.0" encoding="UTF-8"?><root><element>Some text here</element></root>

Common Lisp[edit]

Library: Closure XML

Assuming that matching the whitespace in the problem description isn't necessary and that character encodings are permitted (see the talk page):

(let* ((doc (dom:create-document 'rune-dom:implementation nil nil nil))
(root (dom:create-element doc "root"))
(element (dom:create-element doc "element"))
(text (dom:create-text-node doc "Some text here")))
(dom:append-child element text)
(dom:append-child root element)
(dom:append-child doc root)
(dom:map-document (cxml:make-rod-sink) doc))

gives the following output:

<?xml version="1.0" encoding="UTF-8"?>
<root><element>Some text here</element></root>

Because dom:append-child returns the appended child, the same output can be produced while binding fewer variables:

(let ((doc (dom:create-document 'rune-dom:implementation nil nil nil)))
(dom:append-child
(dom:append-child
(dom:append-child doc (dom:create-element doc "root"))
(dom:create-element doc "element"))
(dom:create-text-node doc "Some text here"))
(write-string (dom:map-document (cxml:make-rod-sink) doc)))

The prefix notation makes this hard to decipher, however, and so a final version uses an auxiliary append-child*:

(defun append-child* (parent &rest children)
(reduce 'dom:append-child children :initial-value parent))
 
(let* ((doc (dom:create-document 'rune-dom:implementation nil nil nil)))
(append-child* doc
(dom:create-element doc "root")
(dom:create-element doc "element")
(dom:create-text-node doc "Some text here"))
(write-string (dom:map-document (cxml:make-rod-sink) doc)))

D[edit]

Works with: D version 2.011+
module xmltest ;
 
import std.stdio ;
import std.xml ;
 
void main() {
auto doc = new Document("root") ;
//doc.prolog = q"/<?xml version="1.0"?>/" ; // default
doc ~= new Element("element", "Some text here") ;
writefln(doc) ;
// output: <?xml version="1.0"?><root><element>Some text here</element></root>
}

E[edit]

Works with: E-on-Java

This makes use of XML libraries provided with Java.

def document := <unsafe:javax.xml.parsers.makeDocumentBuilderFactory> \
.newInstance() \
.newDocumentBuilder() \
.getDOMImplementation() \
.createDocument(null, "root", null)
def root := document.getDocumentElement()
root.appendChild(
def element := document.createElement("element"))
element.appendChild(
document.createTextNode("Some text here"))
println(document.saveXML(root))

(On the use of <unsafe>: The class has not yet been reviewed for E safety, so <import:...makeDocumentBuilderFactory> is not yet allowed. The review would probably be straightforward.)


F#[edit]

open System.Xml
 
[<EntryPoint>]
let main argv =
let xd = new XmlDocument()
// Create the required nodes:
xd.AppendChild (xd.CreateXmlDeclaration("1.0", null, null)) |> ignore
let root = xd.AppendChild (xd.CreateNode("element", "root", ""))
let element = root.AppendChild (xd.CreateElement("element", "element", ""))
element.AppendChild (xd.CreateTextNode("Some text here")) |> ignore
// The same can be accomplished with:
// xd.LoadXml("""<?xml version="1.0"?><root><element>Some text here</element></root>""")
 
let xw = new XmlTextWriter(System.Console.Out)
xw.Formatting <- Formatting.Indented
xd.WriteContentTo(xw)
0

Output

<?xml version="1.0"?>
<root>
  <element>Some text here</element>
</root>

Fantom[edit]

 
using xml
 
class XmlDom
{
public static Void main ()
{
doc := XDoc()
root := XElem("root")
doc.add (root)
 
child := XElem("element")
child.add(XText("Some text here"))
root.add (child)
 
doc.write(Env.cur.out)
}
}
 

Output:

<?xml version='1.0' encoding='UTF-8'?>
<root>
 <element>Some text here</element>
</root>

Forth[edit]

include ffl/dom.fs
 
\ Create a dom variable 'doc' in the dictionary
 
dom-create doc
 
\ Add the document root with its version attribute
 
dom.document doc dom-append-node
 
s" version" s" 1.0" dom.attribute doc dom-append-node
 
\ Add root and element
 
doc dom-parent 2drop
 
s" root" dom.element doc dom-append-node
 
s" element" dom.element doc dom-append-node
 
\ Add the text
 
s" Some text here" dom.text doc dom-append-node
 
\ Convert the document to a string and print
 
doc dom-write-string [IF]
type cr
[THEN]

Go[edit]

A partial solution based on an incomplete library. The library is missing functions needed to create a DOM piece by piece like other other solutions here. It can however create a DOM by parsing XML. Also, it lacks a function to access the processing instruction, so not surprisingly this is missing from the serialized output.

package main
 
import (
"fmt"
dom "bitbucket.org/rj/xmldom-go"
)
 
func main() {
d, err := dom.ParseStringXml(`
<?xml version="1.0" ?>
<root>
<element>
Some text here
</element>
</root>`
)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(d.ToXml()))
}
Output:
<root>
<element>
Some text here
</element>
</root>

Groovy[edit]

import groovy.xml.MarkupBuilder
def writer = new StringWriter() << '<?xml version="1.0" ?>\n'
def xml = new MarkupBuilder(writer)
xml.root() {
element('Some text here' )
}
println writer

Haskell[edit]

Using the XML.Light module from HackageDB

import Data.List
import Text.XML.Light
 
xmlDOM :: String -> String
xmlDOM txt = showTopElement $ Element
(unqual "root")
[]
[ Elem $ Element
(unqual "element")
[]
[Text $ CData CDataText txt Nothing]
Nothing
]
Nothing

Output:

*Main> mapM_ (putStrLn.ppContent) $ parseXML (xmlDOM "  Some text  ")
<?xml version="1.0" ?>
<root>
  <element>  Some text  </element>
</root>

J[edit]

There are probably better ways of doing this, but, here is a simple serializer for a rudimentary concept of a dom:

serialize=: ('<?xml version="1.0" ?>',LF),;@serialize1&''
serialize1=:4 :0
if.L.x do.
start=. y,'<',(0{::x),'>',LF
middle=. ;;(}.x) serialize1&.> <' ',y
end=. y,'</',(0{::x),'>',LF
<start,middle,end
else.
<y,x,LF
end.
)

And here is a document object that matches this task:

obj=: 'root';<'element';'some text here'

Example use:

   serialize obj
<?xml version="1.0" ?>
<root>
<element>
some text here
</element>
</root>

Java[edit]

Java's XML DOM tools don't really allow total control of the output format "out of the box" but the following program generates XML that is equivalent to the required output.

 
import java.io.StringWriter;
 
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
 
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
 
public class RDOMSerialization {
 
private Document domDoc;
 
public RDOMSerialization() {
return;
}
 
protected void buildDOMDocument() {
 
DocumentBuilderFactory factory;
DocumentBuilder builder;
DOMImplementation impl;
Element elmt1;
Element elmt2;
 
try {
factory = DocumentBuilderFactory.newInstance();
builder = factory.newDocumentBuilder();
impl = builder.getDOMImplementation();
domDoc = impl.createDocument(null, null, null);
elmt1 = domDoc.createElement("root");
elmt2 = domDoc.createElement("element");
elmt2.setTextContent("Some text here");
 
domDoc.appendChild(elmt1);
elmt1.appendChild(elmt2);
}
catch (ParserConfigurationException ex) {
ex.printStackTrace();
}
 
return;
}
 
protected void serializeXML() {
 
DOMSource domSrc;
Transformer txformer;
StringWriter sw;
StreamResult sr;
 
try {
domSrc = new DOMSource(domDoc);
 
txformer = TransformerFactory.newInstance().newTransformer();
txformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
txformer.setOutputProperty(OutputKeys.METHOD, "xml");
txformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
txformer.setOutputProperty(OutputKeys.INDENT, "yes");
txformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
txformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
 
sw = new StringWriter();
sr = new StreamResult(sw);
 
txformer.transform(domSrc, sr);
 
System.out.println(sw.toString());
}
catch (TransformerConfigurationException ex) {
ex.printStackTrace();
}
catch (TransformerFactoryConfigurationError ex) {
ex.printStackTrace();
}
catch (TransformerException ex) {
ex.printStackTrace();
}
 
return;
}
 
public static void serializationDriver(String[] args) {
 
RDOMSerialization lcl = new RDOMSerialization();
lcl.buildDOMDocument();
lcl.serializeXML();
 
return;
}
 
public static void main(String[] args) {
serializationDriver(args);
return;
}
}
 

Output:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<root>
<element>Some text here</element>
</root>

JavaScript[edit]

Works with: Firefox version 2.0

DOM

var doc = document.implementation.createDocument( null, 'root', null );
var root = doc.documentElement;
var element = doc.createElement( 'element' );
root.appendChild( element );
element.appendChild( document.createTextNode('Some text here') );
var xmlString = new XMLSerializer().serializeToString( doc );

E4X

var xml = <root>
<element>Some text here</element>
</root>;
var xmlString = xml.toXMLString();

E4X — with processing instruction

XML.ignoreProcessingInstructions = false;
var xml = <?xml version="1.0"?>
<root>
<element>Some text here</element>
</root>;
var xmlString = xml.toXMLString();


Lasso[edit]

 
content_type( 'text/xml' );// set MIME type if serving
 
xml( '<?xml version="1.0" ?><root><element>Some text here</element></root>' );
 
 

Lingo[edit]

Code based on Flash Xtra (comes with Director, i.e. "built-in") that allows to use AS2/AS3 classes in Lingo (in this case "XML" is an AS2 class).

-- create an XML document
doc = newObject("XML", "<?xml version='1.0' ?>")
 
root = doc.createElement("root")
doc.appendChild(root)
 
element = doc.createElement("element")
root.appendChild(element)
 
textNode = doc.createTextNode("Some text here")
element.appendChild(textNode)
 
put doc.toString()
-- "<?xml version='1.0' ?><root><element>Some text here</element></root>"

Lua[edit]

Using the widely available 'LuaXML' module

require("LuaXML")
local dom = xml.new("root")
local element = xml.new("element")
table.insert(element, "Some text here")
dom:append(element)
dom:save("dom.xml")

Resulting contents of dom.xml:

<?xml version="1.0"?>
<!-- file "dom.xml", generated by LuaXML -->

<root>
  <element>Some text here</element>
</root>

Mathematica[edit]

DOM = XMLObject["Document"][{XMLObject["Declaration"]["Version" -> "1.0","Encoding" -> "utf-8"]},
XMLElement["root", {}, {XMLElement["element", {}, {"Some text here"}]}], {}];
 
ExportString[DOM, "XML", "AttributeQuoting" -> "\""]

Output:

<?xml version="1.0" encoding="utf-8"?>
<root>
 <element>Some text here</element>
</root>

NetRexx[edit]

Translation of: Java
/* NetRexx */
options replace format comments java crossref symbols nobinary
 
import java.io.StringWriter
import javax.xml.
import org.w3c.dom.
 
class RDOMSerialization public
 
properties private
domDoc = Document
 
method main(args = String[]) public static
 
lcl = RDOMSerialization()
lcl.buildDOMDocument()
lcl.serializeXML()
 
return
 
method buildDOMDocument() inheritable
 
do
factory = DocumentBuilderFactory.newInstance()
builder = factory.newDocumentBuilder()
impl = builder.getDOMImplementation()
domDoc = impl.createDocument(null, null, null)
elmt1 = domDoc.createElement("root")
elmt2 = domDoc.createElement("element")
elmt2.setTextContent("Some text here")
 
domDoc.appendChild(elmt1)
elmt1.appendChild(elmt2)
 
catch exPC = ParserConfigurationException
exPC.printStackTrace
end
 
return
 
method serializeXML() inheritable
 
do
domSrc = DOMSource(domDoc)
txformer = TransformerFactory.newInstance().newTransformer()
txformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no")
txformer.setOutputProperty(OutputKeys.METHOD, "xml")
txformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8")
txformer.setOutputProperty(OutputKeys.INDENT, "yes")
txformer.setOutputProperty(OutputKeys.STANDALONE, "yes")
txformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2")
 
sw = StringWriter()
sr = StreamResult(sw)
 
txformer.transform(domSrc, sr)
 
say sw.toString
 
catch exTC = TransformerConfigurationException
exTC.printStackTrace
catch exTF = TransformerFactoryConfigurationError
exTF.printStackTrace
catch exTE = TransformerException
exTE.printStackTrace
end
 
return
 

Output:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<root>
<element>Some text here</element>
</root>

Nim[edit]

import xmldom
 
var
dom = getDOM()
document = dom.createDocument("", "root")
topElement = document.documentElement
firstElement = document.createElement "element"
textNode = document.createTextNode "Some text here"
 
topElement.appendChild firstElement
firstElement.appendChild textNode
 
echo document

Output:

<?xml version="1.0" encoding="UTF-8" ?>
<root>
  <element>
    Some text here
  </element>
</root>

Objeck[edit]

use XML;
 
bundle Default {
class Test {
function : Main(args : String[]) ~ Nil {
builder := XMLBuilder->New("root", "1.0");
root := builder->GetRoot();
element := XMLElement->New(XMLElementType->ELEMENT, "element", "Some text here");
root->AddChild(element);
builder->ToString()->PrintLine();
}
}
}

OpenEdge/Progress[edit]

The following example uses the X-DOCUMENT, for faster processing SAX can be used.

 
DEFINE VARIABLE hxdoc AS HANDLE NO-UNDO.
DEFINE VARIABLE hxroot AS HANDLE NO-UNDO.
DEFINE VARIABLE hxelement AS HANDLE NO-UNDO.
DEFINE VARIABLE hxtext AS HANDLE NO-UNDO.
DEFINE VARIABLE lcc AS LONGCHAR NO-UNDO.
 
CREATE X-DOCUMENT hxdoc.
 
CREATE X-NODEREF hxroot.
hxdoc:CREATE-NODE( hxroot, 'root', 'ELEMENT' ).
hxdoc:APPEND-CHILD( hxroot ).
 
CREATE X-NODEREF hxelement.
hxdoc:CREATE-NODE( hxelement, 'element', 'ELEMENT' ).
hxroot:APPEND-CHILD( hxelement ).
 
CREATE X-NODEREF hxtext.
hxdoc:CREATE-NODE( hxtext, 'element', 'TEXT' ).
hxelement:APPEND-CHILD( hxtext ).
hxtext:NODE-VALUE = 'Some text here'.
 
hxdoc:SAVE( 'LONGCHAR', lcc ).
MESSAGE STRING( lcc ) VIEW-AS ALERT-BOX.
 

Oz[edit]

With the code from XML Creation#Oz, we can write:

declare
proc {Main}
DOM = root(element("Some text here"))
in
{System.showInfo {Serialize DOM}}
end
...

Output:

<?xml version="1.0" ?>
<root>
<element>Some text here</element>
</root>

Pascal[edit]

Works with: Free_Pascal
Library: Classes
Library: XMLWrite
Library: DOM
program CrearXML;
 
{$mode objfpc}{$H+}
 
uses
Classes, XMLWrite, DOM;
 
var
xdoc: TXMLDocument; // variable objeto documento XML
NodoRaiz, NodoPadre, NodoHijo: TDOMNode; // variables a los nodos
begin
//crear el documento
xdoc := TXMLDocument.create;
 
NodoRaiz := xdoc.CreateElement('root'); // crear el nodo raíz
Xdoc.Appendchild(NodoRaiz); // guardar nodo raíz
NodoPadre := xdoc.CreateElement('element'); // crear el nodo hijo
NodoHijo := xdoc.CreateTextNode('Some text here'); // insertar el valor del nodo
NodoPadre.Appendchild(NodoHijo); // guardar nodo
NodoRaiz.AppendChild(NodoPadre); // insertar el nodo hijo en el correspondiente nodo padre
writeXMLFile(xDoc,'prueba.xml'); // escribir el XML
Xdoc.free;
end.
Output:
<?xml version="1.0"?>
<root>
  <element>Some text here</element>
</root>.

Perl[edit]

use XML::Simple;
print XMLout( { root => { element => "Some text here" } }, NoAttr => 1, RootName => "" );

Output:

<root>
  <element>Some text here</element>
</root>
use XML::DOM::BagOfTricks qw(createDocument createTextElement);
 
my ($doc, $root) = createDocument('root');
$root->appendChild(
createTextElement($doc, 'element', 'Some text here')
);
print $doc->toString;

Output:

<root><element>Some text here</element></root>
Library: LibXML
use XML::LibXML;
 
$xml = XML::LibXML::Document->new('1.0');
$node = $xml->createElement('root');
$xml->setDocumentElement($node);
$node2 = $xml->createElement('element');
$text = $xml->createTextNode('Some text here');
$node2->addChild($text);
$node->appendWellBalancedChunk('text');
$node->addChild($node2);
 
print $xml->toString;

Output:

<?xml version="1.0"?>
<root>text<element>Some text here</element></root>

PHP[edit]

Works with: PHP version 5
<?php
$dom = new DOMDocument();//the constructor also takes the version and char-encoding as it's two respective parameters
$dom->formatOutput = true;//format the outputted xml
$root = $dom->createElement('root');
$element = $dom->createElement('element');
$element->appendChild($dom->createTextNode('Some text here'));
$root->appendChild($element);
$dom->appendChild($root);
$xmlstring = $dom->saveXML();

PicoLisp[edit]

(load "@lib/xm.l")
 
(xml? T)
(xml '(root NIL (element NIL "Some text here")))

Output:

<?xml version="1.0" encoding="utf-8"?>
<root>
   <element>Some text here</element>
</root>

Pike[edit]

manually, one node at a time:

object dom = Parser.XML.Tree.SimpleRootNode();
dom->add_child(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_HEADER, "", ([]), ""));
object node = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_ELEMENT, "root", ([]), "");
dom->add_child(node);
 
object subnode = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_ELEMENT, "element", ([]), "");
node->add_child(subnode);
 
node = subnode;
subnode = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), "Some text here");
node->add_child(subnode);
 
dom->render_xml();
Result: "<?xml version='1.0' encoding='utf-8'?><root><element>Some text here</element></root>"

from an array, using a conversion function:

object make_xml_node(array|string in, void|int level)
{
level++;
if (stringp(in))
return Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), in);
else
{
object node = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_ELEMENT, in[0], in[1], "");
foreach(in[2..];; array|string child)
{
node->add_child(make_xml_node(child, level));
}
return node;
}
}
 
object make_xml_tree(array input)
{
object dom = Parser.XML.Tree.SimpleRootNode();
dom->add_child(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_HEADER, "", ([]), ""));
dom->add_child(make_xml_node(input));
return dom;
}
 
array input = ({ "root", ([]), ({ "element", ([]), "Some text here" }) });
make_xml_tree(input)->render_xml();
Result: "<?xml version='1.0' encoding='utf-8'?><root><element>Some text here</element></root>"

to render the output with indenting as specified in the task, this function adds the necessary text nodes:

object indent_xml(object parent, void|int indent_text, void|int level)
{
int subnodes = false;
foreach(parent->get_children();; object child)
{
if (child->get_node_type() == Parser.XML.Tree.XML_ELEMENT ||
(child->get_node_type() == Parser.XML.Tree.XML_TEXT && indent_text))
{
subnodes = true;
parent->add_child_before(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), "\r\n"+" "*level), child);
indent_xml(child, indent_text, level+1);
}
}
if (subnodes && level)
parent->add_child(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), "\r\n"+" "*(level-1)));
return parent;
}
 
 
indent_xml(make_xml_tree(input))->render_xml();
Result: "<?xml version='1.0' encoding='utf-8'?>\r\n"
"<root>\r\n"
" <element>Some text here</element>\r\n"
"</root>"
 
indent_xml(make_xml_tree(input), 1)->render_xml();
Result: "<?xml version='1.0' encoding='utf-8'?>\r\n"
"<root>\r\n"
" <element>\r\n"
" Some text here\r\n"
" </element>\r\n"
"</root>"

Python[edit]

Works with: Python version 2.5
from xml.dom.minidom import getDOMImplementation
 
dom = getDOMImplementation()
document = dom.createDocument(None, "root", None)
 
topElement = document.documentElement
firstElement = document.createElement("element")
topElement.appendChild(firstElement)
textNode = document.createTextNode("Some text here")
firstElement.appendChild(textNode)
 
xmlString = document.toprettyxml(" " * 4)
from xml.etree import ElementTree as et
 
root = et.Element("root")
et.SubElement(root, "element").text = "Some text here"
xmlString = et.tostring(root)

Racket[edit]

 
#lang at-exp racket
(require xml)
 
(define xml-str
@~a{<?xml version="1.0" ?>
<root>
<element>
Some text here
</element>
</root>})
 
;; read & parse to get an xml value
(define xml (read-xml/document (open-input-string xml-str)))
;; print it out in xml form, which is identical to the input xml
(write-xml xml)
(newline)
 

Rascal[edit]

import lang::xml::DOM;
 
public void main(){
x = document(element(none(), "root", [element(none(), "element", [charData("Some text here")])]));
return println(xmlPretty(x));
}

Output example:

rascal>main()
<?xml version="1.0" encoding="UTF-8"?>
<root>
<element>Some text here</element>
</root>

Ruby[edit]

Library: REXML
require("rexml/document")
include REXML
(doc = Document.new) << XMLDecl.new
root = doc.add_element('root')
element = root.add_element('element')
element.add_text('Some text here')
 
# save to a string
# (the first argument to write() needs an object that understands "<<")
serialized = String.new
doc.write(serialized, 4)
puts serialized

produces

<?xml version='1.0'?>
<root>
    <element>
        Some text here
    </element>
</root>

Scala[edit]

val xml = <root><element>Some text here</element></root>
scala.xml.XML.save(filename="output.xml", node=xml, enc="UTF-8", xmlDecl=true, doctype=null)

Sidef[edit]

Translation of: Perl
require('XML::Simple');
print %S'XML::Simple'.XMLout(
 :(root => :( element => 'Some text here' )),
NoAttr => 1, RootName => '',
);
Output:
  <root>
    <element>Some text here</element>
  </root>

Tcl[edit]

Library: tDOM
package require tdom
set d [dom createDocument root]
set root [$d documentElement]
$root appendChild [$d createElement element]
[$root firstChild] appendChild [$d createTextNode "Some text here"]
$d asXML
<root>
    <element>Some text here</element>
</root>

Using TclDOM

package require dom
set doc [dom::DOMImplementation create]
set root [dom::document createElement $doc root]
set elem [dom::document createElement $root element]
set text [dom::document createTextNode $elem "Some text here"]
dom::DOMImplementation serialize $doc -newline {element}
<?xml version='1.0'?>
<!DOCTYPE root>
<root>
<element>
Some text here
</element>
</root>

XProc[edit]

<p:pipeline xmlns:p="http://www.w3.org/ns/xproc" version="1.0">
<p:identity>
<p:input port="source">
<p:inline>
<root>
<element>
Some text here
</element>
</root>
</p:inline>
</p:input>
</p:identity>
</p:pipeline>

XQuery[edit]

In XQuery static element construction is like normal XML:

<root>
<element>
Some text here
</element>
</root>

Dynamic element construction looks quite different:

let $rootTagname := 'root'
let $elementTagname := 'element'
let $elementContent := 'Some text here'
 
return
element {$rootTagname}
{
element{$elementTagname}
{$elementContent}
}

XSLT[edit]

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" indent="yes" />
<xsl:template match="/"> <!-- replace the root of the incoming document with our own model -->
<xsl:element name="root">
<xsl:element name="element">
<xsl:text>Some text here</xsl:text>
</xsl:element>
</xsl:element>
</xsl:template>
</xsl:stylesheet>