Add a JSON extention

Author: Azzaare

Project.toml

@@ -7,6 +7,13 @@ version = "0.3.4"
 Mmap = "a63ad114-7e13-5084-954f-fe012c677804"
 OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
 
+[weakdeps]
+JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
+
+[extensions]
+XMLJSONExt = ["JSON"]
+
 [compat]
+JSON = "0.21"
 OrderedCollections = "1.4, 1.5"
 julia = "1.6"

ext/XMLJSONExt.jl

@@ -0,0 +1,58 @@
+module XMLJSONExt
+
+using JSON
+using OrderedCollections
+using XML
+
+function XML.xml2dicts(node::Node)
+    if nodetype(node) == XML.Document
+        # root node has no tag and 1 child, so it is special, just apply to its child
+        return XML.xml2dicts(only(node.children))
+    elseif nodetype(node) == XML.Text
+        # text nodes have no tag, and just have contents
+        return OrderedDict("_" => node.value)
+    elseif nodetype(node) == XML.Element
+        # normal case
+        dict = OrderedDict{String,Any}()
+        # first put in the attributes
+        if !isnothing(attributes(node))
+            merge!(dict, attributes(node))
+        end
+        # then any children
+        for child in children(node)
+            child_result = XML.xml2dicts(child)
+            for (key, value) in child_result
+                if haskey(dict, key)
+                    if isa(dict[key], Vector)
+                        push!(dict[key], value)
+                    else
+                        dict[key] = [dict[key], value]
+                    end
+                else
+                    dict[key] = value
+                end
+            end
+        end
+        return OrderedDict(tag(node) => dict)
+    else
+        throw(DomainError(nodetype(node), "unsupported node type"))
+    end
+end
+
+
+
+function XML.xml2json(xml::Node, json="")
+    dict_result = XML.xml2dicts(xml)
+
+    if isdir(dirname(json))
+        open(json, "w") do io
+            JSON.print(io, dict_result, 2)
+        end
+    else
+        return JSON.json(dict_result)
+    end
+end
+
+XML.xml2json(xml::IO, json="") = XML.xml2json(read(xml, String), json)
+
+end # module

src/XML.jl

@@ -9,7 +9,9 @@ export
     # Interface:
     children, nodetype, tag, attributes, value, is_simple, simplevalue, simple_value,
     # Extended Interface for LazyNode:
-    parent, depth, next, prev
+    parent, depth, next, prev,
+    # Extension XMLJSONExt:
+    xml2dicts, xml2json
 
 #-----------------------------------------------------------------------------# escape/unescape
 const escape_chars = ('&' => "&amp;", '<' => "&lt;", '>' => "&gt;", "'" => "&apos;", '"' => "&quot;")
@@ -69,9 +71,9 @@ A Lazy representation of an XML node.
 """
 mutable struct LazyNode <: AbstractXMLNode
     raw::Raw
-    tag::Union{Nothing, String}
-    attributes::Union{Nothing, OrderedDict{String, String}}
-    value::Union{Nothing, String}
+    tag::Union{Nothing,String}
+    attributes::Union{Nothing,OrderedDict{String,String}}
+    value::Union{Nothing,String}
 end
 LazyNode(raw::Raw) = LazyNode(raw, nothing, nothing, nothing)
 
@@ -126,33 +128,33 @@ A representation of an XML DOM node.  For simpler construction, use `(::NodeType
 """
 struct Node <: AbstractXMLNode
     nodetype::NodeType
-    tag::Union{Nothing, String}
-    attributes::Union{Nothing, OrderedDict{String, String}}
-    value::Union{Nothing, String}
-    children::Union{Nothing, Vector{Node}}
+    tag::Union{Nothing,String}
+    attributes::Union{Nothing,OrderedDict{String,String}}
+    value::Union{Nothing,String}
+    children::Union{Nothing,Vector{Node}}
 
     function Node(nodetype::NodeType, tag=nothing, attributes=nothing, value=nothing, children=nothing)
         new(nodetype,
             isnothing(tag) ? nothing : string(tag),
             isnothing(attributes) ? nothing : OrderedDict(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) :
-                children isa Tuple ? map(Node, collect(children)) :
-                [Node(children)]
+            children isa Node ? [children] :
+            children isa Vector{Node} ? children :
+            children isa Vector ? map(Node, children) :
+            children isa Tuple ? map(Node, collect(children)) :
+            [Node(children)]
         )
     end
 end
 
 function Node(o::Node, x...; kw...)
     attrs = !isnothing(kw) ?
