Remove dependency on ZipFiles.jl and EzXML.jl (#280)

* Remove remaining dependency on ZipFile.jl

* Remove overlooked use of ZipFile

* No need to close zip io any longer

* No need to close zip io any longer

* Now also removed dependency on EzXML.jl except for calls to the
 overloaded findall() and findfirst() functions and a single call
 to EzXMLunlnk().

* Replace EzXML.findall() with a new find_all_nodes()
function that uses the XML.jl API.

* Replaced EzXML.findfirst() with find_all_nodes()[begin]

* Further changes to unlink rows in write.jl

* Yesterday's changes

* Finally got SheetRowStreamIterator to work!

* Further changes bug fixing failed tests

* Force recompile?

* Now passing all tests except `escape`

* Clean up remaining open and close actions

* Final fixes to escape tests

* Remove unnecesaary data files

* Tidy-up

* Don't pretty print

* Remove last pretty printing example

* Simplify regex that undoes pretty printing

Author: TimG1964

Project.toml

@@ -8,17 +8,15 @@ version = "0.10.5-dev"
 [deps]
 Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
-EzXML = "8f5d6c58-4d21-5cfd-889c-e3ad7ee6a615"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
+XML = "72c71f33-b9b6-44de-8c94-c961784809e2"
 ZipArchives = "49080126-0e18-4c2a-b176-c102e4b3760c"
-ZipFile = "a5390f91-8eb1-5f08-bee0-b1d1ffed6cea"
 
 [compat]
-EzXML = "1"
 Tables = "1"
+XML = "0.3.4"
 ZipArchives = "2"
-ZipFile = "0.8, 0.9, 0.10"
 julia = "1.6"
 
 [extras]

data/escape.xlsx

@@ -4,18 +4,12 @@ module XLSX
 import Artifacts
 import Dates
 import Printf.@printf
-import ZipFile
 import ZipArchives
-import EzXML
+import XML
 import Tables
 import Base.convert
 
-# https://github.com/fhs/ZipFile.jl/issues/39
-if !hasmethod(Base.bytesavailable, Tuple{ZipFile.ReadableFile})
-    Base.bytesavailable(f::ZipFile.ReadableFile) = f.uncompressedsize - f._pos
-end
-
-const SPREADSHEET_NAMESPACE_XPATH_ARG = [ "xpath" => "http://schemas.openxmlformats.org/spreadsheetml/2006/main" ]
+const SPREADSHEET_NAMESPACE_XPATH_ARG = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
 const EXCEL_MAX_COLS = 16_384     # total columns supported by Excel per sheet
 const EXCEL_MAX_ROWS = 1_048_576  # total rows supported by Excel per sheet (including headers)
 

src/XLSX.jl

@@ -18,13 +18,13 @@ Base.hash(c::Cell) = hash(c.ref) + hash(c.datatype) + hash(c.style) + hash(c.val
 Base.:(==)(c1::EmptyCell, c2::EmptyCell) = c1.ref == c2.ref
 Base.hash(c::EmptyCell) = hash(c.ref) + 10
 
-function find_t_node_recursively(n::EzXML.Node) :: Union{Nothing, EzXML.Node}
-    if EzXML.nodename(n) == "t"
+function find_t_node_recursively(n::XML.LazyNode) :: Union{Nothing, XML.LazyNode}
+    if XML.tag(n) == "t"
         return n
     else
-        for child in EzXML.eachelement(n)
+        for child in XML.children(n)
             result = find_t_node_recursively(child)
-            if result != nothing
+            if result !== nothing
                 return result
             end
         end
@@ -33,25 +33,27 @@ function find_t_node_recursively(n::EzXML.Node) :: Union{Nothing, EzXML.Node}
     return nothing
 end
 
-function Cell(c::EzXML.Node)
+function Cell(c::XML.LazyNode)
     # c (Cell) element is defined at section 18.3.1.4
     # t (Cell Data Type) is an enumeration representing the cell's data type. The possible values for this attribute are defined by the ST_CellType simple type (§18.18.11).
     # s (Style Index) is the index of this cell's style. Style records are stored in the Styles Part.
 
-    @assert EzXML.nodename(c) == "c" "`Cell` Expects a `c` (cell) XML node."
+    @assert XML.tag(c) == "c" "`Cell` Expects a `c` (cell) XML node."
 
-    ref = CellRef(c["r"])
+    a = XML.attributes(c) # Dict of cell attributes
+
+    ref = CellRef(a["r"])
 
     # type
-    if haskey(c, "t")
-        t = c["t"]
+    if haskey(a, "t")
+        t = a["t"]
     else
         t = ""
     end
 
     # style
-    if haskey(c, "s")
-        s = c["s"]
+    if haskey(a, "s")
+        s = a["s"]
     else
         s = ""
     end
@@ -62,29 +64,35 @@ function Cell(c::EzXML.Node)
     local found_v::Bool = false
     local found_f::Bool = false
 
-    for c_child_element in EzXML.eachelement(c)
-
+    for c_child_element in XML.children(c)
         if t == "inlineStr"
-
-            if EzXML.nodename(c_child_element) == "is"
+            if XML.tag(c_child_element) == "is"
                 t_node = find_t_node_recursively(c_child_element)
-                if t_node != nothing
-                    v = EzXML.nodecontent(t_node)
+                if t_node !== nothing
+                    c = XML.children(t_node)
+                    if length(c) == 0
+                        v = ""
+                    elseif length(c) == 1
+                        v= XML.value(c[1])
+                    else
+                        error("Too amny children in `t` node. Expected >=1, found: $(length(c))")
+                    end
                 end
             end
 
         else
-            if EzXML.nodename(c_child_element) == "v"
+            if XML.tag(c_child_element) == "v"
 
                 # we should have only one v element
                 if found_v
                     error("Unsupported: cell $(ref) has more than 1 `v` elements.")
                 else
                     found_v = true
                 end
+                
+                v = XML.unescape(XML.simple_value(c_child_element))
 
-                v = EzXML.nodecontent(c_child_element)
-            elseif EzXML.nodename(c_child_element) == "f"
+            elseif XML.tag(c_child_element) == "f"
 
                 # we should have only one f element
                 if found_f
@@ -97,40 +105,54 @@ function Cell(c::EzXML.Node)
             end
         end
     end
-
     return Cell(ref, t, s, v, f)
 end
 
 function parse_formula_from_element(c_child_element) :: AbstractFormula
 
-    if EzXML.nodename(c_child_element) != "f"
-        error("Expected nodename `f`. Found: `$(EzXML.nodename(c_child_element))`")
+    if XML.tag(c_child_element) != "f"
+        error("Expected nodename `f`. Found: `$(XML.tag(c_child_element))`")
     end
 
-    formula_string = EzXML.nodecontent(c_child_element)
+    if XML.is_simple(c_child_element)
+        formula_string = XML.simple_value(c_child_element)
+    else
+        fs = [x for x in XML.children(c_child_element) if XML.nodetype(x) == XML.Text]
+        if length(fs)==0
+            formula_string=""
+        else
+            formula_string=XML.value(fs[1])
+        end
+    end
 
-    if haskey(c_child_element, "ref") && haskey(c_child_element, "t") && c_child_element["t"] == "shared"
+    a = XML.attributes(c_child_element)
 
-        haskey(c_child_element, "si") || error("Expected shared formula to have an index. `si` attribute is missing: $c_child_element")
+    if !isnothing(a)
 
-        return ReferencedFormula(
-            formula_string,
-            parse(Int, c_child_element["si"]),
-            c_child_element["ref"],
-        )
+        if haskey(a, "ref") && haskey(a, "t") && a["t"] == "shared"
 
-    elseif haskey(c_child_element, "t") && c_child_element["t"] == "shared"
+            haskey(a, "si") || error("Expected shared formula to have an index. `si` attribute is missing: $c_child_element")
 
-        haskey(c_child_element, "si") || error("Expected shared formula to have an index. `si` attribute is missing: $c_child_element")
+            return ReferencedFormula(
+                formula_string,
+                parse(Int, a["si"]),
+                a["ref"],
+            )
 
-        return FormulaReference(
-            parse(Int, c_child_element["si"]),
-        )
-    else
-        return Formula(formula_string)
+        elseif haskey(a, "t") && a["t"] == "shared"
+
+            haskey(a, "si") || error("Expected shared formula to have an index. `si` attribute is missing: $c_child_element")
+
+            return FormulaReference(
+                parse(Int, a["si"]),
+            )
+        end
     end
+
+    return Formula(formula_string)
 end
 
+
 # Constructor with simple formula string for backward compatibility
 function Cell(ref::CellRef, datatype::String, style::String, value::String, formula::String)
     return Cell(ref, datatype, style, value, Formula(formula))
@@ -197,7 +219,6 @@ function getdata(ws::Worksheet, cell::Cell) :: CellValueType
             return _celldata_datetime(cell.value, isdate1904(ws))
 
         elseif !isempty(cell.style) && styles_is_float(ws, cell.style)
-
             # float
             return parse(Float64, cell.value)