xmltree

A simple XML tree generator.

Example:

var g = newElement("myTag")
g.add newText("some text")
g.add newComment("this is comment")

var h = newElement("secondTag")
h.add newEntity("some entity")

let att = {"key1": "first value", "key2": "second value"}.toXmlAttributes
let k = newXmlTree("treeTag", [g, h], att)

doAssert $k == """<treeTag key1="first value" key2="second value">
  <myTag>some text<!-- this is comment --></myTag>
  <secondTag>&some entity;</secondTag>
</treeTag>"""

See also:

• xmlparser module for high-level XML parsing
• parsexml module for low-level XML parsing
• htmlgen module for html code generator

Imports

since, macros, strtabs, strutils

Types

XmlNode = ref XmlNodeObj

An XML tree consisting of XML nodes.

Use newXmlTree proc for creating a new tree.

Source Edit

XmlNodeKind = enum
  xnText,                   ## a text element
  xnVerbatimText, xnElement, ## an element with 0 or more children
  xnCData,                  ## a CDATA node
  xnEntity,                 ## an entity (like ``&thing;``)
  xnComment                  ## an XML comment

Different kinds of XML nodes. Source Edit

XmlAttributes = StringTableRef

An alias for a string to string mapping.

Use toXmlAttributes proc to create XmlAttributes.

Source Edit

Consts

xmlHeader = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"

Header to use for complete XML output. Source Edit

Procs

proc newElement(tag: string): XmlNode {...}{.raises: [], tags: [].}

Creates a new XmlNode of kind xnElement with the given tag.

See also:

• newXmlTree proc
• <> macro

Example:

var a = newElement("firstTag")
a.add newElement("childTag")
assert a.kind == xnElement
assert $a == """<firstTag>
  <childTag />
</firstTag>"""

Source Edit

proc newText(text: string): XmlNode {...}{.raises: [], tags: [].}

Creates a new XmlNode of kind xnText with the text text.

Example:

var b = newText("my text")
assert b.kind == xnText
assert $b == "my text"

Source Edit

proc newVerbatimText(text: string): XmlNode {...}{.raises: [], tags: [].}

Creates a new XmlNode of kind xnVerbatimText with the text text. Since: Version 1.3. Source Edit

proc newComment(comment: string): XmlNode {...}{.raises: [], tags: [].}

Creates a new XmlNode of kind xnComment with the text comment.

Example:

var c = newComment("my comment")
assert c.kind == xnComment
assert $c == "<!-- my comment -->"

Source Edit

proc newCData(cdata: string): XmlNode {...}{.raises: [], tags: [].}

Creates a new XmlNode of kind xnCData with the text cdata.

Example:

var d = newCData("my cdata")
assert d.kind == xnCData
assert $d == "<![CDATA[my cdata]]>"

Source Edit

proc newEntity(entity: string): XmlNode {...}{.raises: [], tags: [].}

Creates a new XmlNode of kind xnEntity with the text entity.

Example:

var e = newEntity("my entity")
assert e.kind == xnEntity
assert $e == "&my entity;"

Source Edit

proc newXmlTree(tag: string; children: openArray[XmlNode];
                attributes: XmlAttributes = nil): XmlNode {...}{.raises: [], tags: [].}

Creates a new XML tree with tag, children and attributes.

See also:

• newElement proc
• <> macro

Example:

var g = newElement("myTag")
g.add newText("some text")
g.add newComment("this is comment")
var h = newElement("secondTag")
h.add newEntity("some entity")
let att = {"key1": "first value", "key2": "second value"}.toXmlAttributes
let k = newXmlTree("treeTag", [g, h], att)

doAssert $k == """<treeTag key1="first value" key2="second value">
  <myTag>some text<!-- this is comment --></myTag>
  <secondTag>&some entity;</secondTag>
</treeTag>"""

Source Edit

proc text(n: XmlNode): string {...}{.inline, raises: [], tags: [].}

Gets the associated text with the node n.

n can be a CDATA, Text, comment, or entity node.

See also:

• text= proc for text setter
• tag proc for tag getter
• tag= proc for tag setter
• innerText proc

Example:

var c = newComment("my comment")
assert $c == "<!-- my comment -->"
assert c.text == "my comment"