-        merge(
-            OrderedDict(string(k) => string(v) for (k,v) in pairs(kw)),
-            isnothing(o.attributes) ? OrderedDict{String, String}() : o.attributes
-        ) :
-        o.attributes
+            merge(
+        OrderedDict(string(k) => string(v) for (k, v) in pairs(kw)),
+        isnothing(o.attributes) ? OrderedDict{String,String}() : o.attributes
+    ) :
+            o.attributes
     children = isempty(x) ? o.children : vcat(isnothing(o.children) ? [] : o.children, collect(x))
     Node(o.nodetype, o.tag, attrs, o.value, children)
 end
@@ -171,7 +173,7 @@ 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)
 
-h(tag::Union{Symbol, String}, children...; kw...) = Node(Element, tag, kw, nothing, children)
+h(tag::Union{Symbol,String}, children...; kw...) = Node(Element, tag, kw, nothing, children)
 Base.getproperty(::typeof(h), tag::Symbol) = h(tag)
 (o::Node)(children...; kw...) = Node(o, Node.(children)...; kw...)
 
@@ -261,7 +263,7 @@ next(o) = missing
 prev(o) = missing
 
 is_simple(o) = nodetype(o) == Element && (isnothing(attributes(o)) || isempty(attributes(o))) &&
-    length(children(o)) == 1 && nodetype(only(o)) in (Text, CData)
+               length(children(o)) == 1 && nodetype(only(o)) in (Text, CData)
 
 simple_value(o) = is_simple(o) ? value(only(o)) : error("`XML.simple_value` is only defined for simple nodes.")
 
@@ -274,22 +276,22 @@ function nodes_equal(a, b)
     out &= XML.attributes(a) == XML.attributes(b)
     out &= XML.value(a) == XML.value(b)
     out &= length(XML.children(a)) == length(XML.children(b))
-    out &= all(nodes_equal(ai, bi) for (ai,bi) in zip(XML.children(a), XML.children(b)))
+    out &= all(nodes_equal(ai, bi) for (ai, bi) in zip(XML.children(a), XML.children(b)))
     return out
 end
 
 Base.:(==)(a::AbstractXMLNode, b::AbstractXMLNode) = nodes_equal(a, b)
 
 #-----------------------------------------------------------------------------# parse
-Base.parse(::Type{T}, str::AbstractString) where {T <: AbstractXMLNode} = parse(str, T)
+Base.parse(::Type{T}, str::AbstractString) where {T<:AbstractXMLNode} = parse(str, T)
 
 #-----------------------------------------------------------------------------# indexing
-Base.getindex(o::Union{Raw, AbstractXMLNode}) = o
-Base.getindex(o::Union{Raw, AbstractXMLNode}, i::Integer) = children(o)[i]
-Base.getindex(o::Union{Raw, AbstractXMLNode}, ::Colon) = children(o)
-Base.lastindex(o::Union{Raw, AbstractXMLNode}) = lastindex(children(o))
+Base.getindex(o::Union{Raw,AbstractXMLNode}) = o
+Base.getindex(o::Union{Raw,AbstractXMLNode}, i::Integer) = children(o)[i]
+Base.getindex(o::Union{Raw,AbstractXMLNode}, ::Colon) = children(o)
+Base.lastindex(o::Union{Raw,AbstractXMLNode}) = lastindex(children(o))
 
-Base.only(o::Union{Raw, AbstractXMLNode}) = only(children(o))
+Base.only(o::Union{Raw,AbstractXMLNode}) = only(children(o))
 
 Base.length(o::AbstractXMLNode) = length(children(o))
 
@@ -338,7 +340,7 @@ end
 function _print_attrs(io::IO, o; color=:normal)
     attr = attributes(o)
     isnothing(attr) && return nothing
-    for (k,v) in attr
+    for (k, v) in attr
         # printstyled(io, ' ', k, '=', '"', v, '"'; color)
         print(io, ' ', k, '=', '"', v, '"')
     end
@@ -356,13 +358,13 @@ write(x; kw...) = (io = IOBuffer(); write(io, x; kw...); String(take!(io)))
 write(filename::AbstractString, x; kw...) = open(io -> write(io, x; kw...), filename, "w")
 
 function write(io::IO, x; indentsize::Int=2, depth::Int=depth(x))
-    indent = ' ' ^ indentsize
+    indent = ' '^indentsize
     nodetype = XML.nodetype(x)
     tag = XML.tag(x)
     value = XML.value(x)
     children = XML.children(x)
 
-    padding = indent ^ max(0, depth - 1)
+    padding = indent^max(0, depth - 1)
     print(io, padding)
     if nodetype === Text
         print(io, value)
@@ -377,7 +379,7 @@ function write(io::IO, x; indentsize::Int=2, depth::Int=depth(x))
             else
                 println(io)
                 foreach(children) do child
