File: Todo.xml

package info (click to toggle)
r-cran-xml 3.98-1.5-1
  • links: PTS
  • area: main
  • in suites: stretch
  • size: 9,464 kB
  • ctags: 636
  • sloc: xml: 79,579; ansic: 6,518; asm: 644; sh: 16; makefile: 1
file content (776 lines) | stat: -rw-r--r-- 20,336 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
<?xml version="1.0" encoding="utf-8"?>

<?xml-stylesheet type="text/xsl" href="../../Docs/XSL/Todo.xsl" ?> 

<!--<?xml-stylesheet type="text/xsl" href="file:///Users/duncan/Projects/org/omegahat/Docs/XSL/Todo.xsl" ?> -->
<!-- <?xml-stylesheet type="text/xsl" href="http://www.omegahat.net/Todo.xsl" ?> -->

<topics xmlns:r="http://www.r-project.org">
<title>XML package</title>

<ulink url="../XSL/S/libxslt/Todo.html">Sxslt Todo</ulink>
<ulink url="../../../../../Books/RPackages/RXMLDoc/Todo.xml">RXMLDoc Todo</ulink>
<ulink url="../../../../../Classes/StatComputing/XDynDocs/Todo.xml">IDynDocs Todo</ulink>
<ulink url="Todo-orig.html">Original HTML Todo</ulink>
<topic>
<title>XML Internal Nodes</title>

<items>

<item>
[This is a libxml2 2.9.0 issue. Dropping back to libxml2 2.7.8 cures the problem.
So implement for 2.9.0]
getNodeLocation misbehaving by not giving filename.
See book.xml and 
<r:code>
getNodeLocation(xmlParent(getNodeSet(doc, "//r:func[. = 'addRevision']")[[1]]))
</r:code>
</item>

<item>
Get rid of spurios warning message in removeNodes.list() removeNode only works on internal nodes at present.
See pkgBiblio.R in book directory.
</item>
<item>
In xmlTreeParse(), allow a function that takes the parser context.
See xmlParserContextFunction example.
</item>
<item>
getNodeLocation misbehaving on nested XIncludes.
See book.xml and 
<r:code>
ci = getNodeSet(doc, "//citation/biblioref[contains(@linkend, 'NCBIEntrez')]")
</r:code>
Should be eGQueryResultType.Rdb, but showing up as mapTypesToR.Rdb
This is a problem with findXInclude.
It appears that the issue is caused by an xpointer qualifier 
on the outer XInclude, i.e. XMLSchema include mapTypesToR.Rdb
with an xpointer.
</item>

<item>
Add error = argument for xmlParseDoc() so we can handle the errors.
</item>

<item>
getEncoding() methods for different types of nodes and trees.
</item>

<item>
Why does event parsing not scale linearly. See eventParse.R in 
Data/Wikipedia.

<r:code>
 f = h3(4000);  system.time(xmlEventParse("enwiki-20100130-pages-logging.xml", handlers = f))
</r:code>

</item>

<item>
xmlRoot&lt;- for an internal node needs to fix the reference counting.
</item>

<item>
getNodeSet() and xpathSApply() should be able to work with a 
node that has no document. i.e. just put the top node into a document,
do the XPath query and then undo the doc.
</item>

<item>
Document xmlParseString, xml, XMLString class.
</item>

<item>
If we use clean = TRUE in xmlParseString, the name space on any of the
sub-nodes disappears when we put it into the document.
</item>

<item>
Check readHTMLTable() now that we have changed its value
for one of the method's defaults for header.
</item>

<item>
findXInclude is giving back the wrong file.
See the XML book as an example.
The percent function in XDocTools was giving back iTunes.xml
when the node was actually in ParseXML.xml
</item>

<item>
Define getXIncludeInfo
</item>

<item>
Dependency/Imports for bitops
</item>

<item status="low">
verifyNamespace needs to be fixed up. What does it try to do ?
Not exported or used!
</item>

<item>
Work on "XMLNamespaceRef" nodes.

<r:code><![CDATA[
xml <- xmlParse("~/Papers/RXMLXSL/Papers/ReusableDocuments/Sys.sleep.xml")
getNodeSet(xml, "/*/namespace::*")
]]></r:code>

Want to be able to removeNodes, xmlName, 
as(, "character")

<br/>
Code is there (R_convertXMLNsRef), but not getting proper nodes back in
tests/removeNamespaces.R
</item>


<item>
newXMLNode should guard against the parent not being an XMLInternalNode,
e.g. a list() from getNodeSet().
</item>
<item>