Source Edit

proc text=(n: XmlNode; text: string) {...}{.inline, raises: [], tags: [].}

Sets the associated text with the node n.

n can be a CDATA, Text, comment, or entity node.

See also:

• text proc for text getter
• tag proc for tag getter
• tag= proc for tag setter

Example:

var e = newEntity("my entity")
assert $e == "&my entity;"
e.text = "a new entity text"
assert $e == "&a new entity text;"

Source Edit

proc tag(n: XmlNode): string {...}{.inline, raises: [], tags: [].}

Gets the tag name of n.

n has to be an xnElement node.

See also:

• text proc for text getter
• text= proc for text setter
• tag= proc for tag setter
• innerText proc

Example:

var a = newElement("firstTag")
a.add newElement("childTag")
assert $a == """<firstTag>
  <childTag />
</firstTag>"""
assert a.tag == "firstTag"

Source Edit

proc tag=(n: XmlNode; tag: string) {...}{.inline, raises: [], tags: [].}

Sets the tag name of n.

n has to be an xnElement node.

See also:

• text proc for text getter
• text= proc for text setter
• tag proc for tag getter

Example:

var a = newElement("firstTag")
a.add newElement("childTag")
assert $a == """<firstTag>
  <childTag />
</firstTag>"""
a.tag = "newTag"
assert $a == """<newTag>
  <childTag />
</newTag>"""

Source Edit

proc rawText(n: XmlNode): string {...}{.inline, raises: [], tags: [].}

Returns the underlying 'text' string by reference.

This is only used for speed hacks.

Source Edit

proc rawTag(n: XmlNode): string {...}{.inline, raises: [], tags: [].}

Returns the underlying 'tag' string by reference.

This is only used for speed hacks.

Source Edit

proc innerText(n: XmlNode): string {...}{.raises: [], tags: [].}

Gets the inner text of n:

• If n is xnText or xnEntity, returns its content.
• If n is xnElement, runs recursively on each child node and concatenates the results.
• Otherwise returns an empty string.

See also:

• text proc

Example:

var f = newElement("myTag")
f.add newText("my text")
f.add newComment("my comment")
f.add newEntity("my entity")
assert $f == "<myTag>my text<!-- my comment -->&my entity;</myTag>"
assert innerText(f) == "my textmy entity"

Source Edit

proc add(father, son: XmlNode) {...}{.inline, raises: [], tags: [].}

Adds the child son to father.

See also:

• insert proc
• delete proc

Example:

var f = newElement("myTag")
f.add newText("my text")
f.add newElement("sonTag")
f.add newEntity("my entity")
assert $f == "<myTag>my text<sonTag />&my entity;</myTag>"

Source Edit

proc insert(father, son: XmlNode; index: int) {...}{.inline, raises: [], tags: [].}

Inserts the child son to a given position in father.

father and son must be of xnElement kind.

See also:

• add proc
• delete proc

Example:

var f = newElement("myTag")
f.add newElement("first")
f.insert(newElement("second"), 0)
assert $f == """<myTag>
  <second />
  <first />
</myTag>"""

Source Edit

proc delete(n: XmlNode; i: Natural) {...}{.raises: [], tags: [].}

Deletes the i'th child of n.

See also:

• add proc
• insert proc

Example:

var f = newElement("myTag")
f.add newElement("first")
f.insert(newElement("second"), 0)
f.delete(0)
assert $f == """<myTag>
  <first />
</myTag>"""

Source Edit

proc len(n: XmlNode): int {...}{.inline, raises: [], tags: [].}

Returns the number of n's children.

Example:

var f = newElement("myTag")
f.add newElement("first")
f.insert(newElement("second"), 0)
assert len(f) == 2

Source Edit

proc kind(n: XmlNode): XmlNodeKind {...}{.inline, raises: [], tags: [].}

Returns n's kind.

Example:

var a = newElement("firstTag")
assert a.kind == xnElement
var b = newText("my text")
assert b.kind == xnText

Source Edit

proc `[]`(n: XmlNode; i: int): XmlNode {...}{.inline, raises: [], tags: [].}

Returns the i'th child of n.

Example:

