tDOM

Critique  edit

Features  edit

Based on the Expat parser

uses Tcl namespaces

allows access to the DOM trees as Tcl DOM objects

Includes an HTML reader that reads HTML and generates a DOM tree.

See Also  edit

Interfacing with XML

starDOM

which combines tDOM and BWidget - Playing SAX.

Natively accessing XML and Tcllib tree style interface to tDOM

which modify/extend the tDOM API

XML Graph to canvas

uses expat and Tcldot to render directed graphs

XML/tDOM encoding issues with the http package

tDOM and Coroutines

using coroutines with tDOM and Expat to parse a document in SAX mode

Documentation  edit

Overview

dom

Create an in-memory DOM tree from XML

domDoc

Manipulates an instance of a DOM document object

domNode

Manipulates an instance of a DOM node object

expat

Creates an instance of an expat parser object

expatapi

Functions to create, install and remove expat parser object extensions.

tdom

tdom is an expat parser object extension to create an in-memory DOM tree from the input while parsing.

tnc

tnc is an expat parser object extension, that validates the XML stream against the document DTD while parsing.

Tutorials and articles  edit

A tDOM tutorial

available here on the Wiki.

tDOM – A fast XML/DOM/XPath package for Tcl written in C (alternate)

by Jochen Loewer, a valuable description of tDOM's origins and uses presented at the first European Tcl Conference.

tclum2001-tdom.pdf(alternates (compressed) 1 2), Jochen Loewer, Second European Tcl/Tk Users Meeting, 2001

design, API, usage, eBay web scraping example

Processing XML documents with Tcl and tDOM

Carsten Zerbst, 2003, illustrating how practical and easy tDOM is. And here's the same article in german: XML-Dokumente mit Tcl und tDOM bearbeiten

XMI and UML combine to drive product development, Cameron Laird, 2001

profiles a company (Ideogramic) that uses tDOM for XMI processing in its product.

Using tDOM and tDOM XSLT, Cameron Laird, 2002-02-01

highlights tDOM's performance, while also supplying a recipe for your own start with the package.

Releases  edit

http://tdom.org/downloads

Obtaining  edit

http://tdom.org/index.html

The "official" repository maintained by Rolf Ade. To clone with fossil:

fossil clone http://tdom.org/index.html

http://core.tcl.tk/tdom/

A mirror of the "official" repository.

irrational-numbers project

the Yahoo tdom group

mirror

Resources  edit

issue tracker

yahoo tdom group

Licensing  edit

• The library itself is under MPL (Mozilla Public License)
• Two of the source files are under LGPL: generic/DOMhtml.c and generic/XMLsimple.c

Examples  edit

Downloading your utility usage from Pacific Gas and Electric using TCL

Scraping timeentry.kforce.com

• how to use the SAX interface (setting up event handler scripts, stacking event handler scripts, error handling etc)
• how to parse (parse a string, or read the XML data out of a channel, with notes about the encoding problems)
• how to get a DOM tree representation of XML data
• the XPointer, DOM 1 and DOM 2 and XPath commands to find or to navigate to some nodes of interest
• how to use tDOM's XSLT engine (to build an XSLT processor or in server application)
• how to serialize DOM trees (as XML, HTML or text)
• how to validate the XML data while parsing
• how to create DOM trees from scratch
• how to create additional, tcl scripted DOM methods
• how to create additional, tcl scripted XPath functions

Example: An XPath query

set xml {
<agents>
    <agent id="007">
        <name type="first">James</name>
        <name type="last">Bond</name>
        <age>Still attractive</age>
        <sex>Male</sex>
    </agent>
    <agent id="013">
        <name type="first">Austin</name>
        <name type="last">Powers</name>
        <age>Depends on your timeline</age>
        <sex>Yes, please</sex>
    </agent>
</agents>
}


set dom [dom parse $xml]
set doc [$dom documentElement]
puts "Agent: [$doc selectNodes {string(/agents/agent[@id='013']/@id)}]"
puts "First Name: [$doc selectNodes {string(/agents/agent[@id='013']/name[@type='first'])}]"
puts "Last Name: [$doc selectNodes {string(/agents/agent[@id='013']/name[@type='last'])}]"
puts "Age: [$doc selectNodes {string(/agents/agent[@id='013']/age)}]"

Agent: 013
First Name: Austin
Last Name: Powers
Age: Depends on your timeline

Example: innerXML as extension to the DOM node methods

• initial version

• re-use parameter checks from asXML (allows -indentAttrs from trunk)
• fixed indentation of first line

% package require tdom
0.8.3
%    # returns the inner XML of a node
   # @param node a DOM node
   # @param -indent the optional indentation (see tdom's <code>asXML -indent</code>). Defaults to use tdom's default
   # @param -indentAttrs the optional attribute indentation (see tdom's <code>asXML -indentAttrs</code>). Defaults to use tdom's default
   # @return the inner XML string
   proc ::dom::domNode::innerXML {node args} {
      # re-use parameter checks from asXML
      set result [$node asXML {*}$args]
      if {[$node hasChildNodes]} {
         # strip element tag
         set result [string replace $result 0 [string first ">" $result]]
         set result [string replace $result [string last "<" $result] end]
         # strip whitespace, but not the indentation
         set indent ""
         regexp {^\s*?\n??([ \t]*?)\S} $result -> indent
         set result $indent[string trim $result]
         return $result
      } else {
         return [$node text]
      }
      # UNREACHABLE
   }