Allow addAttributes(node, v) where v is  c(name = value).
In other words, don't make the caller specify .attrs = v
</item>

<item>
Get an error when do something like
newXMLNode("p:el", namespaceDefinitions = c("o" = "http://www.w.org"))
</item>

<item topic="xmlSource">
Line numbers in xmlSource, e.g. if there is a syntax error, map it
back to the XML file.
</item>

<item>
<r:code>htmlTreeParse("http://www.fivethirtyeight.com", useInternal = TRUE)</r:code>
causes an error about namespaces.
</item>

<item topic="xmlSource" status="low">
Get 
<r:code>
xmlSource("~/Books/XMLTechnologies/Examples/Examples.xml", xpath = "//section[@id='xsl']", verbose = TRUE)
</r:code>
to work.
<br/>
Actually, we should use
<r:code>
xmlSource("~/Books/XMLTechnologies/Examples/Examples.xml", section = 'xsl', verbose = TRUE)
</r:code>
i.e. use the <r:arg>section</r:arg> parameter.
</item>

<item>
Display line number information when there is an error in the XML
parser about an entity, etc.
See xmllint.
</item>

<item>
Allow the warnings  from htmlTreeParse() to be silenced.
See the Examples.xml in the Book/XMLTechnologies and the
Flickr example.
</item>

<item> 
Ability to identify the index of a node in its parent's children list
or ability to add nodes to a sibling,
i.e. insert them just after (or before) a particular sibling.
<br/>
addChildren(, at = siblingNode)
</item>

<item>
Last example in xmlNamespace.Rd has no URI.
</item>

<item>
comments and problems raised by Deb in the book chapters.
</item>

<item status="done">
put classes on the document instances, up to XMLAbstractDocument
</item>

<item>
Figure out what XMLTreeNode and XMLHashTreeNode have in common
and what they are supposed to be
</item>

<item>
xmlRoot&lt;-()  function and methods.
</item>

<item>
Add a free() method for XMLInternalDocument, etc.
<br/>
Ideally check whether it has a finalizer.
</item>
<item id="xsl:includes" status="done">
replaceNodes seems to be failing here.
If we include an addFinalizer = FALSE for the 
parsing of the imported documents, all seems well.
So it seems like we are releasing something that
is still in use.
Is it the text from the dictionary of the sub-document?
<r:code id="replace">
db = xmlParse("~/docbook-xsl-1.74.0/fo/docbook.xsl")
base = dirname(docName(db))
#gctorture(TRUE)
xsl.include =
 function(x){ 
       u = getRelativeURL(xmlGetAttr(x, "href"), base)
       try({tmpDoc = xmlParse(u, addFinalizer = TRUE) ;  
            print(xmlSize(xmlRoot(tmpDoc)));
            replaceNodes(x, xmlRoot(tmpDoc));
            tmpDoc
           }) 
 }
docs = xpathApply(db, "//xsl:include", xsl.include)
sel = unique(unlist(getNodeSet(db, "//@select")))
</r:code>

This version takes account of the fact that we
are dying when freeing a DTD. One or more of
the subdocuments has a DTD and that is the root 
node. But we want the xsl:stylesheet node,
not the DTD. So we fetch that explicitly
and use that as the node to replace the 
xsl:include with.
This seems to cure the problem.
<followup-question>
So we want to find out why the DTD caused the problem.
It might be the presence of an entity
</followup-question>
<r:code id="replace2">
db = xmlParse("~/docbook-xsl-1.74.0/fo/docbook.xsl")
base = dirname(docName(db))
#gctorture(TRUE)
xsl.include =
 function(x){ 
       u = getRelativeURL(xmlGetAttr(x, "href"), base)
       try({tmpDoc = xmlParse(u, addFinalizer = TRUE) ;  
            replaceNodes(x, tmpDoc[["//xsl:stylesheet"]]);
            tmpDoc
           }) 
 }
xpathApply(db, "//xsl:include", xsl.include)
sel = unique(unlist(getNodeSet(db, "//@select")))
</r:code>

I run this with
<r:code>
replicate(100, xmlSource("Todo.xml", ids = "replace2"))
</r:code>


The following all seem to work.
This one creates a new node outside of a document and
tries to replace that.
But it only processes the first xsl:include node.
<r:code>
db = xmlParse("~/docbook-xsl-1.74.0/fo/docbook.xsl")
base = dirname(docName(db))
n = db[["//xsl:include"]]
replaceNodes(n, newXMLNode("bob"))
saveXML(db)
</r:code>

