fix issues #81 and #84 (PR #89)

* fix issues #81 and #84, remove lualint space warnings from xml2lua.lua file
* Version bump to 1.6-1

Signed-off-by: Manoel Campos <[email protected]>
Co-authored-by: Manoel Campos <[email protected]>

Author: nilzao

xml2lua-1.5-2.rockspec renamed to xml2lua-1.6-1.rockspec

@@ -1,8 +1,8 @@
 package = "xml2lua"
-version = "1.5-2"
+version = "1.6-1"
 source = {
    url = "git://github.com/manoelcampos/xml2lua",
-   tag = "v1.5-2"
+   tag = "v1.6-1"
 }
 description = {
    summary = "An XML Parser written entirely in Lua that works for Lua 5.1+",

xml2lua.lua

@@ -1,8 +1,8 @@
---- @module Module providing a non-validating XML stream parser in Lua. 
---  
+--- @module Module providing a non-validating XML stream parser in Lua.
+--
 --  Features:
 --  =========
---  
+--
 --      * Tokenises well-formed XML (relatively robustly)
 --      * Flexible handler based event API (see below)
 --      * Parses all XML Infoset elements - ie.
@@ -13,29 +13,29 @@
 --          - XML Decl
 --          - Processing Instructions
 --          - DOCTYPE declarations
---      * Provides limited well-formedness checking 
+--      * Provides limited well-formedness checking
 --        (checks for basic syntax & balanced tags only)
 --      * Flexible whitespace handling (selectable)
 --      * Entity Handling (selectable)
---  
+--
 --  Limitations:
 --  ============
---  
+--
 --      * Non-validating
---      * No charset handling 
---      * No namespace support 
+--      * No charset handling
+--      * No namespace support
 --      * Shallow well-formedness checking only (fails
 --        to detect most semantic errors)
---  
+--
 --  API:
 --  ====
 --
---  The parser provides a partially object-oriented API with 
+--  The parser provides a partially object-oriented API with
 --  functionality split into tokeniser and handler components.
---  
+--
 --  The handler instance is passed to the tokeniser and receives
 --  callbacks for each XML element processed (if a suitable handler
---  function is defined). The API is conceptually similar to the 
+--  function is defined). The API is conceptually similar to the
 --  SAX API but implemented differently.
 --
 --  XML data is passed to the parser instance through the 'parse'
@@ -49,7 +49,7 @@
 --
 --@author Paul Chakravarti ([email protected])
 --@author Manoel Campos da Silva Filho
-local xml2lua = {_VERSION = "1.5-2"}
+local xml2lua = { _VERSION = "1.6-1" }
 local XmlParser = require("XmlParser")
 
 ---Recursivelly prints a table in an easy-to-ready format
@@ -59,7 +59,7 @@ local function printableInternal(tb, level)
   if tb == nil then
      return
   end
-  
+
   level = level or 1
   local spaces = string.rep(' ', level*2)
   for k,v in pairs(tb) do
@@ -69,7 +69,7 @@ local function printableInternal(tb, level)
       else
          print(spaces .. k..'='..v)
       end
-  end  
+  end
 end
 
 ---Instantiates a XmlParser object to parse a XML string
@@ -79,16 +79,16 @@ end
 -- local handler = require("xmlhandler/tree").
 --@return a XmlParser object used to parse the XML
 --@see XmlParser
-function xml2lua.parser(handler)    
+function xml2lua.parser(handler)
     if handler == xml2lua then
         error("You must call xml2lua.parse(handler) instead of xml2lua:parse(handler)")
     end
 
