Row::getHydratedFieldName() - Code Metrics - Inspection of "Add the Row with field name case insensitive" - byjg/anydataset - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#10)

by Joao

created 2022-05-16 16:39 UTC

Row::getHydratedFieldName() A

↳ Parent: Row

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

Metric	Value
eloc	3
dl	0
loc	7
ccs	4
cts	4
cp	1
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	1
crap	2

<?php

namespace ByJG\AnyDataset\Core;

use ByJG\Serializer\BinderObject;
use ByJG\Serializer\DumpToArrayInterface;
use ByJG\Util\XmlUtil;
use UnexpectedValueException;

class Row extends BinderObject implements DumpToArrayInterface
{

    /**
     * \DOMNode represents a Row
     * @var \DOMElement
     */
    private $node = null;
    private $row = null;
    private $originalRow = null;

    protected $fieldNameCaseSensitive = true;

    /**
     * Row constructor
     *
     * @param array()
     * @throws \ByJG\Serializer\Exception\InvalidArgumentException
     */
    public function __construct($instance = null)
    {
        if (is_null($instance)) {
            $this->row = array();
        } elseif (is_array($instance)) {
            $this->row = $instance;
        } else {
            $this->row = array();
            $this->bind($instance);
        }

        $this->acceptChanges();
    }

    /**
     * Add a string field to row
     * @param string $name
     * @param string $value
     */
    public function addField($name, $value)
    {
        $name = $this->getHydratedFieldName($name);

        if (!array_key_exists($name, $this->row)) {
            $this->row[$name] = $value;
        } elseif (is_array($this->row[$name])) {
            $this->row[$name][] = $value;
        } else {
            $this->row[$name] = array($this->row[$name], $value);
        }
        $this->informChanges();
    }

    /**
     * @param string $name - Field name
     * @return string
     * @desc et the string value from a field name
     */
    public function get($name)
    {
        $name = $this->getHydratedFieldName($name);

        if (!array_key_exists($name, $this->row)) {
            return null;
        }

        $result = $this->row[$name];
        if (is_array($result)) {
            return array_shift($result);
        } else {
            return $result;
        }
    }

    /**
     * Get array from a single field
     *
     * @param string $fieldName
     * @return array
     */
    public function getAsArray($fieldName)
    {
        $fieldName = $this->getHydratedFieldName($fieldName);

        if (!array_key_exists($fieldName, $this->row)) {
            return [];
        }

        $result = $this->row[$fieldName];

        if (empty($result)) {
            return [];
        }

        return (array)$result;
    }

    /**
     * Return all Field Names from current Row
     * @return array
     */
    public function getFieldNames()
    {
        return array_keys($this->row);
    }

    /**
     * Set a string value to existing field name
     * @param string $name
     * @param string $value
     */
    public function set($name, $value)
    {
        $name = $this->getHydratedFieldName($name);

        if (!array_key_exists($name, $this->row)) {
            $this->addField($name, $value);
        } else {
            $this->row[$name] = $value;
        }
        $this->informChanges();
    }

    /**
     * Remove specified field name from row.
     *
     * @param string $fieldName
     */
    public function removeField($fieldName)
    {
        $fieldName = $this->getHydratedFieldName($fieldName);

        if (array_key_exists($fieldName, $this->row)) {
            unset($this->row[$fieldName]);
            $this->informChanges();
        }
    }

    /**
     * Remove specified field name with specified value name from row.
     *
     * @param string $fieldName
     * @param $value
     */
    public function removeValue($fieldName, $value)
    {
        $fieldName = $this->getHydratedFieldName($fieldName);

        $result = $this->row[$fieldName];
        if (!is_array($result)) {
            if ($value == $result) {
                unset($this->row[$fieldName]);
                $this->informChanges();
            }
        } else {
            $qty = count($result);
            for ($i = 0; $i < $qty; $i++) {
                if ($result[$i] == $value) {
                    unset($result[$i]);
                    $this->informChanges();
                }
            }
            $this->row[$fieldName] = array_values($result);
        }
    }