This one replaces a brand new node,
but for all nodes.
<r:code>
db = xmlParse("~/docbook-xsl-1.74.0/fo/docbook.xsl")
base = dirname(docName(db))
# gctorture(TRUE)
n = xpathApply(db, "//xsl:include", 
                function(node)
                  replaceNodes(node, newXMLNode("bob")))
saveXML(db)
</r:code>

This one parses a document and inserts the root
<r:code>
db = xmlParse("~/docbook-xsl-1.74.0/fo/docbook.xsl")
base = dirname(docName(db))
# gctorture(TRUE)
n = xpathApply(db, "//xsl:include", 
                function(node) {
                  doc = xmlParse("<foo><bar/></foo>", asText = TRUE)
                  replaceNodes(node, xmlRoot(doc))
                })
saveXML(db)
</r:code>

Let's try adding the root of the imported document to the
import node.
<r:code>
db = xmlParse("~/docbook-xsl-1.74.0/fo/docbook.xsl")
base = dirname(docName(db))
xsl.include =
 function(x){ 
       u = getRelativeURL(xmlGetAttr(x, "href"), base)
       try({tmpDoc = xmlParse(u) ; 
print(xmlSize(xmlRoot(tmpDoc)))
            addChildren(x, xmlRoot(tmpDoc))
           }) 
 }
xpathApply(db, "//xsl:include", xsl.include)
sel = unique(unlist(getNodeSet(db, "//@select")))
   # Get rid of the variables
i = grep("^\\$[a-zA-Z0-9.\\-]+$", sel)
if(length(i))
  sel = sel[-i]
</r:code>
</item>

<item>
Add a sep argument to xmlValue().  For XMLInternalNode, we would have
to write the code slightly differently, in R and not a single call to
a C routine in libxml2, xmlGetNodeContent().
</item>

<item status="done">
Make xmlValue() for the different nodes return the same content.
</item>


<item status="done">
Check we have methods for XMLNamespaceDefinitions nodes
<r:code>
d = xmlParse("data/job.xml")
xmlNamespaceDefinitions(d)
</r:code>
<br/>
See tests/attrNS.R
</item>

<item status="test">
Problem with EntitiesEscape class on the XMLTextNode
means is(xmlTextNode("bob"), "XMLAbstractNode")
is FALSE.
</item>

<item status="done">
Get the classes defined for PI nodes, comments, etc.
for the different types so that they inherit from
the correct base classes.
I.e. find and fix all the class(x) = vector, not scalars!
</item>

<item status="test">
Check for duplicates in xmlNamespaces&lt;-()
</item>

<item status="done">
Consolidate the code in xmlNamespaces.XMLNode/XMLInternalNode.
<br/>
Not very much to consolidate, so not worth it.
Added a setAs("XMLNamespace", "character") method which
reduces the duplicated details.
</item>

<item status="done">
test the xmlNamespaces() and move to xmlNamespaceDefinintions.
<br/>
See tests/attrNS.R
<br/>
Actually, leave it at xmlNamespaces and xmlNamespaces&lt;-
for ease of typing.
But we have xmlNamespaces as a synonym for xmlNamespaceDefinitions.
<br/>
Set the namespace definitions on an XMLInternalNode
<r:code>
z = newXMLNode("bob")
xmlNamespaces(z, append = TRUE) = c(r = "http://www.r-project.org", omg = "http://www.omegahat.net")
names(xmlNamespaces(z))
</r:code>
</item>

<item status="test">
change the name of XMLNameSpace to XMLNamespace or whatever.
</item>

<item status="done">
Define an abstract class, e.g. RXMLNode, which is the 
base class of XMLNode and XMLHashTreeNode.
</item>

<item status="done">
Add methods for newXMLNamespace for the different types of nodes.
<br/>
Or use 
<r:code>
xmlNamespaceDefinitions(x) = c(r = "http://www.r-project.org", ...)
</r:code>
Prefer this.
</item>

<item status="done">
Check we can pass a list of namespace definitions, e.g. from an XMLInternalNode
to xmlNode(), in addition to a character vector.
<br/>
<pre>
x = xmlNode("bob", namespaceDefinitions = c(r = "http://www.r-project.org", omg = "http://www.omegahat.net"))
</pre>
</item>

<item status="done">
Hash tree for data/job.xml and dealing with comments
as first nodes.
<r:code>
tt = as(xmlParse("data/job.xml"), "XMLHashTree")
table(unlist(eapply(tt, class)))
xmlRoot(tt)
xmlRoot(tt, skip = FALSE)
</r:code>
<br/>
For the top-level nodes with no parents, we need to keep the order.
We can add a .root and them sequentially.
<br/>
Add an argument to xmlRoot() to allow skipping over these.
This is skip which is there already.
<br/>
Apply to XMLInternalDocument also.
</item>

