Merge pull request #13 from garborg/track04

Track Julia 0.4 syntax changes, minor bug and doc fixes

Author: lindahua

.gitignore

@@ -1 +1,3 @@
+*.jl.cov
+*.jl.mem
 ex1

README.md

@@ -1,10 +1,10 @@
 ## LightXML.jl
 
-This package is a light-weight Julia wrapper of [Libxml2](http://www.xmlsoft.org), which provides a minimal interface that covers functionalities that are commonly needed:
+This package is a light-weight Julia wrapper of [libxml2](http://www.xmlsoft.org), which provides a minimal interface that covers functionalities that are commonly needed:
 
 * Parse a XML file or string into a tree
 * Access XML tree structure
-* Create an XML tree 
+* Create an XML tree
 * Export an XML tree to a string or an XML file
 
 ### Setup
@@ -50,11 +50,11 @@ Here is the code to parse this file:
 using LightXML
 
 # parse ex1.xml:
-# xdoc is an instance of XMLDocument, which maintains a tree structure  
+# xdoc is an instance of XMLDocument, which maintains a tree structure
 xdoc = parse_file("ex1.xml")
 
 # get the root element
-xroot = root(xdoc)   # an instance of XMLElement
+xroot = root(xdoc)  # an instance of XMLElement
 # print its name
 println(name(xroot))  # this should print: bookstore
 
@@ -68,15 +68,15 @@ for c in child_nodes(xroot)  # c is an instance of XMLNode
 end
 ```
 
-There are actually five child nodes under ``<bookstore>``: the 1st, 3rd, 5th children are text nodes (any space between node elements are captured by text nodes), while the 2nd and 4th nodes are element nodes corresponding to the ``<book>`` elements. 
+There are actually five child nodes under ``<bookstore>``: the 1st, 3rd, 5th children are text nodes (any space between node elements are captured by text nodes), while the 2nd and 4th nodes are element nodes corresponding to the ``<book>`` elements.
 
 One may use the function ``nodetype`` to determine the type of a node, which returns an integer following the table [here](http://www.w3schools.com/dom/dom_nodetype.asp). In particular, 1 indicates element node and 3 indicates text node.
 
-If you only care about child elements, you may use ``child_elements`` instead of ``child_nodes``. 
+If you only care about child elements, you may use ``child_elements`` instead of ``child_nodes``.
 
 ```julia
 ces = collect(child_elements(xroot))  # get a list of all child elements
-@assert length(ces) == 2 
+@assert length(ces) == 2
 
 # if you know the child element tagname, you can instead get a list as
 ces = get_elements_by_tagname(xroot, "book")
@@ -90,33 +90,33 @@ println(attribute(e1, "category"))
 t = find_element(e1, "title")
 
 # retrieve the value of lang attribute of t
-a = attribute(t, "lang")   # a <- "en"
+a = attribute(t, "lang")  # a <- "en"
 
 # retrieve the text content of t
 r = content(t)  # r <- "Everyday Italian"
 ```
 
-One can also traverse all attributes of an element ``e`` as
+One can also traverse all attributes of an element (``e1``) as
 
 ```julia
-for a in attributes(e)  # a is an instance of XMLAttr
-	n = name(a)
-	v = value(a)
-	println("$n = $v")
+for a in attributes(e1)  # a is an instance of XMLAttr
+    n = name(a)
+    v = value(a)
+    println("$n = $v")
 end
 ```
 
 Another way to access attributes is to turn them into a dictionary using ``attributes_dict``, as
 
 ```julia
-ad = attributes_dict(e1)  
-v = ad["lang"]  # v <-- "en"
+ad = attributes_dict(e1)
+v = ad["category"]  # v <-- "COOKING"
 ```
 
 **Note:** The functions ``child_nodes``, ``child_elements``, and ``attributes`` return light weight iterators -- so that one can use them with for-loop. To get an array of all items, one may use the ``collect`` function provided by Julia.
 
 
-#### Create an XML Document 
+#### Create an XML Document
 
 This package allows you to construct an XML document programmatically. For example, to create an XML document as
 
@@ -153,7 +153,7 @@ add_text(xs2, "Illinois")
 # set multiple attributes using a dict
 set_attributes(xs2, {"tag"=>"IL", "cap"=>"Springfield"})
 
-# now, the thrid child
+# now, the third child
 xs3 = new_child(xroot, "State")
 add_text(xs3, "California")
 # set attributes using keyword arguments
@@ -166,16 +166,16 @@ With this package, you can easily export an XML file to a string or a file, or s
 
 ```julia
 # save to an XML file
-save_file(xdoc, "f1.xml") 
+save_file(xdoc, "f1.xml")
 
 # output to a string
 s = string(xdoc)
 
 # print to the console (in a pretty format as in an XML file)
-print(xdoc)  
+print(xdoc)
 ```
 
-**Note:** the ``string`` and ``show`` functions are specialized for both ``XMLDocument`` and ``XMLElement``. 
+**Note:** the ``string`` and ``show`` functions are specialized for both ``XMLDocument`` and ``XMLElement``.
 
 
 ### Types
@@ -187,7 +187,7 @@ Main types of this package
 * ``XMLNode``: represent a generic XML node (``child_nodes`` give you this)
 * ``XMLAttr``: represent an XML attribute
 
-Note that one if an ``XMLNode`` instance ``x`` is actually an element node, one may construct an ``XMLElement`` instance by ``XMLElement(x)``.
+**Note:** If an ``XMLNode`` instance ``x`` is actually an element node, one may construct an ``XMLElement`` instance by ``XMLElement(x)``.
 
 
 ### API Functions
@@ -200,91 +200,91 @@ A list of API functions:
 ```julia
 # Let xdoc be a document, x be a node/element, e be an element
 
-root(xdoc)    # get the root element of a document
+root(xdoc)   # get the root element of a document
 
-nodetype(x)   # get an integer indicating the node type
-name(x)       # get the name of a node/element
-content(x)    # get text content of a node/element
-              # if x is an element, this returns all text (concatenated) within x
+nodetype(x)  # get an integer indicating the node type
+name(x)      # get the name of a node/element
+content(x)   # get text content of a node/element
+             # if x is an element, this returns all text (concatenated) within x
 
-is_elementnode(x)   # whether x is an element node
-is_textnode(x)      # whether x is a text node
-is_cdatanode(x)     # whether x is a CDATA node
-is_commentnode(x)   # whether x is a comment node
+is_elementnode(x)       # whether x is an element node
+is_textnode(x)          # whether x is a text node
+is_cdatanode(x)         # whether x is a CDATA node
+is_commentnode(x)       # whether x is a comment node
 
-has_children(e)      # whether e has child nodes
-has_attributes(e)    # whether e has attributes 
+has_children(e)         # whether e has child nodes
+has_attributes(e)       # whether e has attributes
 
-child_nodes(x)       # iterator of all child nodes of a node/element x
-child_elements(e)    # iterator of all child elements of e
-attributes(e)        # iterator of all attributes of e
+child_nodes(x)          # iterator of all child nodes of a node/element x
+child_elements(e)       # iterator of all child elements of e
+attributes(e)           # iterator of all attributes of e
 
-attributes_dict(e)   # a dictionary of all attributes of e, 
-                     # which maps names to corresponding values
+attributes_dict(e)      # a dictionary of all attributes of e,
+                        # which maps names to corresponding values
 
 has_attribute(e, name)  # whether a named attribute exists for e
 
 # get the value of a named attribute
-# when the attribute does not exist, it either 
+# when the attribute does not exist, it either
 # throws an exception (when required is true)
 # or returns nothing (when required is false)
-attribute(e, name; required=false)                                         
+attribute(e, name; required=false)
 
 find_element(e, name)   # the first element of specified name under e
                         # return nothing is no such an element is found
 
 get_elements_by_tagname(e, name)  # a list of all child elements of e with
-                                  # the specified name 
+                                  # the specified name
 
-string(e)      # Format an XML element into a string
-show(io, e)    # output formatted XML element
+string(e)               # format an XML element into a string
+show(io, e)             # output formatted XML element
 ```
 
 ##### Functions to create an XML document
 
 ```julia
-xdoc = XMLDocument()     # create an empty XML document
+xdoc = XMLDocument()           # create an empty XML document
 
-e = new_element(name)    # create a new XML element 
-                         # this does not attach e to a tree
+e = new_element(name)          # create a new XML element
+                               # this does not attach e to a tree
 
-t = new_textnode(content)   # create a new text node
-                            # this does not attach t to a tree
+t = new_textnode(content)      # create a new text node
+                               # this does not attach t to a tree
 
-set_root(xdoc, e)        # set element e as the root of xdoc
-add_child(parent, x)     # add x as a child of a parent element
+set_root(xdoc, e)              # set element e as the root of xdoc
+add_child(parent, x)           # add x as a child of a parent element
 
-e = create_root(xdoc, name)  # create a root element and set it as root 
-                             # equiv. to new_element + set_root
+e = create_root(xdoc, name)    # create a root element and set it as root
+                               # equiv. to new_element + set_root
 
-e = new_child(parent, name)  # create a new element and add it as a child
-                             # equiv. to new_element + add_child
+e = new_child(parent, name)    # create a new element and add it as a child
+                               # equiv. to new_element + add_child
 
-add_text(e, text)    # add text content to an element
-                     # equiv. to new_textnode + add_child
+add_text(e, text)              # add text content to an element
+                               # equiv. to new_textnode + add_child
 
-add_cdata(xdoc, e, text)    # add cdata content to an element
-                            # equiv. to new_cdatanode + add_child
+add_cdata(xdoc, e, text)       # add cdata content to an element
+                               # equiv. to new_cdatanode + add_child
 
 set_attribute(e, name, value)  # set an attribute of an element
-                               # this returns the added attribute 
+                               # this returns the added attribute
                                # as an instance of XMLAttr
 
-set_attributes(e, attrs)   # set multiple attributes in one call
-                           # attrs can be a dictionary or 
-                           # a list of pairs as (name, value)    
+set_attributes(e, attrs)       # set multiple attributes in one call
+                               # attrs can be a dictionary or
+                               # a list of pairs as (name, value)
 
 # one can also use keyword arguments to set attributes to an element
-set_attributes(e, key1="val1", key2="val2", ...)                                                      
+set_attributes(e, key1="val1", key2="val2", ...)
 ```
 
 ##### Functions to work with a document
 
 ```julia
-xdoc = parse_file(filename)    # parse an XML file
-xdoc = parse_string(str)       # parse an XML doc from a string
-save_file(xdoc, filename)      # save xdoc to an XML file
+xdoc = parse_file(filename)  # parse an XML file
+xdoc = parse_string(str)     # parse an XML doc from a string
+save_file(xdoc, filename)    # save xdoc to an XML file
 
-string(xdoc)     # Formatted XML doc to a string
-show(io, xdoc)   # output formatted XML document
+string(xdoc)                 # formatted XML doc to a string
+show(io, xdoc)               # output formatted XML document
 ```

REQUIRE

@@ -1,3 +1,3 @@
-julia 0.2-
+julia 0.3-
 @windows BinDeps
 @windows WinRPM

src/LightXML.jl

@@ -1,31 +1,31 @@
 module LightXML
 
-	export 
-
-	# common
-	name, free,
-
-	# nodes
-	AbstractXMLNode, 
-	XMLAttr, XMLAttrIter, XMLNode, XMLNodeIter, XMLElement, XMLElementIter,
-	nodetype, value, content, attribute, has_attribute,
-	is_elementnode, is_textnode, is_commentnode, is_cdatanode, is_blanknode,
-	child_nodes, has_children, attributes, has_attributes, attributes_dict,
-	child_elements, find_element, get_elements_by_tagname,
-
-	new_element, add_child, new_child, new_textnode, add_text, add_cdata,
-	set_attribute, set_attributes,
-
-	# document
-	XMLDocument, version, encoding, compression, standalone, root, 
-	parse_file, parse_string, save_file, set_root, create_root
-	
-
-	include("clib.jl")
-	include("errors.jl")
-
-	include("utils.jl")
-	include("nodes.jl")
-	include("document.jl")
-	include("cdata.jl")
+    export
+
+    # common
+    name, free,
+
+    # nodes
+    AbstractXMLNode,
+    XMLAttr, XMLAttrIter, XMLNode, XMLNodeIter, XMLElement, XMLElementIter,
+    nodetype, value, content, attribute, has_attribute,
+    is_elementnode, is_textnode, is_commentnode, is_cdatanode, is_blanknode,
+    child_nodes, has_children, attributes, has_attributes, attributes_dict,
+    child_elements, find_element, get_elements_by_tagname,
+
+    new_element, add_child, new_child, new_textnode, add_text, add_cdata,
+    set_attribute, set_attributes,
+
+    # document
+    XMLDocument, version, encoding, compression, standalone, root,
+    parse_file, parse_string, save_file, set_root, create_root
+
+
+    include("clib.jl")
+    include("errors.jl")
+
+    include("utils.jl")
+    include("nodes.jl")
+    include("document.jl")
+    include("cdata.jl")
 end

src/clib.jl

@@ -4,9 +4,9 @@
 @windows_only const libxml2 = dlopen(Pkg.dir("WinRPM","deps","usr","$(Sys.ARCH)-w64-mingw32","sys-root","mingw","bin","libxml2-2"))
 
 macro lx2func(fname)  # the macro to get functions from libxml2
-	quote
-		$(esc(fname)) = dlsym( libxml2, ($(string(fname))) )
-	end
+    quote
+        $(esc(fname)) = dlsym( libxml2, ($(string(fname))) )
+    end
 end
 
 const nullptr = convert(Ptr{Void}, 0)
@@ -21,11 +21,11 @@ typealias Xptr Ptr{Void}
 # supporting functions
 
 #
-# After tests, it seems that free in libc instead of xmlFree 
+# After tests, it seems that free in libc instead of xmlFree
 # should be used here
 #
 @lx2func xmlFree
-_xmlfree{T}(p::Ptr{T}) = ccall(:free, Void, (Ptr{T},), p)  
+_xmlfree{T}(p::Ptr{T}) = ccall(:free, Void, (Ptr{T},), p)
 
 # pre-condition: p is not null
 _xcopystr(p::Xstr) = (r = bytestring(p); _xmlfree(p); r)
@@ -65,4 +65,3 @@ _xcopystr(p::Xstr) = (r = bytestring(p); _xmlfree(p); r)
 @lx2func xmlDocDumpFormatMemoryEnc
 @lx2func xmlSaveFileEnc
 @lx2func xmlSaveFormatFileEnc
-