% % % % % %
% dom parse {<A specialchar="&lt;"><B><C x="y"/></B></A>} doc
domDoc0xf6aa10
% $doc documentElement root
domNode0x1011838
% [$root selectNodes //C] innerXML
% [$root selectNodes //B] innerXML
    <C x="y"/>
% [$root selectNodes //A] innerXML
    <B>
        <C x="y"/>
    </B>
% [$root selectNodes //A] innerXML -indent none
<B><C x="y"/></B>
% [$root selectNodes //A] innerXML -indent 0
<B>
<C x="y"/>
</B>

An XPath query with a namespace  edit

Making XPATH queries against a document w/ namespaces

% set fh [open small.gpx]
file13bbfa8
% set xmldata [read $fh]
<?xml version="1.0"?>
<gpx
version="1.0"
creator="ExpertGPS 1.1 - http://www.topografix.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.topografix.com/GPX/1/0"
xsi:schemaLocation="http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd">
<time>2002-02-27T17:18:33Z</time>
<bounds minlat="42.401051" minlon="-71.126602" maxlat="42.468655" maxlon="-71.102973"/>
<wpt lat="42.438878" lon="-71.119277">
<ele>44.586548</ele>
<time>2001-11-28T21:05:28Z</time>
<name>5066</name>
<desc><![CDATA[5066]]></desc>
<sym>Crossing</sym>
<type><![CDATA[Crossing]]></type>
</wpt>
<wpt lat="42.439227" lon="-71.119689">
<ele>57.607200</ele>
<time>2001-06-02T03:26:55Z</time>
<name>5067</name>
<desc><![CDATA[5067]]></desc>
<sym>Dot</sym>
<type><![CDATA[Intersection]]></type>
</wpt>
</gpx>

% close $fh

http://www.topografix.com/fells_loop.gpx

% set doc [dom parse $xmldata]
domDoc013CAE80
% set root [$doc documentElement]
domNode013B1FDC

waypoints

% set ns {gpxns http://www.topografix.com/GPX/1/0}
gpxns http://www.topografix.com/GPX/1/0

% $root selectNodes -namespaces $ns //wpt
% $root selectNodes -namespaces $ns //gpxns:wpt
domNode013B2060 domNode013B2194
% $root selectNodes -namespaces $ns {//gpxns:wpt[1]}
domNode013B2060

% $doc selectNodesNamespaces $ns
% $root selectNodes gpxns:wpt

Example: Parse HTML  edit

package require tdom
package require http

# html - the source of the html page
proc pullOutTheURLs {html} {

# Parse your HTML document into a DOM tree structure
set doc [dom parse -html $html]

# root will be the root element of your HTML document,
# ie. the HTML element
set root [$doc documentElement]

# The following finds all anchor links <a>. It isn't clear to me,
# if you also interested in the urls of <area>, <link> and <base>
# elements.
set nodeList [$root selectNodes {descendant::a}]

# init the result list
set urlList {}

# Pull out the Values of the href attributes
foreach node $nodeList {
    set attList [$node attributes *]
    foreach attribute $attList {
        if {[string tolower $attribute] == "href"} {
            lappend urlList [$node getAttribute $attribute]
            break
        }   
    }
}

# Get rid of the DOM representation of your HTML document
$doc delete

# finished
return $urlList
}


# Test it
set urlList [pullOutTheURLs [http::data [http::geturl [lindex $argv 0]]]]

foreach url $urlList {
    puts $url
}

# pull out the values of the href attributes
foreach attr [$root selectNodes {descendant::a/@href}] {
    lappend urlList [lindex $attr 1]
}

# if case insensitive matching is required, use {descendant::a/@*['href' = translate(name(),'HREF','href')]}

# if no URL matches "href" then it can be achieved in one line
set urlList [lsearch -all -inline -exact -not [concat {*}[$root selectNodes descendant::a/@href]] href]

XSLT Example  edit

What kind of language is XSLT?

% package require tdom
080
% set gamedata {<results group="A">
<match>
    <date>10-Jun-1998</date>
    <team score="2">Brazil</team>
    <team score="1">Scotland</team>
</match>
<match>
    <date>23-Jun-1998</date>
    <team score="0">Scotland</team>
    <team score="3">Morocco</team>
</match>
</results>}
% set gamedoc [dom parse $gamedata]
domDoc012E5690

% set xsldata {
         <xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
            <xsl:template match="results">
            <html>
                    <head>
                    <title>
                        Results of Group <xsl:value-of select="@group"/>
                    </title>
                    </head>
                    <body>
                            <h1>
                                Results of Group <xsl:value-of select="@group"/>
                            </h1>
                            <xsl:apply-templates/>
                    </body>
            </html>
            </xsl:template>
            <xsl:template match="match">
                    <h2>
                        <xsl:value-of select="team[1]"/> versus <xsl:value-of select="team[2]"/>
                    </h2>
                    <p>Played on <xsl:value-of select="date"/></p>
                    <p>Result: 
                            <xsl:value-of select="team[1] "/> 
                            <xsl:value-of select="team[1]/@score"/>,
                            <xsl:value-of select="team[2] "/> 
                            <xsl:value-of select="team[2]/@score"/>
                    </p>
            </xsl:template>
    </xsl:transform>
}

% set soccerstyle [dom parse $xsldata]
domDoc012DB570
% $gamedoc xslt $soccerstyle gamehtml
domDoc012E6CC0
% $gamehtml asXML
<html>
    <head>
        <title>
        Results of Group A</title>
    </head>
    <body>
        <h1>
        Results of Group A</h1>
        <h2>Brazil versus Scotland</h2>
        <p>Played on 10-Jun-1998</p>
        <p>Result: 
            Brazil2,
            Scotland1</p>
        <h2>Scotland versus Morocco</h2>
        <p>Played on 23-Jun-1998</p>
        <p>Result: 
            Scotland0,
            Morocco3</p>
    </body>
</html>

Loading XML from file with the right encoding settings  edit

tdom again - BOM and/or encoding problems & how to create <?xml ...?> node?

tDOM::xmlOpenFile expects a filename and returns a file channel handle, which

is readily fconfigure'd and seek'ed to get feeded into a dom parse -channel ...

Please note, that the proc opens a channel and returns that. That channel will

not magically go away, if you're done with it. It's your responsibility to

close that channel, if you don't need them anymore. So, a typical use pattern

(sure, not the only) is

set xmlfd [tDOM::xmlOpenFile $filename]
set doc [dom parse -channel $xmlfd]
close $xmlfd

set doc [dom parse [tDOM::xmlReadFile $filename]]

Preserving Whitespace  edit

How to apply an XSLT transformation that includes spaces to an XML doc using tDOM?, 2011-10-26.

asymmetry in tDOM XML parsing and rendering, comp.lang.tcl, 2008-04-11

Discussion  edit

Further Readings

http://www.tdom.org/files/

Given that the variable node2 holds the node command, for which you
want to know all prefix-URI mappings in scope, do

$node2 selectNodes namespace::*

>  2. I evidently don't understand the domNode man page. For the 
>     "getAttribute" method it says: 

>        getAttribute attributeName ?defaultValue? 
>           Returns the value of the attribute attributeName. If 
>           attribute is not available defaultValue is returned. 


>      It also doesn't give any example(s). 


> Can someone point me to some sample code? 

<Foo Bar="baz">Stuff</Foo> 

set $node [$doc getElementsByTagName "Foo"] 
puts [$node getAttribute "Bar"] 

baz 

puts $xmlfile "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>"

dom parse [tDOM::xmlReadFile $filename encStr]

this google thread

Historical  edit

package require tdom

Bugs  edit

Description  edit

set doc [dom createDocument foo]
set root [$doc documentElement]
# append a node
set node [$root appendChild [$doc createElement bar]]
# all of the following return a value == $node
$root firstChild
lindex [$root selectNodes /foo/bar] 0
lindex [$root selectNodes //bar] 0
lindex [$root selectNodes /*/*] 0
lindex [$root getElementsByTagName bar] 0

# do it again
set node1 [$root appendChild [$doc createElement bar]]
# all of the following return a value == $node1
[$root firstChild] nextSibling
lindex [$root selectNodes /foo/bar] 1
lindex [$root selectNodes {/foo/bar[2]}] 0
lindex [$root selectNodes //bar] 1
lindex [$root selectNodes /*/*] 1
lindex [$root getElementsByTagName bar] 1

return of "$node attributes" (and xmlns:xxx attributes) edit

$node attributes ?attributeNamePattern?

My example for xml namespace declarations

tcl ws bug 584bfb77

<?xml version="1.0" encoding="utf-8"?>
<ps1:t1 xmlns:ps1="uri1" xmlns:ps2="uri2">
  <ps1:t2 type="ps2:type"></ps1:t2>
</ps1:t1>

set xml {<?xml version="1.0" encoding="utf-8"?>
<ps1:t1 xmlns:ps1="uri1" xmlns:ps2="uri2">
  <ps1:t2 type="ps2:type"></ps1:t2>
</ps1:t1>
}
dom parse $xml doc
$doc documentElement top
foreach attributelist [$top  attributes] {
    lassign $attributelist localname prefix uri

    # ignore attributes in namespaces and with different local names
    if {$uri ne "" || $prefix ne $localname} {continue}

    # Attribute name of a namespace prefix
    set attributename "xmlns:[lindex $attributelist 0]"

    # This will filter out any non-namespace declaration attributes
    if {![$top hasAttribute $attributename]} {continue}

    puts "$attributename = [$top getAttribute $attributename]"
}

xmlns:ps1 = uri1
xmlns:ps2 = uri2

client.tcl line 2187 - 2203

• Home
• Recent changes
• Help
• WhoAmI/Logout
• Create new page
• Random page
• Previous page
• Next page
• 
  
• Add comments
• Edit
• History
• Edit summary
• References