Code Coverage for /home/graste/projects/environaut/src/Environaut/Config/Reader/Dom/DomElement.php

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total		0.00%	0 / 1		55.56%	10 / 18	CRAP		85.59%	95 / 111
DomElement		0.00%	0 / 1		55.56%	10 / 18	57.49		85.59%	95 / 111
__toString()					100.00%	1 / 1	1		100.00%	1 / 1
getName()					0.00%	0 / 1	2		0.00%	0 / 1
getValue()					100.00%	1 / 1	1		100.00%	1 / 1
getIterator()					100.00%	1 / 1	1		100.00%	1 / 1
getChildNodes()					0.00%	0 / 1	2.06		75.00%	3 / 4
getAttributeValue($name, $default_value = null)					100.00%	1 / 1	2		100.00%	5 / 5
getAttributes()					100.00%	1 / 1	2		100.00%	5 / 5
get($name)					0.00%	0 / 1	2.15		66.67%	2 / 3
has($name)					100.00%	1 / 1	1		100.00%	1 / 1
hasChild($name)					0.00%	0 / 1	2		0.00%	0 / 1
getChild($name)					0.00%	0 / 1	2		0.00%	0 / 5
hasChildren($name)					100.00%	1 / 1	1		100.00%	1 / 1
countChildren($name)					0.00%	0 / 1	5.27		77.78%	14 / 18
getChildren($name)					100.00%	1 / 1	4		100.00%	16 / 16
hasParameters()					0.00%	0 / 1	2.15		66.67%	2 / 3
getParameters(array $default = array(), $literalize = true)					100.00%	1 / 1	7		100.00%	18 / 18
getLiteralValue($element)					0.00%	0 / 1	7.10		87.50%	14 / 16
literalize($value)					100.00%	1 / 1	9		100.00%	11 / 11