    /**
     * Update a specific field and specific value with new value
     *
     * @param String $fieldName
     * @param String $oldvalue
     * @param String $newvalue
     */
    public function replaceValue($fieldName, $oldvalue, $newvalue)
    {
        $fieldName = $this->getHydratedFieldName($fieldName);

        $result = $this->row[$fieldName];
        if (!is_array($result)) {
            if ($oldvalue == $result) {
                $this->row[$fieldName] = $newvalue;
                $this->informChanges();
            }
        } else {
            for ($i = count($result) - 1; $i >= 0; $i--) {
                if ($result[$i] == $oldvalue) {
                    $this->row[$fieldName][$i] = $newvalue;
                    $this->informChanges();
                }
            }
        }
    }

    /**
     * Get the \DOMElement row objet
     *
     * @return \DOMElement
     * @throws \ByJG\Util\Exception\XmlUtilException
     */
    public function getAsDom()
    {
        if (is_null($this->node)) {
            $this->node = XmlUtil::createXmlDocumentFromStr("<row></row>");

            $root = $this->node->getElementsByTagName("row")->item(0);
            foreach ($this->row as $key => $value) {
                if (!is_array($value)) {
                    $field = XmlUtil::createChild($root, "field", $value);
                    XmlUtil::addAttribute($field, "name", $key);
                } else {
                    foreach ($value as $valueItem) {
                        $field = XmlUtil::createChild($root, "field", $valueItem);
                        XmlUtil::addAttribute($field, "name", $key);
                    }
                }
            }
        }
        return $this->node;

    }

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

    /**
     *
     * @return array
     */
    public function getAsJSON()
    {
        if (is_array($this->row)) {

            return json_decode(json_encode($this->row));
        } else {
            throw new UnexpectedValueException(
                'I expected that getRawFormat is array() but ' . gettype($this->row) . ' was given'
            );
        }
    }

    /**
     * @return array
     */
    public function getAsRaw()
    {
        return $this->originalRow;
    }

    /**
     *
     * @return bool
     */
    public function hasChanges()
    {
        return ($this->row != $this->originalRow);
    }

    /**
     *
     */
    public function acceptChanges()
    {
        $this->originalRow = $this->row;
    }

    /**
     *
     */
    public function rejectChanges()
    {
        $this->row = $this->originalRow;
    }

    protected function informChanges()
    {
        $this->node = null;
    }

    /**
     * Override Specific implementation of setPropValue to Row
     *
     * @param Row $obj
     * @param string $propName
     * @param string $value
     */
    protected function setPropValue($obj, $propName, $value)
    {
        $obj->set($propName, $value);
    }

    /**
     * @return bool
     */
    public function fieldExists($name)
    {
        return isset($this->row[$this->getHydratedFieldName($name)]);
    }

    /**
     * @return void
     */
    public function enableFieldNameCaseInSensitive() 
    {
        $this->row = array_change_key_case($this->row, CASE_LOWER);
        $this->originalRow = array_change_key_case($this->originalRow, CASE_LOWER);
        $this->fieldNameCaseSensitive = false;
    }

    /**
     * @return bool
     */
    public function isFieldNameCaseSensitive()
    {
        return $this->fieldNameCaseSensitive;
    }

    /**
     * @params name Fieldname
     * @return string
     */
    protected function getHydratedFieldName($name)
    {
        if (!$this->isFieldNameCaseSensitive()) {
            return strtolower($name);
        }

        return $name;
    }
}