var f = newElement("myTag")
f.add newElement("first")
f.insert(newElement("second"), 0)
assert $f[1] == "<first />"
assert $f[0] == "<second />"

Source Edit

proc `[]`(n: var XmlNode; i: int): var XmlNode {...}{.inline, raises: [], tags: [].}

Returns the i'th child of n so that it can be modified. Source Edit

proc clear(n: var XmlNode) {...}{.raises: [], tags: [].}

Recursively clears all children of an XmlNode.

Example:

var g = newElement("myTag")
g.add newText("some text")
g.add newComment("this is comment")

var h = newElement("secondTag")
h.add newEntity("some entity")

let att = {"key1": "first value", "key2": "second value"}.toXmlAttributes
var k = newXmlTree("treeTag", [g, h], att)

doAssert $k == """<treeTag key1="first value" key2="second value">
  <myTag>some text<!-- this is comment --></myTag>
  <secondTag>&some entity;</secondTag>
</treeTag>"""

clear(k)
doAssert $k == """<treeTag key1="first value" key2="second value" />"""

Source Edit

proc toXmlAttributes(keyValuePairs: varargs[tuple[key, val: string]]): XmlAttributes {...}{.
    raises: [], tags: [].}

Converts {key: value} pairs into XmlAttributes.

Example:

let att = {"key1": "first value", "key2": "second value"}.toXmlAttributes
var j = newElement("myTag")
j.attrs = att

doAssert $j == """<myTag key1="first value" key2="second value" />"""

Source Edit

proc attrs(n: XmlNode): XmlAttributes {...}{.inline, raises: [], tags: [].}

Gets the attributes belonging to n.

Returns nil if attributes have not been initialised for this node.

See also:

• attrs= proc for XmlAttributes setter
• attrsLen proc for number of attributes
• attr proc for finding an attribute

Example:

var j = newElement("myTag")
assert j.attrs == nil
let att = {"key1": "first value", "key2": "second value"}.toXmlAttributes
j.attrs = att
assert j.attrs == att

Source Edit

proc attrs=(n: XmlNode; attr: XmlAttributes) {...}{.inline, raises: [], tags: [].}

Sets the attributes belonging to n.

See also:

• attrs proc for XmlAttributes getter
• attrsLen proc for number of attributes
• attr proc for finding an attribute

Example:

var j = newElement("myTag")
assert j.attrs == nil
let att = {"key1": "first value", "key2": "second value"}.toXmlAttributes
j.attrs = att
assert j.attrs == att

Source Edit

proc attrsLen(n: XmlNode): int {...}{.inline, raises: [], tags: [].}

Returns the number of n's attributes.

See also:

• attrs proc for XmlAttributes getter
• attrs= proc for XmlAttributes setter
• attr proc for finding an attribute

Example:

var j = newElement("myTag")
assert j.attrsLen == 0
let att = {"key1": "first value", "key2": "second value"}.toXmlAttributes
j.attrs = att
assert j.attrsLen == 2

Source Edit

proc attr(n: XmlNode; name: string): string {...}{.raises: [], tags: [].}

Finds the first attribute of n with a name of name. Returns "" on failure.

See also:

• attrs proc for XmlAttributes getter
• attrs= proc for XmlAttributes setter
• attrsLen proc for number of attributes

Example:

var j = newElement("myTag")
let att = {"key1": "first value", "key2": "second value"}.toXmlAttributes
j.attrs = att
assert j.attr("key1") == "first value"
assert j.attr("key2") == "second value"

Source Edit

proc clientData(n: XmlNode): int {...}{.inline, raises: [], tags: [].}

Gets the client data of n.

The client data field is used by the HTML parser and generator.

Source Edit

proc clientData=(n: XmlNode; data: int) {...}{.inline, raises: [], tags: [].}

Sets the client data of n.

The client data field is used by the HTML parser and generator.

Source Edit

proc addEscaped(result: var string; s: string) {...}{.raises: [], tags: [].}

The same as result.add(escape(s)), but more efficient. Source Edit

proc escape(s: string): string {...}{.raises: [], tags: [].}

Escapes s for inclusion into an XML document.

Escapes these characters:

char	is converted to
<	&lt;
>	&gt;
&	&amp;
"	&quot;
'	&apos;