<item status="done">
Does XMLInternalDocument handle the comments as top-level nodes properly?
Yes.
<r:code>
tt = xmlParse("data/job.xml")
saveXML(xmlRoot(tt, skip = FALSE))
saveXML(xmlRoot(tt))
</r:code>
</item>

<item status="done">
getSibling() for XMLHashTree nodes.
</item>

<item  topic="XMLInternalNodes and GC">
Mechanism for taking xmlRoot() and not freeing the XMLInternalDocument
and its nodes, but freeing it when none of them are referenced
in R.
<p>
The problem is 
<r:code>
 top = xmlRoot(xmlInternalTreeParse(f)) 
</r:code>
assigns the node to top but arranges to free the document.  If the
G.C. happens then, the doc is cleaned up, freeing the nodes at the
same time.  If we could determine that xmlRoot() was called with the
parsing command inlined, then we would know we had this situation.
Then we could detach the document from the node and free the document,
moving forward.  Of course, we can also avoid adding a finalizer via
<r:code>addFinalizer = FALSE</r:code> in the call to
<r:func>xmlInternalTreeParse</r:func>.  We could also put a finalizer
on the node that says jump to the document and free it when we are
GC'ing that variable.  But the general problem remains that we can
extract sub-nodes at will and assign them to R variables.  If we free
an ancestor node, the C-level data structure is freed too and the R
variable will be pointing to garbage.
</p>
<p>
We might also try to put <emphasis>the same</emphasis>
reference to the document as an attribute on all extracted nodes.
We could attach this SEXP to a userData in the tree.
But how do we protect it - via R_PreserveObject() and that
causes problems too.
</p>
<p>
So how about we bring the libxml2 memory management under R's
and try to handle the chains, etc. 
It is not obvious how to do this and maintain
the copy-on-modify semantics.
</p>
</item>

<item status="done">
Fill in the class names for xmlRoot.XMLHashTree in hashTree.R
</item>

<item status="low">
Finish off xmlRoot.XMLFlatTree in tree.R
<br/>
Define an XMLAbstractFlatTree class and have
XMLFlatTree and XMLHashTree extend this.
<br/>
Do we really want to make XMLFlatTree visible from the package?
</item>


<item status="done">
Attributes on children 
See tests/attrs.R or man/xmlNode.Rd
<r:code>
 d = xmlTreeParse("data/simple.xml")
 b = xmlRoot(d)
 xmlAttrs(b[[1]]) = c("class" = "character")
 xmlAttrs(xmlChildren(b)[[1]]) = c("r:class" = "character") 


 d = xmlParse("data/simple.xml")
 b = xmlRoot(d)
</r:code>
Does it work for XMLNode objects? and not for XMLInternalNode ?
Yes. So it is XMLInternalNode
And  it looks like the reassignment back to a.
The C-level node has been updated by the time the error occurs.
The error message talks about an externalptr, but
does this mean that we have lost the class?
It seems to be the case.
The error is in do_subassign2_dflt
which is called by do_subassign2 which attempts to dispatch
before calling do_subassign2_dflt.
So 
<br/>
<!--- crap here!
It turns out that when we use xmlTreeParse(), things work,
but when we create the node ourselves (as in xmlNode.Rd), it does not.
The nodes have different classes.
-->
</item>

<item>
Check the namespaces of the ancestors to see if it is valid before
issuing a warning about it not being defined in 
xmlAttrs(), e.g. the  example in tests/attrs.R
<br/>
Can we use XPath.

<br/>
For XMLNode objects, we can't check ancestors.
But for XMLHashTree objects we can.
Something like
<r:code>
getNodeSet(getNodeSet(doc, "//x:defaultNs", "x")[[1]], "./ancestor::namespace")
</r:code>
But we need to get the XPath query working at  a particular node.
<br/>
See getEffectiveNamespaces() which does the walk up the tree.
</item>

<item status="done">
Assign function for xmlAttrs&lt;-.XMLInternalNode
</item>



<item status="done">
End element handlers for SAX identified by /
</item>

<item>
Handlers for DOM and SAX using name space identifiers.
</item>

<item>
Access to the fields in the xmlParserCtxt object for XMLParserContextFunction.
</item>

<item status="done">
Do we have as(node, "XMLNode") for XMLInternalNode and vice-versa
</item>

<item status="done">
Implement xmlRoot() for which there is no XMLInternalDocument
as a run up the ancestors to the top.
<br/>
See xmlRoot.XMLInternalNode in xmlTree.R
</item>