1		<?php
2
3		namespace ByJG\AnyDataset\Core;
4
5		use ByJG\Serializer\BinderObject;
6		use ByJG\Serializer\DumpToArrayInterface;
7		use ByJG\Util\XmlUtil;
8		use UnexpectedValueException;
9
10		class Row extends BinderObject implements DumpToArrayInterface
11		{
12
13		/**
14		* \DOMNode represents a Row
15		* @var \DOMElement
16		*/
17		private $node = null;
18		private $row = null;
19		private $originalRow = null;
20
21		protected $fieldNameCaseSensitive = true;
22
23		/**
24		* Row constructor
25		*
26		* @param array()
27		* @throws \ByJG\Serializer\Exception\InvalidArgumentException
28		*/
29	37	public function __construct($instance = null)
30		{
31	37	if (is_null($instance)) {
32	35	$this->row = array();
33	11	} elseif (is_array($instance)) {
34	7	$this->row = $instance;
35		} else {
36	4	$this->row = array();
37	4	$this->bind($instance);
38		}
39
40	37	$this->acceptChanges();
41	37	}
42
43		/**
44		* Add a string field to row
45		* @param string $name
46		* @param string $value
47		*/
48	32	public function addField($name, $value)
49		{
50	32	$name = $this->getHydratedFieldName($name);
51
52	32	if (!array_key_exists($name, $this->row)) {
53	32	$this->row[$name] = $value;
54	14	} elseif (is_array($this->row[$name])) {
55	14	$this->row[$name][] = $value;
56		} else {
57	14	$this->row[$name] = array($this->row[$name], $value);
58		}
59	32	$this->informChanges();
60	32	}
61
62		/**
63		* @param string $name - Field name
64		* @return string
65		* @desc et the string value from a field name
66		*/
67	17	public function get($name)
68		{
69	17	$name = $this->getHydratedFieldName($name);
70
71	17	if (!array_key_exists($name, $this->row)) {
72	5	return null;
73		}
74
75	17	$result = $this->row[$name];
76	17	if (is_array($result)) {
77	2	return array_shift($result);
78		} else {
79	16	return $result;
80		}
81		}
82
83		/**
84		* Get array from a single field
85		*
86		* @param string $fieldName
87		* @return array
88		*/
89	3	public function getAsArray($fieldName)
90		{
91	3	$fieldName = $this->getHydratedFieldName($fieldName);
92
93	3	if (!array_key_exists($fieldName, $this->row)) {
94		return [];
95		}
96
97	3	$result = $this->row[$fieldName];
98
99	3	if (empty($result)) {
100	1	return [];
101		}
102
103	3	return (array)$result;
104		}
105
106		/**
107		* Return all Field Names from current Row
108		* @return array
109		*/
110	1	public function getFieldNames()
111		{
112	1	return array_keys($this->row);
113		}
114
115		/**
116		* Set a string value to existing field name
117		* @param string $name
118		* @param string $value
119		*/
120	10	public function set($name, $value)
121		{
122	10	$name = $this->getHydratedFieldName($name);
123
124	10	if (!array_key_exists($name, $this->row)) {
125	6	$this->addField($name, $value);
126		} else {
127	6	$this->row[$name] = $value;
128		}
129	10	$this->informChanges();
130	10	}
131
132		/**
133		* Remove specified field name from row.
134		*
135		* @param string $fieldName
136		*/
137	3	public function removeField($fieldName)
138		{
139	3	$fieldName = $this->getHydratedFieldName($fieldName);
140
141	3	if (array_key_exists($fieldName, $this->row)) {
142	3	unset($this->row[$fieldName]);
143	3	$this->informChanges();
144		}
145	3	}
146
147		/**
148		* Remove specified field name with specified value name from row.
149		*
150		* @param string $fieldName
151		* @param $value
152		*/
153	1	public function removeValue($fieldName, $value)
154		{
155	1	$fieldName = $this->getHydratedFieldName($fieldName);
156
157	1	$result = $this->row[$fieldName];
158	1	if (!is_array($result)) {
159	1	if ($value == $result) {
160	1	unset($this->row[$fieldName]);
161	1	$this->informChanges();
162		}
163		} else {
164	1	$qty = count($result);
165	1	for ($i = 0; $i < $qty; $i++) {
166	1	if ($result[$i] == $value) {
167	1	unset($result[$i]);
168	1	$this->informChanges();
169		}
170		}
171	1	$this->row[$fieldName] = array_values($result);
172		}
173	1	}
174
175		/**
176		* Update a specific field and specific value with new value
177		*
178		* @param String $fieldName
179		* @param String $oldvalue
180		* @param String $newvalue
181		*/
182	1	public function replaceValue($fieldName, $oldvalue, $newvalue)
183		{
184	1	$fieldName = $this->getHydratedFieldName($fieldName);
185
186	1	$result = $this->row[$fieldName];
187	1	if (!is_array($result)) {
188	1	if ($oldvalue == $result) {
189	1	$this->row[$fieldName] = $newvalue;
190	1	$this->informChanges();
191		}
192		} else {
193	1	for ($i = count($result) - 1; $i >= 0; $i--) {
194	1	if ($result[$i] == $oldvalue) {
195	1	$this->row[$fieldName][$i] = $newvalue;
196	1	$this->informChanges();
197		}
198		}
199		}
200	1	}
201
202		/**
203		* Get the \DOMElement row objet
204		*
205		* @return \DOMElement
206		* @throws \ByJG\Util\Exception\XmlUtilException
207		*/
208	4	public function getAsDom()
209		{
210	4	if (is_null($this->node)) {
211	4	$this->node = XmlUtil::createXmlDocumentFromStr("<row></row>");
		0 ignored issues – show Documentation Bug introduced 2021-01-03 18:56 UTC by Report Bug Copy Issue Report It seems like `ByJG\Util\XmlUtil::creat...tFromStr('<row></row>')` of type `DOMDocument` is incompatible with the declared type `DOMElement` of property `$node`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
212	4	$root = $this->node->getElementsByTagName("row")->item(0);
213	4	foreach ($this->row as $key => $value) {
214	4	if (!is_array($value)) {
215	4	$field = XmlUtil::createChild($root, "field", $value);
216	4	XmlUtil::addAttribute($field, "name", $key);
217		} else {
218	1	foreach ($value as $valueItem) {
219	1	$field = XmlUtil::createChild($root, "field", $valueItem);
220	1	XmlUtil::addAttribute($field, "name", $key);
221		}
222		}
223		}
224		}
225	4	return $this->node;
		0 ignored issues – show Bug Best Practice introduced 2021-01-03 18:56 UTC by Report Bug Copy Issue Report The expression `return $this->node` also could return the type `DOMDocument` which is incompatible with the documented return type `DOMElement`. Loading history...
226		}
227
228	18	public function toArray()
229		{
230	18	return $this->row;
231		}
232
233		/**
234		*
235		* @return array
236		*/
237		public function getAsJSON()
238		{
239		if (is_array($this->row)) {
		0 ignored issues – show introduced 2021-01-03 18:56 UTC by Report Bug Copy Issue Report The condition `is_array($this->row)` is always `true`. Loading history...
240		return json_decode(json_encode($this->row));
241		} else {
242		throw new UnexpectedValueException(
243		'I expected that getRawFormat is array() but ' . gettype($this->row) . ' was given'
244		);
245		}
246		}
247
248		/**
249		* @return array
250		*/
251	2	public function getAsRaw()
252		{
253	2	return $this->originalRow;
254		}
255
256		/**
257		*
258		* @return bool
259		*/
260	1	public function hasChanges()
261		{
262	1	return ($this->row != $this->originalRow);
263		}
264
265		/**
266		*
267		*/
268	37	public function acceptChanges()
269		{
270	37	$this->originalRow = $this->row;
271	37	}
272
273		/**
274		*
275		*/
276	1	public function rejectChanges()
277		{
278	1	$this->row = $this->originalRow;
279	1	}
280
281	32	protected function informChanges()
282		{
283	32	$this->node = null;
284	32	}
285
286		/**
287		* Override Specific implementation of setPropValue to Row
288		*
289		* @param Row $obj
290		* @param string $propName
291		* @param string $value
292		*/
293	4	protected function setPropValue($obj, $propName, $value)
294		{
295	4	$obj->set($propName, $value);
296	4	}
297
298		/**
299		* @return bool
300		*/
301	1	public function fieldExists($name)
302		{
303	1	return isset($this->row[$this->getHydratedFieldName($name)]);
304		}
305
306		/**
307		* @return void
308		*/
309	2	public function enableFieldNameCaseInSensitive()
310		{
311	2	$this->row = array_change_key_case($this->row, CASE_LOWER);
312	2	$this->originalRow = array_change_key_case($this->originalRow, CASE_LOWER);
313	2	$this->fieldNameCaseSensitive = false;
314	2	}
315
316		/**
317		* @return bool
318		*/
319	36	public function isFieldNameCaseSensitive()
320		{
321	36	return $this->fieldNameCaseSensitive;
322		}
323
324		/**
325		* @params name Fieldname
326		* @return string
327		*/
328	36	protected function getHydratedFieldName($name)
329		{
330	36	if (!$this->isFieldNameCaseSensitive()) {
331	2	return strtolower($name);
332		}
333
334	36	return $name;
335		}
336		}
337

byjg / anydataset

Pull Request — master (#10)

Row::getHydratedFieldName() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like