-    local options = { 
+    local options = {
             --Indicates if whitespaces should be striped or not
-            stripWS = 1, 
+            stripWS = 1,
             expandEntities = 1,
-            errorHandler = function(errMsg, pos) 
+            errorHandler = function(errMsg, pos)
                 error(string.format("%s [char=%d]\n", errMsg or "Parse Error", pos))
             end
           }
@@ -114,10 +114,10 @@ function xml2lua.toString(t)
     end
 
     for k,v in pairs(t) do
-        if type(v) == 'table' then 
+        if type(v) == 'table' then
             v = xml2lua.toString(v)
         end
-        res = res .. sep .. string.format("%s=%s", k, v)    
+        res = res .. sep .. string.format("%s=%s", k, v)
         sep = ','
     end
     res = '{'..res..'}'
@@ -136,7 +136,7 @@ function xml2lua.loadFile(xmlFilePath)
         f:close()
         return content
     end
-    
+
     error(e)
 end
 
@@ -149,51 +149,114 @@ end
 local function attrToXml(attrTable)
   local s = ""
   attrTable = attrTable or {}
-  
+
   for k, v in pairs(attrTable) do
       s = s .. " " .. k .. "=" .. '"' .. v .. '"'
   end
   return s
 end
 
 ---Gets the first key of a given table
-local function getFirstKey(tb)
-   if type(tb) == "table" then
+local function getSingleChild(tb)
+  local count = 0
+  for _ in pairs(tb) do
+    count = count + 1
+  end
+  if (count == 1) then
       for k, _ in pairs(tb) do
           return k
       end
+  end
+  return nil
+end
+
+---Gets the first value of a given table
+local function getFirstValue(tb)
+  if type(tb) == "table" then
+    for _, v in pairs(tb) do
+      return v
+    end
       return nil
    end
 
    return tb
 end
 
---- Parses a given entry in a lua table
--- and inserts it as a XML string into a destination table.
--- Entries in such a destination table will be concatenated to generated
--- the final XML string from the origin table.
--- @param xmltb the destination table where the XML string from the parsed key will be inserted
--- @param tagName the name of the table field that will be used as XML tag name
--- @param fieldValue a field from the lua table to be recursively parsed to XML or a primitive value that will be enclosed in a tag name
--- @param level a int value used to include indentation in the generated XML from the table key
-local function parseTableKeyToXml(xmltb, tagName, fieldValue, level)
-    local spaces = string.rep(' ', level*2)
-
-    local strValue, attrsStr = "", ""
-    if type(fieldValue) == "table" then
-        attrsStr = attrToXml(fieldValue._attr)
-        fieldValue._attr = nil
-        --If after removing the _attr field there is just one element inside it,
-        --the tag was enclosing a single primitive value instead of other inner tags.
-        strValue = #fieldValue == 1 and spaces..tostring(fieldValue[1]) or xml2lua.toXml(fieldValue, tagName, level+1)
-        strValue = '\n'..strValue..'\n'..spaces
-    else
-        strValue = tostring(fieldValue)
+xml2lua.pretty = true
+
+function xml2lua.getSpaces(level)
+  local spaces = ''
+  if (xml2lua.pretty) then
+    spaces = string.rep(' ', level * 2)
+  end
+  return spaces
+end
+
+function xml2lua.addTagValueAttr(tagName, tagValue, attrTable, level)
+  local attrStr = attrToXml(attrTable)
+  local spaces = xml2lua.getSpaces(level)
+  if (tagValue == '') then
+    table.insert(xml2lua.xmltb, spaces .. '<' .. tagName .. attrStr .. '/>')
+  else
+    table.insert(xml2lua.xmltb, spaces .. '<' .. tagName .. attrStr .. '>' .. tostring(tagValue) .. '</' .. tagName .. '>')
+  end
+end
+
+function xml2lua.startTag(tagName, attrTable, level)
+  local attrStr = attrToXml(attrTable)
+  local spaces = xml2lua.getSpaces(level)
+  if (tagName ~= nil) then
+    table.insert(xml2lua.xmltb, spaces .. '<' .. tagName .. attrStr .. '>')
+  end
+end
+
+function xml2lua.endTag(tagName, level)
+  local spaces = xml2lua.getSpaces(level)
+  if (tagName ~= nil) then
+    table.insert(xml2lua.xmltb, spaces .. '</' .. tagName .. '>')
+  end
+end
+
+function xml2lua.isChildArray(obj)
+  for tag, _ in pairs(obj) do
+    if (type(tag) == 'number') then
+      return true
     end
+  end
+  return false
+end
 
-    table.insert(xmltb, spaces..'<'..tagName.. attrsStr ..'>'..strValue..'</'..tagName..'>')
+function xml2lua.isTableEmpty(obj)
+  for k, _ in pairs(obj) do
+    if (k ~= '_attr') then
+      return false
+    end
+  end
+  return true
 end
 
+function xml2lua.parseTableToXml(obj, tagName, level)
+  if (tagName ~= '_attr') then
+    if (type(obj) == 'table') then
+      if (xml2lua.isChildArray(obj)) then
+        for _, value in pairs(obj) do
+          xml2lua.parseTableToXml(value, tagName, level)
+        end
+      elseif xml2lua.isTableEmpty(obj) then
+        xml2lua.addTagValueAttr(tagName, "", obj._attr, level)
+      else
+        xml2lua.startTag(tagName, obj._attr, level)
+        for tag, value in pairs(obj) do
+          xml2lua.parseTableToXml(value, tag, level + 1)
+        end
+        xml2lua.endTag(tagName, level)
+      end
+    else
+      xml2lua.addTagValueAttr(tagName, obj, nil, level)
+    end
+  end
+    end
+
 ---Converts a Lua table to a XML String representation.
 --@param tb Table to be converted to XML
 --@param tableName Name of the table variable given to this function,
@@ -203,52 +266,21 @@ end
 --
 --@return a String representing the table content in XML
 function xml2lua.toXml(tb, tableName, level)
-  level = level or 1
-  local firstLevel = level
-  tableName = tableName or ''
-  local xmltb = (tableName ~= '' and level == 1) and {'<'..tableName..attrToXml(tb._attr)..'>'} or {}
-  tb._attr = nil
-
-  for k, v in pairs(tb) do
-      if type(v) == 'table' then
-         -- If the key is a number, the given table is an array and the value is an element inside that array.
-         -- In this case, the name of the array is used as tag name for each element.
-         -- So, we are parsing an array of objects, not an array of primitives.
-         if type(k) == 'number' then
-            parseTableKeyToXml(xmltb, tableName, v, level)
-         else
-            level = level + 1
-            -- If the type of the first key of the value inside the table
-            -- is a number, it means we have a HashTable-like structure,
-            -- in this case with keys as strings and values as arrays.
-            if type(getFirstKey(v)) == 'number' then
-                for sub_k, sub_v in pairs(v) do
-                    if sub_k ~= '_attr' then
-                      local sub_v_with_attr = type(v._attr) == 'table' and { sub_v, _attr = v._attr } or sub_v
-                      parseTableKeyToXml(xmltb, k, sub_v_with_attr, level)
-                    end
-                end
+  xml2lua.xmltb = {}
+  level = level or 0
+  local singleChild = getSingleChild(tb)
+  tableName = tableName or singleChild
+
+  if (singleChild) then
+    xml2lua.parseTableToXml(getFirstValue(tb), tableName, level)
             else
-               -- Otherwise, the "HashTable" values are objects
-               parseTableKeyToXml(xmltb, k, v, level)
-            end
-         end
-      else
-         -- When values are primitives:
-         -- If the type of the key is number, the value is an element from an array.
-         -- In this case, uses the array name as the tag name.
-         if type(k) == 'number' then
-            k = tableName
-         end
-         parseTableKeyToXml(xmltb, k, v, level)
-      end
+    xml2lua.parseTableToXml(tb, tableName, level)
   end
 
-  if tableName ~= '' and firstLevel == 1 then
-      table.insert(xmltb, '</'..tableName..'>\n')
+  if (xml2lua.pretty) then
+    return table.concat(xml2lua.xmltb, '\n')
   end
-
-  return table.concat(xmltb, '\n')
+  return table.concat(xml2lua.xmltb)
 end
 
 return xml2lua