-                    write(io, child; indentsize, depth = depth + 1)
+                    write(io, child; indentsize, depth=depth + 1)
                     println(io)
                 end
                 print(io, padding, "</", tag, '>')
@@ -407,4 +409,8 @@ function write(io::IO, x; indentsize::Int=2, depth::Int=depth(x))
     end
 end
 
+# Extension XMLJSONExt
+function xml2dicts end
+function xml2json end
+
 end

test/JSONExt.jl

@@ -0,0 +1,8 @@
+using JSON
+
+@testset "XML to JSON" begin
+    xml = read("data/toJSON.xml", Node)
+    json = xml2json(xml)
+    d = xml2dicts(xml)
+    @test JSON.parse(json) == d
+end

test/Project.toml

@@ -1,4 +1,5 @@
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
 Downloads = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
+JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

test/data/toJSON.xml

@@ -0,0 +1,23 @@
+<instance
+        format="XCSP3"
+        type="CSP">
+    <variables>
+        <var id="x">0 1</var>
+        <var id="y">0 1</var>
+        <var id="z">0 1</var>
+    </variables>
+    <constraints>
+        <extension>
+            <list>x y</list>
+            <supports>(0,0) (1,1)</supports>
+        </extension>
+        <extension>
+            <list>x z</list>
+            <supports>(0,0) (1,1)</supports>
+        </extension>
+        <extension>
+            <list>y z</list>
+            <supports>(0,1) (1,0)</supports>
+        </extension>
+    </constraints>
+</instance>

test/runtests.jl

@@ -58,28 +58,28 @@ end
 #-----------------------------------------------------------------------------# Raw
 @testset "Raw tag/attributes/value" begin
     examples = [
-        (xml = "<!DOCTYPE html>",
-            nodetype = DTD,
+        (xml="<!DOCTYPE html>",
+            nodetype=DTD,
             tag=nothing,
             attributes=nothing,
             value="html"),
-        (xml = "<?xml version=\"1.0\" key=\"value\"?>",
-            nodetype = Declaration,
+        (xml="<?xml version=\"1.0\" key=\"value\"?>",
+            nodetype=Declaration,
             tag=nothing,
             attributes=Dict("version" => "1.0", "key" => "value"),
             value=nothing),
-        (xml = "<tag _id=\"1\", x=\"abc\" />",
-            nodetype = Element,
+        (xml="<tag _id=\"1\", x=\"abc\" />",
+            nodetype=Element,
             tag="tag",
             attributes=Dict("_id" => "1", "x" => "abc"),
             value=nothing),
-        (xml = "<!-- comment -->",
-            nodetype = Comment,
+        (xml="<!-- comment -->",
+            nodetype=Comment,
             tag=nothing,
             attributes=nothing,
             value=" comment "),
-        (xml = "<![CData[cdata test]]>",
-            nodetype = CData,
+        (xml="<![CData[cdata test]]>",
+            nodetype=CData,
             tag=nothing,
             attributes=nothing,
             value="cdata test"),
@@ -129,7 +129,7 @@ end
 
         idx = findall(next_res .!= prev_res)
 
-        for (a,b) in zip(next_res, prev_res)
+        for (a, b) in zip(next_res, prev_res)
             @test a == b
         end
     end
@@ -172,7 +172,7 @@ end
         @test node == node2
 
         #For debugging:
-        for (a,b) in zip(AbstractTrees.Leaves(node), AbstractTrees.Leaves(node2))
+        for (a, b) in zip(AbstractTrees.Leaves(node), AbstractTrees.Leaves(node2))
             if a != b
                 @info path
                 @info a
@@ -192,7 +192,7 @@ end
         ProcessingInstruction("xml-stylesheet", href="mystyle.css", type="text/css"),
         Element("root_tag", CData("cdata"), Text("text"))
     )
-    @test map(nodetype, children(doc)) == [DTD,Declaration,Comment,ProcessingInstruction,Element]
+    @test map(nodetype, children(doc)) == [DTD, Declaration, Comment, ProcessingInstruction, Element]
     @test length(children(doc[end])) == 2
     @test nodetype(doc[end][1]) == XML.CData
     @test nodetype(doc[end][2]) == XML.Text
@@ -221,6 +221,8 @@ end
 
     # https://github.com/JuliaComputing/XML.jl/issues/14 (Sorted Attributes)
     kw = NamedTuple(OrderedDict(Symbol(k) => Int(k) for k in 'a':'z'))
-    xyz  = XML.Element("point"; kw...)
+    xyz = XML.Element("point"; kw...)
     @test collect(keys(attributes(xyz))) == string.(collect('a':'z'))
 end
+
+include("JSONExt.jl")