QuiteSimpleXMLElement::children() - Code Metrics - Inspection of "chore: simplify code, remove php 5.3 support" - danmichaelo/quitesimplexmlelement - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5bfc48...6d45fd )

by Dan Michael O.

created 2016-08-11 18:12 UTC

QuiteSimpleXMLElement::children() A

↳ Parent: QuiteSimpleXMLElement

Complexity

Conditions	3
Paths	4

Size

Total Lines	12
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	1	Features	1

Metric	Value
cc	3
eloc	8
c	5
b	1
f	1
nc	4
nop	1
dl	0
loc	12
rs	9.4285

<?php
/*
 * (c) Dan Michael O. Heggø (2013)
 *
 * QuiteSimpleXMLElement is a wrapper around SimpleXMLElement to add a quite simple
 * feature not present in SimpleXMLElement: inheritance of namespaces.
 *
 * My first attempt was to extend the original SimpleXMLElement class, but
 * unfortunately the constructor is static and cannot be overriden!
 *
 * It's easier to understand with a simple example:
 *
 *     $xml = '<root xmlns:dc="http://purl.org/dc/elements/1.1/">
 *         <dc:a>
 *           <dc:b >
 *             1.9
 *           </dc:a>
 *         </dc:b>
 *       </root>';
 *
 *     $root = new SimpleXMLElement($xml);
 *     $root->registerXPathNamespace('d', 'http://purl.org/dc/elements/1.1/');
 *     $a = $root->xpath('d:a');
 *     $a[0]->registerXPathNamespace('d', 'http://purl.org/dc/elements/1.1/');
 *     $b = $a[0]->xpath('d:b');
 *     echo trim((string)$b[0]);
 *
 * Since namespaces are not inherited, we have to register them over and over again.
 * Using QuiteSimpleXMLElement instead;
 *
 *     $root = new QuiteSimpleXMLElement($xml);
 *     $root->registerXPathNamespace('d', 'http://purl.org/dc/elements/1.1/');
 *     $a = $root->xpath('d:a');
 *     $b = $a->xpath('d:b');
 *     echo trim((string)$b[0]);
 *
 * And while we're at it, we can add a few convenience methods...
 */

namespace Danmichaelo\QuiteSimpleXMLElement;

class InvalidXMLException extends \Exception
{

    public function __construct($message = null, $code = 0, Exception $previous = null)
    {
        parent::__construct($message, $code, $previous);
    }
}

class QuiteSimpleXMLElement
{
    public $namespaces;
    public $el;

    #
    # See https://github.com/draffter/FollowFunctionPHP/blob/master/_php/SimpleXML.php
    # for list of functions with arguments
    #
    public function __construct($elem, $inherit_from=null)
    {
        $this->namespaces = array();

        if (gettype($elem) == 'string') {
            try {
                $this->el = new \SimpleXMLElement($elem);
            } catch (\Exception $e) {
                throw new InvalidXMLException("Invalid XML encountered: " . $elem);
            }
        } elseif (gettype($elem) == 'object') {
            if (in_array(get_class($elem), array('Danmichaelo\QuiteSimpleXMLElement\QuiteSimpleXMLElement', 'SimpleXMLElement'))) {
                $this->el = $elem; // assume it's a SimpleXMLElement
            } else {
                throw new \InvalidArgumentException('Unknown object given to QuiteSimpleXMLElement. Expected SimpleXMLElement or QuiteSimpleXMLElement.');
            }
        } else {
            throw new \InvalidArgumentException('QuiteSimpleXMLElement expects a string or a QuiteSimpleXMLElement/SimpleXMLElement object.');
        }

        if ($inherit_from != null) {
            foreach ($inherit_from->namespaces as $prefix => $uri) {
                $this->registerXPathNamespace($prefix, $uri);
            }
        } else {
            $this->namespaces = $this->el->getNamespaces(true);
        }
    }

