LCOV - code coverage report
Current view: top level - src - Xml2JsonGData.dart (source / functions) Hit Total Coverage
Test: coverage.lcov Lines: 53 58 91.4 %
Date: 2017-07-14 Functions: 0 0 -

          Line data    Source code
       1             : /*
       2             :  * Package : xml2json
       3             :  * Author : S. Hamblett <steve.hamblett@linux.com>
       4             :  * Date   : 12/09/2013
       5             :  * Copyright :  S.Hamblett@OSCF
       6             :  *
       7             :  * GData conversion class.
       8             :  * 
       9             :  * This is Badgerfish except that it drops the @ symbol for attributes 
      10             :  * and uses $t instead of just $ for values, also the XML Processing element is
      11             :  * added at the top of the JSON output.
      12             :  * 
      13             :  */
      14             : 
      15             : part of xml2json;
      16             : 
      17             : class _Xml2JsonGData {
      18             :   final String _marker = '"\$t"';
      19             :   final String _xmlnsPrefix = '"xmlns"';
      20             :   final String _cdata = '"__cdata"';
      21             : 
      22             :   /// GData transformer function.
      23             : 
      24             :   Map _transform(XmlDocument node) {
      25           1 :     final json = {};
      26             : 
      27             :     void _process(var node, var obj, var ns) {
      28           1 :       if (node is XmlText) {
      29             :         /* Text node processing */
      30             :         final String sanitisedNodeData =
      31           2 :             _Xml2JsonUtils.escapeTextForJson(node.text);
      32           2 :         final String nodeData = '"' + sanitisedNodeData + '"';
      33           4 :         if (obj["$_marker"] is List) {
      34           0 :           obj["$_marker"].add(nodeData);
      35           4 :         } else if (obj["$_marker"] is Map) {
      36           0 :           obj["$_marker"] = [obj["$_marker"], nodeData];
      37             :         } else {
      38           3 :           obj["$_marker"] = nodeData;
      39             :         }
      40           1 :       } else if (node is XmlElement) {
      41             :         /* Element node processing */
      42           1 :         final p = {};
      43           2 :         String nodeName = "\"${node.name}\"";
      44           1 :         nodeName = nodeName.replaceAll(':', '\$');
      45             : 
      46           4 :         for (var i = 0; i < node.attributes.length; i++) {
      47           2 :           final attr = node.attributes[i];
      48           2 :           final name = attr.name.qualified;
      49           1 :           final value = attr.value;
      50           1 :           if (name == "xmlns") {
      51           4 :             ns["\"$name\""] = '"' + value + '"';
      52           2 :           } else if (name.indexOf("xmlns:") == 0) {
      53           1 :             String namePrefix = name.replaceAll(':', '\$');
      54           2 :             namePrefix = '"' + namePrefix + '"';
      55           3 :             ns[namePrefix] = '"' + value + '"';
      56             :           } else {
      57           1 :             final String indexName = '"$name"';
      58           3 :             p[indexName] = '"' + value + '"';
      59             :           }
      60             :         }
      61             : 
      62           1 :         if (ns.isNotEmpty) {
      63           3 :           for (var prefix in ns.keys) {
      64           2 :             if (!p.containsKey(_xmlnsPrefix)) {
      65           1 :               final List pList = new List<Map>();
      66           2 :               p[_xmlnsPrefix] = pList;
      67             :             }
      68           2 :             p[prefix] = ns[prefix];
      69             :           }
      70             :         }
      71             : 
      72           2 :         if (obj[nodeName] is List) {
      73           0 :           obj[nodeName].add(p);
      74           2 :         } else if (obj[nodeName] is Map) {
      75           3 :           obj[nodeName] = [obj[nodeName], p];
      76             :         } else {
      77           1 :           obj[nodeName] = p;
      78             :         }
      79             : 
      80           4 :         for (var j = 0; j < node.children.length; j++) {
      81           4 :           _process(node.children[j], p, {});
      82             :         }
      83           1 :       } else if (node is XmlDocument) {
      84             :         /* Document node processing */
      85           4 :         for (var k = 0; k < node.children.length; k++) {
      86           4 :           _process(node.children[k], obj, {});
      87             :         }
      88           1 :       } else if (node is XmlCDATA) {
      89             :         /* CDATA node processing */
      90             :         final String sanitisedNodeData =
      91           2 :             _Xml2JsonUtils.escapeTextForJson(node.text);
      92           2 :         final String nodeData = '"' + sanitisedNodeData + '"';
      93           3 :         obj["$_cdata"] = nodeData;
      94           1 :       } else if (node is XmlProcessing) {
      95             :         /* Processing node, only text in this node */
      96           1 :         final String processingString = node.text;
      97           1 :         final Map nodeMap = _Xml2JsonUtils.mapProcessingNode(processingString);
      98           3 :         for (String i in nodeMap.keys) {
      99           2 :           final String index = '"' + i + '"';
     100             :           final String sanitisedNodeData =
     101           2 :               _Xml2JsonUtils.escapeTextForJson(nodeMap[i]);
     102           2 :           final String nodeData = '"' + sanitisedNodeData + '"';
     103           1 :           obj[index] = nodeData;
     104             :         }
     105             :       }
     106             :     }
     107             : 
     108           2 :     _process(node, json, {});
     109             :     return json;
     110             :   }
     111             : 
     112             :   /// Transformer function
     113             :   String transform(XmlDocument xmlNode) {
     114             :     Map json = null;
     115             :     try {
     116           1 :       json = _transform(xmlNode);
     117             :     } catch (e) {
     118           0 :       throw new Xml2JsonException(
     119           0 :           "GData internal transform error => ${e.toString()}");
     120             :     }
     121           1 :     return json.toString();
     122             :   }
     123             : }

Generated by: LCOV version 1.10