Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
0.00%
0 / 68
0.00%
0 / 8
 CRAP
0.00%
0 / 1
XMLParser
0.00%
0 / 68
0.00%
0 / 8
 870
0.00%
0 / 1
 encode
0.00%
0 / 17
0.00%
0 / 1
 56
 objectToArray
0.00%
0 / 5
0.00%
0 / 1
 12
 _validateEncodeData
0.00%
0 / 7
0.00%
0 / 1
 12
 _addChildren
0.00%
0 / 26
0.00%
0 / 1
 72
 _formatName
0.00%
0 / 7
0.00%
0 / 1
 2
 _formatValue
0.00%
0 / 2
0.00%
0 / 1
 12
 _bool
0.00%
0 / 1
0.00%
0 / 1
 6
 decode
0.00%
0 / 3
0.00%
0 / 1
 6
1<?php
2namespace XMLParser;
3use Exception;
4use InvalidArgumentException;
5use SimpleXMLElement;
6class XMLParser {
7    private static $_defaultRootNode = 'root';
8    private static $_defaultListNode = 'list';
9    private static $_defaultItemNode = 'item';
10    private static $_defaultEncoding = 'UTF-8';
11    private static $_defaultVersion  = '1.0';
12    private static $_defaultAttrTag  = 'attr:';
13    public static function encode ($data, $root = null)
14    {
15        if ($data instanceof SimpleXMLElement) {
16            return $data;
17        }
18        try {
19            $data = self::_validateEncodeData($data);
20            $version = self::$_defaultVersion;
21            $encoding  = self::$_defaultEncoding;
22            $xml_string = "<?xml version=\"{$version}\" encoding=\"{$encoding}\" ?>";
23            $node = self::_formatName( is_null($root) ?
24                self::$_defaultRootNode :
25                $root);
26            $value = ($is_array = is_array($data)) ? NULL : self::_formatValue($data);
27            $xml_string .= "<$node>$value</$node>";
28            $xml = new SimpleXMLElement($xml_string);
29            if ($is_array) {
30                $xml = self::_addChildren($xml,$data);
31            }
32        }
33        catch (Exception $e) {
34            trigger_error($e->getMessage(), E_USER_ERROR);
35        }
36        return isset($xml) ? $xml : null; // isset() essentially to make editor happy.
37    }
38    public static function objectToArray($std) {
39        if (is_object($std)) {
40            $std = get_object_vars($std);
41        }
42        if (is_array($std)) {
43            return array_map(['self','objectToArray'], $std);
44        }
45        else {
46            return $std;
47        }
48    }
49    private static function _validateEncodeData ($data)
50    {
51        if(is_object($data)){ // Try conversion
52            $data = self::objectToArray($data);
53        }
54        if (is_object($data)) { // If it's still an object throw exception
55            throw new InvalidArgumentException(
56                "Invalid data type supplied for XMLParser::encode"
57            );
58        }
59        return $data;
60    }
61    private static function _addChildren (SimpleXMLElement $element, $data)
62    {
63        foreach ($data as $key => $value) {
64            $regex = '/^'.self::$_defaultAttrTag.'([a-z0-9\._-]*)/';
65            $is_attr = preg_match($regex, $key, $attr);
66            if ($is_attr) {
67                if (is_array($value)) {
68                    foreach( $value as $k=>$v ) {
69                        $element->addAttribute(
70                            self::_formatName($k),
71                            self::_formatValue($v));
72                    }
73                } else {
74                    $element->addAttribute(
75                        self::_formatName($attr[1]),
76                        self::_formatValue($value)
77                    );
78                }
79                continue;
80            }
81            $node = self::_formatName(
82                is_numeric($key) ?
83                    (is_array($value) ?
84                        self::$_defaultListNode :
85                        self::$_defaultItemNode) : $key
86            );
87            if (is_array($value)) {
88                $child = $element->addChild($node);
89                self::_addChildren($child,$value);
90                continue;
91            }
92            $element->addChild($node, $value);
93        }
94        return $element;
95    }
96    private static function _formatName ($string)
97    {
98        $p = [
99            '/[^a-z0-9\._ -]/i' => '',
100            '/(?=^[[0-9]\.\-\:^xml])/i' => self::$_defaultItemNode.'_',
101            '/ /' => '_'
102        ];
103        $string = preg_replace(array_keys($p), array_values($p), $string);
104        return strtolower($string);
105    }
106    private static function _formatValue ($string)
107    {
108        $string = is_null($string) ? 'NULL' : $string;
109        return is_bool($string) ? self::_bool($string) : $string;
110    }
111    private static function _bool ($bool)
112    {
113        return $bool ? 'TRUE' : 'FALSE';
114    }
115    public static function decode ($xml)
116    {
117        if (!$xml instanceof SimpleXMLElement)
118        {
119            $xml = new SimpleXMLElement($xml);
120        }
121        return json_decode(json_encode($xml),false);
122    }
123}