    public function registerXPathNamespace($prefix, $uri)
    {
        $this->el->registerXPathNamespace($prefix, $uri);
        $this->namespaces[$prefix] = $uri;
    }

    public function registerXPathNamespaces($namespaces)
    {
        # Convenience method to add multiple namespaces at once
        foreach ($namespaces as $prefix => $uri) {
            $this->registerXPathNamespace($prefix, $uri);
        }
    }

    /*
     * Convenience method for getting the text of the first
     * node matching an xpath. The text is trimmed by default,
     * but setting the second argument to false will return
     * the untrimmed text.
     */
    public function text($path = '.', $trim=true)
    {
        $text = strval($this->first($path));

        return $trim ? trim($text) : $text;
    }

    /*
     * Convenience method for getting an attribute of a node
     */
    public function attr($attribute)
    {
        return trim((string) $this->el->attributes()->{$attribute});
    }

    public function first($path)
    {
        # Convenience method
        $x = $this->xpath($path);

        return count($x) ? $x[0] : null;
    }

    /*
     * Convenience method for checking if a node exists
     */
    public function has($path)
    {
        $x = $this->xpath($path);

        return count($x) ? true : false;
    }

    public function el()
    {
        return $this->el;
    }

    /**
     * Returns an array of QuiteSimpleXMLElement instances.
     *
     * @param $path
     * @return QuiteSimpleXMLElement[]
     */
    public function xpath($path)
    {
        return array_map(function($el)  {
            return new QuiteSimpleXMLElement($el, $this);
        }, $this->el->xpath($path));
    }

    /**
     * Alias for xpath().
     *
     * @param $path
     * @return QuiteSimpleXMLElement[]
     */
    public function all($path)
    {
        return $this->xpath($path);
    }

    /**
     * Returns the *untrimmed* text content of the node
     */
    public function __toString()
    {
        return (string) $this->el;
    }

    /* The original children and count methods are quite flawed. The count() method
       only return the count of children _with no namespace_. The children() method
       can take namespace prefix as argument, but doesn't use the document's prefixes,
       not the registered ones.

       And it returns a "pseudo array" instead of a real iterator... making it quite hard
       to work with, there's no next() method for instance...
       We're returning a real array instead, even though that might not be what you want
       in _all_ situations.

       An alternative could be to use xpath('child::node()')
    */
    public function children($ns = null)
    {
        $ch = $ns
            ? $this->el->children($this->namespaces[$ns])
            : $this->el->children();
        $o = array();
        foreach ($ch as $c) {
            $o[] = new QuiteSimpleXMLElement($c, $this);
        }

        return $o;
    }
    public function count($ns = null)
    {
        return $ns
            ? count($this->el->children($this->namespaces[$ns]))
            : count($this->el->children());
    }

    public function attributes()
    {
        return $this->el->attributes();
    }
    public function asXML()
    {
        return $this->el->asXML();
    }
    public function getName()
    {
        return $this->el->getName();
    }
    public function getNamespaces($recursive = false)
    {
        return $this->el->getNamespaces($recursive);
    }

    /**
     * Set the node value
     */
    public function setValue($value)
    {
        $this->el[0] = $value;
    }

    public function asDOMElement()
    {
        return dom_import_simplexml($this->el);
    }

    /**
     * Replaces the current node. Thanks to @hakre
     * <http://stackoverflow.com/questions/17661167/how-to-replace-xml-node-with-simplexmlelement-php>
     */
    public function replace(QuiteSimpleXMLElement $element)
    {
        $oldNode = $this->asDOMElement();
        $newNode = $oldNode->ownerDocument->importNode(
            $element->asDOMElement(),
            true
        );
        $oldNode->parentNode->replaceChild($newNode, $oldNode);
    }

    public static function make($input, $ns = array())
    {
        $elem = new QuiteSimpleXMLElement($input);
        $elem->registerXPathNamespaces($ns);
        return $elem;
    }
}


