organize tests, some other fixes

Author: joshday

README.md

@@ -100,6 +100,20 @@ node["key"] = value
 node["key"]
 ```
 
+- `Node` is an immutable type.  However, you can easily create a copy with one or more field values changed by using the `Node(::Node; kw...)` constructor where `kw` are the fields you want to change.  For example:
+
+```julia
+node = XML.Element("tag", XML.Text("child"))
+
+simplevalue(node)
+# "child"
+
+node2 = Node(node, children=XML.Text("changed"))
+
+simplevalue(node2)
+# "changed"
+```
+
 <br>
 
 ## `XML.LazyNode`: For Fast Iteration through an XML File

src/XML.jl

@@ -138,24 +138,29 @@ struct Node <: AbstractXMLNode
             isnothing(attributes) ? nothing : Dict(string(k) => string(v) for (k, v) in pairs(attributes)),
             isnothing(value) ? nothing : string(value),
             isnothing(children) ? nothing :
+                children isa Node ? [children] :
                 children isa Vector{Node} ? children :
                 children isa Vector ? map(Node, children) :
-                map(Node, collect(children))
+                children isa Tuple ? map(Node, collect(children)) :
+                [Node(children)]
         )
     end
 end
-Node(o::Node; kw...) = isempty(kw) ? o : Node((get(kw, x, getfield(o, x)) for x in fieldnames(Node))...)
-
-Node(data::Raw) = Node(LazyNode(data))
 
-Node(x) = Node(Text, nothing, nothing, string(x), nothing)
+Node(o::Node; kw...) = isempty(kw) ? o : Node((get(kw, x, getfield(o, x)) for x in fieldnames(Node))...)
 
 function Node(node::LazyNode)
     (;nodetype, tag, attributes, value) = node
     c = XML.children(node)
     Node(nodetype, tag, attributes, value, isempty(c) ? nothing : map(Node, c))
 end
 
+Node(data::Raw) = Node(LazyNode(data))
+
+# Anything that's not Vector{UInt8} or a (Lazy)Node is converted to a Text Node
+Node(x) = Node(Text, nothing, nothing, string(x), nothing)
+
+
 # NOT in-place for Text Nodes
 function escape!(o::Node, warn::Bool=true)
     if o.nodetype == Text
@@ -184,13 +189,9 @@ Base.parse(x::AbstractString, ::Type{Node}) = Node(parse(x, Raw))
 Base.setindex!(o::Node, val, i::Integer) = o.children[i] = Node(val)
 Base.push!(a::Node, b::Node) = push!(a.children, b)
 
-function Base.setindex!(o::Node, val, key::AbstractString)
-    if isnothing(o.attributes)
-        o.attributes = Dict{String,String}()
-    end
-    o.attributes[key] = string(val)
-end
-Base.getindex(o::Node, val::AbstractString) = isnothing(o.attributes) ? nothing : get(o.attributes, val, nothing)
+Base.setindex!(o::Node, val, key::AbstractString) = (o.attributes[key] = string(val))
+Base.getindex(o::Node, val::AbstractString) = o.attributes[val]
+Base.haskey(o::Node, key::AbstractString) = isnothing(o.attributes) ? false : haskey(o.attributes, key)
 
 Base.show(io::IO, o::Node) = _show_node(io, o)
 
@@ -367,7 +368,7 @@ function write(io::IO, x; indentsize::Int=2, depth::Union{Missing,Int}=depth(x))
             end
         end
     elseif nodetype === DTD
-        print(io, "<!DOCTYPE", value, '>')
+        print(io, "<!DOCTYPE ", value, '>')
     elseif nodetype === Declaration
         print(io, "<?xml")
         _print_attrs(io, x)

src/dtd.jl

@@ -1,3 +1,5 @@
+# This is all a work in progress
+
 #-----------------------------------------------------------------------------# position_after
 function position_after(needle::Vector{UInt8}, haystack::Vector{UInt8}, i)
     x = findnext(needle, haystack, i)
@@ -7,8 +9,6 @@ end
 position_after(needle::String, haystack::Vector{UInt8}, i) = position_after(Vector{UInt8}(needle), haystack, i)
 
 
-
-
 #-----------------------------------------------------------------------------# DeclaredElement
 struct DeclaredElement
     name::String
@@ -102,14 +102,13 @@ end
 
 #-----------------------------------------------------------------------------# DTDBody
 struct DTDBody
-    root::String
     elements::Vector{DeclaredElement}
     attributes::Vector{DeclaredAttribute}
     entities::Vector{DeclaredEntity}
 end
 
 function Base.show(io::IO, o::DTDBody)
-    printstyled(io, "DTDBody(root=\"", o.root, "\")\n", color=:light_cyan)
+    printstyled(io, "DTDBody\n", color=:light_cyan)
     printstyled(io, "   DeclaredElements (", length(o.elements), ")\n", color=:light_green)
     foreach(x -> println(io, "        ", x), o.elements)
     printstyled(io, "    DeclaredAttributes (", length(o.attributes), ")\n", color=:light_green)
@@ -119,22 +118,24 @@ function Base.show(io::IO, o::DTDBody)
 end
 
 
-
-function DTDBody(data::Vector{UInt8})
+function DTDBody(data::Vector{UInt8}, file = false)
+    file && @goto isfile
     i = position_after("<!DOCTYPE", data, 1)
     root, i = get_name(data, i)
 
     i = findnext(==(UInt8('[')), data, i)
     isnothing(i) && return DTDBody(root, [], [], [])
 
+    @label isfile
     elements = get_declared_elements(data)
     attributes = get_declared_attributes(data)
     entities = get_declared_entities(data)
     return DTDBody(root, elements, attributes, entities)
 end
 
 
-Base.read(filename::String, ::Type{DTDBody}) = DTDBody(read(filename))
-Base.read(io::IO, ::Type{DTDBody}) = Raw(read(io))
+Base.read(filename::String, ::Type{DTDBody}) = DTDBody(read(filename), true)
+Base.read(io::IO, ::Type{DTDBody}) = DTDBody(read(io), true)
+
 Base.parse(s::AbstractString, ::Type{DTDBody}) = DTDBody(Vector{UInt8}(s))
 Base.parse(::Type{DTDBody}, s::AbstractString) = parse(s, DTDBody)