You can also use addEscaped proc.

Source Edit

proc add(result: var string; n: XmlNode; indent = 0; indWidth = 2;
         addNewLines = true) {...}{.raises: [], tags: [].}

Adds the textual representation of n to string result.

Example:

var
  a = newElement("firstTag")
  b = newText("my text")
  c = newComment("my comment")
  s = ""
s.add(c)
s.add(a)
s.add(b)
assert s == "<!-- my comment --><firstTag />my text"

Source Edit

proc `$`(n: XmlNode): string {...}{.raises: [], tags: [].}

Converts n into its string representation.

No <$xml ...$> declaration is produced, so that the produced XML fragments are composable.

Source Edit

proc child(n: XmlNode; name: string): XmlNode {...}{.raises: [], tags: [].}

Finds the first child element of n with a name of name. Returns nil on failure.

Example:

var f = newElement("myTag")
f.add newElement("firstSon")
f.add newElement("secondSon")
f.add newElement("thirdSon")
assert $(f.child("secondSon")) == "<secondSon />"

Source Edit

proc findAll(n: XmlNode; tag: string; result: var seq[XmlNode];
             caseInsensitive = false) {...}{.raises: [], tags: [].}

Iterates over all the children of n returning those matching tag.

Found nodes satisfying the condition will be appended to the result sequence.

Example:

var
  b = newElement("good")
  c = newElement("bad")
  d = newElement("BAD")
  e = newElement("GOOD")
b.add newText("b text")
c.add newText("c text")
d.add newText("d text")
e.add newText("e text")
let a = newXmlTree("father", [b, c, d, e])
var s = newSeq[XmlNode]()
a.findAll("good", s)
assert $s == "@[<good>b text</good>]"
s.setLen(0)
a.findAll("good", s, caseInsensitive = true)
assert $s == "@[<good>b text</good>, <GOOD>e text</GOOD>]"
s.setLen(0)
a.findAll("BAD", s)
assert $s == "@[<BAD>d text</BAD>]"
s.setLen(0)
a.findAll("BAD", s, caseInsensitive = true)
assert $s == "@[<bad>c text</bad>, <BAD>d text</BAD>]"

Source Edit

proc findAll(n: XmlNode; tag: string; caseInsensitive = false): seq[XmlNode] {...}{.
    raises: [], tags: [].}

A shortcut version to assign in let blocks.

Example:

var
  b = newElement("good")
  c = newElement("bad")
  d = newElement("BAD")
  e = newElement("GOOD")
b.add newText("b text")
c.add newText("c text")
d.add newText("d text")
e.add newText("e text")
let a = newXmlTree("father", [b, c, d, e])
assert $(a.findAll("good")) == "@[<good>b text</good>]"
assert $(a.findAll("BAD")) == "@[<BAD>d text</BAD>]"
assert $(a.findAll("good", caseInsensitive = true)) == "@[<good>b text</good>, <GOOD>e text</GOOD>]"
assert $(a.findAll("BAD", caseInsensitive = true)) == "@[<bad>c text</bad>, <BAD>d text</BAD>]"

Source Edit

Iterators

iterator items(n: XmlNode): XmlNode {...}{.inline, raises: [], tags: [].}

Iterates over all direct children of n.

Example:

var g = newElement("myTag")
g.add newText("some text")
g.add newComment("this is comment")

var h = newElement("secondTag")
h.add newEntity("some entity")
g.add h

assert $g == "<myTag>some text<!-- this is comment --><secondTag>&some entity;</secondTag></myTag>"

# for x in g: # the same as `for x in items(g):`
#   echo x

# some text
# <!-- this is comment -->
# <secondTag>&some entity;<![CDATA[some cdata]]></secondTag>

Source Edit

iterator mitems(n: var XmlNode): var XmlNode {...}{.inline, raises: [], tags: [].}

Iterates over all direct children of n so that they can be modified. Source Edit

Macros

macro `<>`(x: untyped): untyped

Constructor macro for XML. Example usage:

<>a(href="http://nim-lang.org", newText("Nim rules."))

Produces an XML tree for:

<a href="http://nim-lang.org">Nim rules.</a>

Source Edit