Consistent whitespace

Author: garborg

README.md

@@ -4,7 +4,7 @@ This package is a light-weight Julia wrapper of [Libxml2](http://www.xmlsoft.org
 
 * 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,7 +50,7 @@ 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
@@ -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")
@@ -100,23 +100,23 @@ One can also traverse all attributes of an element ``e`` as
 
 ```julia
 for a in attributes(e)  # a is an instance of XMLAttr
-	n = name(a)
-	v = value(a)
-	println("$n = $v")
+    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)  
+ad = attributes_dict(e1)
 v = ad["lang"]  # v <-- "en"
 ```
 
 **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
@@ -213,28 +213,28 @@ 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_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
 
-attributes_dict(e)   # a dictionary of all attributes of e, 
+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
@@ -245,7 +245,7 @@ show(io, e)    # output formatted XML element
 ```julia
 xdoc = XMLDocument()     # create an empty XML document
 
-e = new_element(name)    # create a new XML element 
+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
@@ -254,7 +254,7 @@ t = new_textnode(content)   # create a new text node
 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 
+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
@@ -267,15 +267,15 @@ 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)    
+                           # 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

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
-