<item  topic="XMLInternalNodes and GC">
Check into xmlSource example crashing for Deb.
</item>

<item topic="XMLInternalNodes and GC">
Who frees the loose nodes or the nodes within a document with a finalizer which unlinks the nodes
or no finalizer at all?
</item>

<item  topic="XMLInternalNodes and GC">
See gc.R, xpathGC.R
<br/>
Protect nodes from gc'ing of the document.
e.g.  getTemplate in Sxslt where we have to copy the contents of the node
to XSLCopiedTemplateDescription objects.
<br/>
Perhaps put the document on the node as an attribute.
</item>


<item status="done">
Fix the getNodeSet/xpathApply problem Martin and I found.
</item>

<item status="high">  
Function like xmlSource() but which gets the code out and into character vector.
</item>

<item topic="hashtree">
When coercing to a hash tree, allow the user to control
the handling of the parserSettings, e.g. for namespace 
conversion.
</item>

<item topic="hashtree">
Get the encoding for the strings in the hashtree correct.
</item>


<item topic="hashtree" status="low">
Finish conversion of unusual nodes,
i.e. atypical nodes such as DTD nodes, etc.
</item>

<item topic="hashtree" status="done">
Convert the DOM in R to an xmlHashTree().
<br/>
This will test the xmlHashTree() code.
<br/>
See XMLHashTree.c.
Finish off the nodes.
<br/>
Deal with XInclude nodes. - Done
</item>

<item topic="hashtree">
Hash tree conversion.
<br/>
Printing without spaces/new lines.
<br/>
Do we need to trim?
<br/>
Display of XMLHashTree has too many spaces.
</item>

<item topic="hashtree">
Functions for adding different types of nodes to trees.
</item>

<item topic="hashtree" status="done">
Put the name of the document source in the tree when parsing.
</item>

<item status="done">
xmlStopParser() doesn't work. Fix it.
</item>

<item status="test">
When setting the error handlers in C , do this from R
and make certain we reset the existing ones.
But this may not be possible as we don't seem to be able to
see the user data variable.
<br/>
Seems to work.
</item>

<item status="done">
at parameter for newXMLCommentNode.
</item>

<item status="low">
at parameter for DTDNode?
</item>

<item status="done">
Class XMLDocument when DTD or just the top-level node is the same!
<br/>
The top-level object is an XMLDocument.
The doc field is an XMLDocumentContent.
</item>

<item status="done">
Error handler for SAX parser.
</item>

<item status="done">
Error handler
<br/>
.errorFun parameter and the default handler is xmlErrorCumulator.
Can cumulate the errors one at a time and gets
called at the end of a failed parse  with the empty message
so that it knows it is complete.
</item>

<item status="done">
Access to xmlStopParser
<br/>
We only need this in the SAX world as
handlers may want to call a halt to the entire thing
but successfully.
</item>


<item status="done">
XMLParserContextFunction for handler functions
to indicate that they will accept the context as the 
first argument.
</item>

<item>
saveXML()
e.g. 
<r:code>
d = xmlParse("../SOAP/WSDLs/msnSearch.asmx")
saveXML(d, "/tmp/foo.xml")
xmlParse("/tmp/foo.xml")
xmlParse(saveXML(d), asText = TRUE)
</r:code>
Seems okay now.
But not if we just sink() and get the indentation
then we can't read it back in!
There is  unicode here
</item>

<item status="low">
Make a function for xmlKeepBlanksDefault
<br/>
Only used in one place so far, so is it really necessary.
</item>

<item status="done">
Add xmlKeepBlanksDefault support in xmlTreeParse and friends.
<br/>
Seems to be done.
<br/>
Is this done?
</item>

<item status="done">
<issue>

Make xmlAttrs()['ns:val'] = value warn about missing  definition for ns
in the same way that newXMLNode() does.

</issue>
</item>

<item status="done">
<issue>
<r:code>
doc = xmlInternalTreeParse("dynDoc.xml")
doc["//rh:arg"] 
xpathApply(doc, "//rh:arg", xmlGetAttr, "id")
</r:code>
The first works, the second complains about undefined namespace prefix.
</issue>
</item>

<xi:include xmlns:xi="http://www.w3.org/2003/XInclude"  href="../../../../../Books/RPackages/RXMLDoc/Todo.xml" xpointer="xpointer(//topic[./title/text()='Infrastructure']/items/item)"/>

<item>
Nested XInclude nodes don't seem to have their attributes.
http://www.nabble.com/Identifying-the-source-file-for-an-xi-inclusion-td21736676.html
</item>

</items>
</topic>
</topics>