1	<?php
2
3	namespace Environaut\Config\Reader\Dom;
4
5	/**
6	* Custom \DOMElement implementation for Environaut to have some
7	* convenience methods to get child nodes etc. Please be aware, that
8	* by default these methods use the Environaut default namespace URI.
9	*
10	* @todo make namespace URI configurable for convenience methods
11	*/
12	class DomElement extends \DOMElement implements \IteratorAggregate
13	{
14	/**
15	* @var DomDocument
16	*/
17	protected $ownerDocument;
18
19	/**
20	* Returns the nodeValue of the element.
21	*
22	* @return string nodeValue of the element
23	*/
24	public function __toString()
25	{
26	return $this->getValue();
27	}
28
29	/**
30	* Returns the nodeName of the element.
31	*
32	* @return string nodeName of the element
33	*/
34	public function getName()
35	{
36	return $this->nodeName;
37	}
38
39	/**
40	* Returns the nodeValue of the element.
41	*
42	* @return string nodeValue of the element
43	*/
44	public function getValue()
45	{
46	return $this->nodeValue;
47	}
48
49	/**
50	* Returns a \DOMNodeList of all child elements of the element.
51	*
52	* @return \DOMNodeList (Traversable) of all child elements
53	*/
54	public function getIterator()
55	{
56	return $this->getChildNodes();
57	}
58
59	/**
60	* Returns a \DOMNodeList of all child elements of the element.
61	*
62	* @return \DOMNodeList of all child elements
63	*/
64	public function getChildNodes()
65	{
66	$prefix = $this->ownerDocument->getDefaultNamespacePrefix();
67
68	if ($prefix) {
69	return $this->ownerDocument->getXpath()->query(sprintf('child::%s:*', $prefix), $this);
70	} else {
71	return $this->ownerDocument->getXpath()->query('child::*', $this);
72	}
73	}
74
75	/**
76	* Returns the value of the given attribute or returns the given
77	* default value if the attribute is missing.
78	*
79	* @param string $name name of attribute
80	* @param mixed $default_value value to return if attribute is missing
81	*
82	* @return mixed string value of attribute or default_value if attribute is not found or empty
83	*/
84	public function getAttributeValue($name, $default_value = null)
85	{
86	$value = parent::getAttribute($name);
87
88	if ($value === '') {
89	$value = $default_value;
90	}
91
92	return $value;
93	}
94
95	/**
96	* Returns all attributes including their values for the element.
97	*
98	* @return array of attributes (name => value pairs)
99	*/
100	public function getAttributes()
101	{
102	$attributes = array();
103
104	foreach ($this->ownerDocument->getXpath()->query('@*', $this) as $attribute) {
105	$attributes[$attribute->localName] = $attribute->nodeValue;
106	}
107
108	return $attributes;
109	}
110
111	/**
112	* Returns all child elements of the given name or all children
113	* of the element if name is not specified.
114	*
115	* @param string $name name of child elements to get
116	*
117	* @return \DOMNodeList of all children
118	*/
119	public function get($name)
120	{
121	if (!$name) {
122	return $this->getChildNodes();
123	}
124
125	return $this->getChildren($name);
126	}
127
128	/**
129	* Determines whether there are children of the element
130	* with the given name.
131	*
132	* @param string $name name of child element to check
133	*
134	* @return bool true if children of that name exist on the element
135	*/
136	public function has($name)
137	{
138	return $this->hasChildren($name);
139	}
140
141	/**
142	* Determines whether there's at least one child node with the given name.
143	*
144	* @param string $name name of child node
145	*
146	* @return bool true, if a first child with that name exists
147	*/
148	public function hasChild($name)
149	{
150	return $this->getChild($name) !== null;
151	}
152
153	/**
154	* Returns first child of the element with the given name.
155	*
156	* @param string $name name of element to get
157	*
158	* @return \DOMNode first child node with the given name
159	*/
160	public function getChild($name)
161	{
162	$query = 'self::node()[count(child::[local-name() = "%1$s" and namespace-uri() = "%2$s"]) = 1]/' .
163	'[local-name() = "%1$s" and namespace-uri() = "%2$s"]';
164
165	$node = $this->ownerDocument->getXpath()->query(
166	sprintf($query, $name, $this->ownerDocument->getDefaultNamespaceUri()),
167	$this
168	)->item(0);
169
170	return $node;
171	}
172
173	/**
174	* Determines whether there are children of the element
175	* with the given name.
176	*
177	* @param string $name name of child element to check
178	*
179	* @return bool true if children of that name exist on the element
180	*/
181	public function hasChildren($name)
182	{
183	return $this->countChildren($name) !== 0;
184	}
185
186	/**
187	* Returns the count of the children with the given name.
188	* Special handling for the following names is implemented:
189	* - 'paramaters' returns count of all direct 'parameters' OR all 'parameters/parameter' child nodes
190	* - 'formatters' returns count of all direct 'formatters' OR all 'formatters/formatter' child nodes
191	*
192	* @param string $name element name
193	*
194	* @return int number of child elements of the given name
195	*/
196	public function countChildren($name)
197	{
198	$query = '';
199	$singular_name = null;
200
201	// special nodes of environaut config files where the surrounding plural node
202	// may be omitted and the singular nodes be used directly (for less verbose xml)
203	if (in_array($name, array('parameters', 'formatters'))) {
204
205	if ($name === 'parameters') {
206	$singular_name = 'parameter';
207	} elseif ($name === 'formatters') {
208	$singular_name = 'formatter';
209	}
210
211	$query = 'count(child::*[local-name() = "%2$s" and namespace-uri() = "%3$s"]) + ' .
212	'count(child::[local-name() = "%1$s" and namespace-uri() = "%3$s"]/' .
213	'[local-name() = "%2$s" and namespace-uri() = "%3$s"])';
214	} elseif (empty($name)) {
215	$query = 'count(child::*[namespace-uri() = "%3$s"])';
216	} else {
217	$query = 'count(child::*[local-name() = "%1$s" and namespace-uri() = "%3$s"])';
218	}
219
220	$count = (int) $this->ownerDocument->getXpath()->evaluate(
221	sprintf($query, $name, $singular_name, $this->ownerDocument->getDefaultNamespaceUri()),
222	$this
223	);
224
225	return $count;
226	}
227
228	/**
229	* Returns all child elements of the given name. Special handling for the following names is implemented:
230	* - 'paramaters' returns all direct 'parameters' OR all 'parameters/parameter' child nodes
231	* - 'formatters' returns all direct 'formatters' OR all 'formatters/formatter' child nodes
232	*
233	* @param string $name name of child element
234	*
235	* @return \DOMNodeList of all child elements with the given name in the default namespace
236	*/
237	public function getChildren($name)
238	{
239	$query = '';
240	$singular_name = null;
241
242	// special nodes of environaut config files where the surrounding plural node
243	// may be omitted and the singular nodes be used directly (for less verbose xml)
244	if (in_array($name, array('parameters', 'formatters'))) {
245
246	if ($name === 'parameters') {
247	$singular_name = 'parameter';
248	} elseif ($name === 'formatters') {
249	$singular_name = 'formatter';
250	}
251
252	$query = 'child::*[local-name() = "%2$s" and namespace-uri() = "%3$s"] \| ' .
253	'child::[local-name() = "%1$s" and namespace-uri() = "%3$s"]/' .
254	'[local-name() = "%2$s" and namespace-uri() = "%3$s"]';
255	} else {
256	$query = 'child::*[local-name() = "%1$s" and namespace-uri() = "%3$s"]';
257	}
258
259	$nodes = $this->ownerDocument->getXpath()->query(
260	sprintf($query, $name, $singular_name, $this->ownerDocument->getDefaultNamespaceUri()),
261	$this
262	);
263
264	return $nodes;
265	}
266
267	/**
268	* Determine whether there's a 'parameters' element as child of the element.
269	*
270	* @return boolean true if there is a 'parameters' element
271	*/
272	public function hasParameters()
273	{
274	if ($this->ownerDocument->isEnvironautDocument()) {
275	return $this->has('parameters');
276	}
277
278	return false;
279	}
280
281	/**
282	* Returns all (nested) parameters of the element as an associative array.
283	*
284	* @param array $default array to be used as default
285	* @param boolean $literalize whether or not to literalize values like 'true'/'false' by default
286	*
287	* @return array of associative nested parameters (numerical keys where a 'name' attribute is missing)
288	*/
289	public function getParameters(array $default = array(), $literalize = true)
290	{
291	$offset = 0;
292
293	if ($this->ownerDocument->isEnvironautDocument()) {
294	$elements = $this->get('parameters');
295	foreach ($elements as $element) {
296
297	$name = null;
298	if (!$element->hasAttribute('name')) {
299	$name = $offset++;
300	$default[$name] = null;
301	} else {
302	$name = $element->getAttributeValue('name');
303	}
304
305	if ($element->hasParameters()) {
306	$default[$name] = isset($default[$name]) && is_array($default[$name]) ? $default[$name] : array();
307	$default[$name] = $element->getParameters($default[$name], $literalize);
308	} else {
309	$default[$name] = $this->getLiteralValue($element);
310	}
311	}
312	}
313
314	return $default;
315	}
316
317	/**
318	* Depending on the values of the 'literalize' and 'space' attributes of the element
319	* the transformed or literal value of the value is returned
320	*
321	* @param \DOMNode $element element to get a value for
322	*
323	* @return mixed literalized and/or whitespace preserved value or null if value is empty
324	*/
325	protected function getLiteralValue($element)
326	{
327	$value = $element->getValue();
328	$trimmed_value = trim($value);
329
330	$preserve_whitespace = $element->getAttributeValue('space', 'default') === 'preserve';
331	$literalize_value = self::literalize($element->getAttributeValue('literalize')) !== false;
332
333	if ($literalize_value) {
334	if ($preserve_whitespace && ($trimmed_value === '' \|\| $value !== $trimmed_value)) {
335	$value = $value;
336	} else {
337	$value = self::literalize($trimmed_value);
338	}
339	} elseif (!$preserve_whitespace) {
340	$value = $trimmed_value;
341	if ($value === '') {
342	$value = null;
343	}
344	}
345
346	return $value;
347	}
348
349	/**
350	* Returns the literalized value, that is:
351	* - 'on\|yes\|true' will be boolean TRUE
352	* - 'off\|no\|false' will be boolean FALSE
353	* - '' will be NULL
354	*
355	* All other non-string values will be returned as is.
356	*
357	* @param mixed $value value to literalize
358	*
359	* @return mixed null or boolean value or the original value of it's not a string
360	*/
361	public static function literalize($value)
362	{
363	if (!is_string($value)) {
364	return $value;
365	}
366
367	$value = trim($value);
368	if ($value == '') {
369	return null;
370	}
371
372	$lc_value = strtolower($value);
373	if ($lc_value === 'on' \|\| $lc_value === 'yes' \|\| $lc_value === 'true') {
374	return true;
375	} elseif ($lc_value === 'off' \|\| $lc_value === 'no' \|\| $lc_value === 'false') {
376	return false;
377	}
378
379	return $value;
380	}
381	}