1			<?php
2			/*
3			* (c) Dan Michael O. Heggø (2013)
4			*
5			* QuiteSimpleXMLElement is a wrapper around SimpleXMLElement to add a quite simple
6			* feature not present in SimpleXMLElement: inheritance of namespaces.
7			*
8			* My first attempt was to extend the original SimpleXMLElement class, but
9			* unfortunately the constructor is static and cannot be overriden!
10			*
11			* It's easier to understand with a simple example:
12			*
13			* $xml = '<root xmlns:dc="http://purl.org/dc/elements/1.1/">
14			* <dc:a>
15			* <dc:b >
16			* 1.9
17			* </dc:a>
18			* </dc:b>
19			* </root>';
20			*
21			* $root = new SimpleXMLElement($xml);
22			* $root->registerXPathNamespace('d', 'http://purl.org/dc/elements/1.1/');
23			* $a = $root->xpath('d:a');
24			* $a[0]->registerXPathNamespace('d', 'http://purl.org/dc/elements/1.1/');
25			* $b = $a[0]->xpath('d:b');
26			* echo trim((string)$b[0]);
27			*
28			* Since namespaces are not inherited, we have to register them over and over again.
29			* Using QuiteSimpleXMLElement instead;
30			*
31			* $root = new QuiteSimpleXMLElement($xml);
32			* $root->registerXPathNamespace('d', 'http://purl.org/dc/elements/1.1/');
33			* $a = $root->xpath('d:a');
34			* $b = $a->xpath('d:b');
35			* echo trim((string)$b[0]);
36			*
37			* And while we're at it, we can add a few convenience methods...
38			*/
39
40			namespace Danmichaelo\QuiteSimpleXMLElement;
41
42			class InvalidXMLException extends \Exception
43			{
44
45			public function __construct($message = null, $code = 0, Exception $previous = null)
46			{
47			parent::__construct($message, $code, $previous);
48			}
49			}
50
51			class QuiteSimpleXMLElement
52			{
53			public $namespaces;
54			public $el;
55
56			#
57			# See https://github.com/draffter/FollowFunctionPHP/blob/master/_php/SimpleXML.php
58			# for list of functions with arguments
59			#
60			public function __construct($elem, $inherit_from=null)
61			{
62			$this->namespaces = array();
63
64			if (gettype($elem) == 'string') {
65			try {
66			$this->el = new \SimpleXMLElement($elem);
67			} catch (\Exception $e) {
68			throw new InvalidXMLException("Invalid XML encountered: " . $elem);
69			}
70			} elseif (gettype($elem) == 'object') {
71			if (in_array(get_class($elem), array('Danmichaelo\QuiteSimpleXMLElement\QuiteSimpleXMLElement', 'SimpleXMLElement'))) {
72			$this->el = $elem; // assume it's a SimpleXMLElement
73			} else {
74			throw new \InvalidArgumentException('Unknown object given to QuiteSimpleXMLElement. Expected SimpleXMLElement or QuiteSimpleXMLElement.');
75			}
76			} else {
77			throw new \InvalidArgumentException('QuiteSimpleXMLElement expects a string or a QuiteSimpleXMLElement/SimpleXMLElement object.');
78			}
79
80			if ($inherit_from != null) {
81			foreach ($inherit_from->namespaces as $prefix => $uri) {
82			$this->registerXPathNamespace($prefix, $uri);
83			}
84			} else {
85			$this->namespaces = $this->el->getNamespaces(true);
86			}
87			}
88
89			public function registerXPathNamespace($prefix, $uri)
90			{
91			$this->el->registerXPathNamespace($prefix, $uri);
92			$this->namespaces[$prefix] = $uri;
93			}
94
95			public function registerXPathNamespaces($namespaces)
96			{
97			# Convenience method to add multiple namespaces at once
98			foreach ($namespaces as $prefix => $uri) {
99			$this->registerXPathNamespace($prefix, $uri);
100			}
101			}
102
103			/*
104			* Convenience method for getting the text of the first
105			* node matching an xpath. The text is trimmed by default,
106			* but setting the second argument to false will return
107			* the untrimmed text.
108			*/
109			public function text($path = '.', $trim=true)
110			{
111			$text = strval($this->first($path));
112
113			return $trim ? trim($text) : $text;
114			}
115
116			/*
117			* Convenience method for getting an attribute of a node
118			*/
119			public function attr($attribute)
120			{
121			return trim((string) $this->el->attributes()->{$attribute});
122			}
123
124			public function first($path)
125			{
126			# Convenience method
127			$x = $this->xpath($path);
128
129			return count($x) ? $x[0] : null;
130			}
131
132			/*
133			* Convenience method for checking if a node exists
134			*/
135			public function has($path)
136			{
137			$x = $this->xpath($path);
138
139			return count($x) ? true : false;
140			}
141
142			public function el()
143			{
144			return $this->el;
145			}
146
147			/**
148			* Returns an array of QuiteSimpleXMLElement instances.
149			*
150			* @param $path
151			* @return QuiteSimpleXMLElement[]
152			*/
153			public function xpath($path)
154			{
155			return array_map(function($el) {
156			return new QuiteSimpleXMLElement($el, $this);
157			}, $this->el->xpath($path));
158			}
159
160			/**
161			* Alias for xpath().
162			*
163			* @param $path
164			* @return QuiteSimpleXMLElement[]
165			*/
166			public function all($path)
167			{
168			return $this->xpath($path);
169			}
170
171			/**
172			* Returns the untrimmed text content of the node
173			*/
174			public function __toString()
175			{
176			return (string) $this->el;
177			}
178
179			/* The original children and count methods are quite flawed. The count() method
180			only return the count of children _with no namespace_. The children() method
181			can take namespace prefix as argument, but doesn't use the document's prefixes,
182			not the registered ones.
183
184			And it returns a "pseudo array" instead of a real iterator... making it quite hard
185			to work with, there's no next() method for instance...
186			We're returning a real array instead, even though that might not be what you want
187			in _all_ situations.
188
189			An alternative could be to use xpath('child::node()')
190			*/
191			public function children($ns = null)
192			{
193			$ch = $ns
194			? $this->el->children($this->namespaces[$ns])
195			: $this->el->children();
196			$o = array();
197			foreach ($ch as $c) {
198			$o[] = new QuiteSimpleXMLElement($c, $this);
199			}
200
201			return $o;
202			}
203			public function count($ns = null)
204			{
205			return $ns
206			? count($this->el->children($this->namespaces[$ns]))
207			: count($this->el->children());
208			}
209
210			public function attributes()
211			{
212			return $this->el->attributes();
213			}
214			public function asXML()
215			{
216			return $this->el->asXML();
217			}
218			public function getName()
219			{
220			return $this->el->getName();
221			}
222			public function getNamespaces($recursive = false)
223			{
224			return $this->el->getNamespaces($recursive);
225			}
226
227			/**
228			* Set the node value
229			*/
230			public function setValue($value)
231			{
232			$this->el[0] = $value;
233			}
234
235			public function asDOMElement()
236			{
237			return dom_import_simplexml($this->el);
238			}
239
240			/**
241			* Replaces the current node. Thanks to @hakre
242			* <http://stackoverflow.com/questions/17661167/how-to-replace-xml-node-with-simplexmlelement-php>
243			*/
244			public function replace(QuiteSimpleXMLElement $element)
245			{
246			$oldNode = $this->asDOMElement();
247			$newNode = $oldNode->ownerDocument->importNode(
248			$element->asDOMElement(),
249			true
250			);
251			$oldNode->parentNode->replaceChild($newNode, $oldNode);
252			}
253
254			public static function make($input, $ns = array())
255			{
256			$elem = new QuiteSimpleXMLElement($input);
257			$elem->registerXPathNamespaces($ns);
258			return $elem;
259			}
260			}
261

danmichaelo / quitesimplexmlelement

Push — master ( 5bfc48...6d45fd )

QuiteSimpleXMLElement::children() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like