Row::toArray() - Code Metrics - Inspection of "Fix deprecation warning for PHP 8.1.7" - byjg/anydataset - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#13)

by Joao

created 2022-07-24 18:11 UTC

Row::toArray() A

↳ Parent: Row

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

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

<?php

namespace ByJG\AnyDataset\Core;

use ByJG\Serializer\SerializerObject;

class Row
{

    /**
     * @var array
     */
    private $row = [];

    /**
     * @var array
     */
    private $originalRow = [];

    /**
     * @var boolean
     */
    protected $fieldNameCaseSensitive = true;

    /**
     * Row constructor
     * 
     * @param Row|array|\stdClass|object $instance
     * @throws \ByJG\Serializer\Exception\InvalidArgumentException
     */
    public function __construct($instance = [])
    {
        if (is_array($instance)) {
            $this->row = $instance;
        } else {
            $this->row = SerializerObject::instance($instance)->serialize();
        }

        $this->acceptChanges();
    }

    /**
     * Add a string field to row
     * @param string $name
     * @param string|array|null $value
     * @return void
     */
    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);
        }
    }

    /**
     * @param string $name - Field name
     * @return null|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
     * @return void
     */
    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;
        }
    }

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

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

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

        $result = $this->row[$fieldName];
        if (!is_array($result)) {
            if ($value == $result) {
                unset($this->row[$fieldName]);
            }
        } else {
            $qty = count($result);
            for ($i = 0; $i < $qty; $i++) {
                if ($result[$i] == $value) {
                    unset($result[$i]);
                }
            }
            $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
     * @return void
     */
    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;
            }
        } else {
            for ($i = count($result) - 1; $i >= 0; $i--) {
                if ($result[$i] == $oldvalue) {
                    $this->row[$fieldName][$i] = $newvalue;
                }
            }
        }
    }

    /**
     * @param array|null $fields
     * @return array
     */
    public function toArray($fields = [])
    {
        if (empty($fields)) {
            return $this->row;
        }
        
        $fieldAssoc = array_combine($fields, array_fill(0, count($fields), null));
        return array_intersect_key(array_merge($fieldAssoc, $this->row), $fieldAssoc);
    }

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

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

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

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

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

    /**
     * @param string $name
     * @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;
    }

    /**
     * @param string $name
     * @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\SerializerObject;
6
7		class Row
8		{
9
10		/**
11		* @var array
12		*/
13		private $row = [];
14
15		/**
16		* @var array
17		*/
18		private $originalRow = [];
19
20		/**
21		* @var boolean
22		*/
23		protected $fieldNameCaseSensitive = true;
24
25		/**
26		* Row constructor
27		*
28		* @param Row\|array\|\stdClass\|object $instance
29		* @throws \ByJG\Serializer\Exception\InvalidArgumentException
30		*/
31	50	public function __construct($instance = [])
32		{
33	50	if (is_array($instance)) {
34	50	$this->row = $instance;
35		} else {
36	4	$this->row = SerializerObject::instance($instance)->serialize();
37		}
38
39	50	$this->acceptChanges();
40		}
41
42		/**
43		* Add a string field to row
44		* @param string $name
45		* @param string\|array\|null $value
46		* @return void
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	15	} elseif (is_array($this->row[$name])) {
55	15	$this->row[$name][] = $value;
56		} else {
57	15	$this->row[$name] = array($this->row[$name], $value);
58		}
59		}
60
61		/**
62		* @param string $name - Field name
63		* @return null\|string
64		* @desc et the string value from a field name
65		*/
66	25	public function get($name)
67		{
68	25	$name = $this->getHydratedFieldName($name);
69
70	25	if (!array_key_exists($name, $this->row)) {
71	6	return null;
72		}
73
74	25	$result = $this->row[$name];
75	25	if (is_array($result)) {
76	2	return array_shift($result);
77		} else {
78	24	return $result;
79		}
80		}
81
82		/**
83		* Get array from a single field
84		*
85		* @param string $fieldName
86		* @return array
87		*/
88	3	public function getAsArray($fieldName)
89		{
90	3	$fieldName = $this->getHydratedFieldName($fieldName);
91
92	3	if (!array_key_exists($fieldName, $this->row)) {
93		return [];
94		}
95
96	3	$result = $this->row[$fieldName];
97
98	3	if (empty($result)) {
99	1	return [];
100		}
101
102	3	return (array)$result;
103		}
104
105		/**
106		* Return all Field Names from current Row
107		* @return array
108		*/
109	1	public function getFieldNames()
110		{
111	1	return array_keys($this->row);
112		}
113
114		/**
115		* Set a string value to existing field name
116		* @param string $name
117		* @param string $value
118		* @return void
119		*/
120	7	public function set($name, $value)
121		{
122	7	$name = $this->getHydratedFieldName($name);
123
124	7	if (!array_key_exists($name, $this->row)) {
125	3	$this->addField($name, $value);
126		} else {
127	6	$this->row[$name] = $value;
128		}
129		}
130
131		/**
132		* Remove specified field name from row.
133		*
134		* @param string $fieldName
135		* @return null
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		}
144		}
145
146		/**
147		* Remove specified field name with specified value name from row.
148		*
149		* @param string $fieldName
150		* @param mixed $value
151		* @return void
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		}
162		} else {
163	1	$qty = count($result);
164	1	for ($i = 0; $i < $qty; $i++) {
165	1	if ($result[$i] == $value) {
166	1	unset($result[$i]);
167		}
168		}
169	1	$this->row[$fieldName] = array_values($result);
170		}
171		}
172
173		/**
174		* Update a specific field and specific value with new value
175		*
176		* @param String $fieldName
177		* @param String $oldvalue
178		* @param String $newvalue
179		* @return void
180		*/
181	1	public function replaceValue($fieldName, $oldvalue, $newvalue)
182		{
183	1	$fieldName = $this->getHydratedFieldName($fieldName);
184
185	1	$result = $this->row[$fieldName];
186	1	if (!is_array($result)) {
187	1	if ($oldvalue == $result) {
188	1	$this->row[$fieldName] = $newvalue;
189		}
190		} else {
191	1	for ($i = count($result) - 1; $i >= 0; $i--) {
192	1	if ($result[$i] == $oldvalue) {
193	1	$this->row[$fieldName][$i] = $newvalue;
194		}
195		}
196		}
197		}
198
199		/**
200		* @param array\|null $fields
201		* @return array
202		*/
203	28	public function toArray($fields = [])
204		{
205	28	if (empty($fields)) {
206	26	return $this->row;
207		}
208
209	2	$fieldAssoc = array_combine($fields, array_fill(0, count($fields), null));
210	2	return array_intersect_key(array_merge($fieldAssoc, $this->row), $fieldAssoc);
211		}
212
213		/**
214		* @return array
215		*/
216	2	public function getAsRaw()
217		{
218	2	return $this->originalRow;
219		}
220
221		/**
222		*
223		* @return bool
224		*/
225	1	public function hasChanges()
226		{
227	1	return ($this->row != $this->originalRow);
228		}
229
230		/**
231		* @return void
232		*/
233	50	public function acceptChanges()
234		{
235	50	$this->originalRow = $this->row;
236		}
237
238		/**
239		* @return void
240		*/
241	1	public function rejectChanges()
242		{
243	1	$this->row = $this->originalRow;
244		}
245
246		/**
247		* Override Specific implementation of setPropValue to Row
248		*
249		* @param Row $obj
250		* @param string $propName
251		* @param string $value
252		* @return void
253		*/
254		protected function setPropValue($obj, $propName, $value)
255		{
256		$obj->set($propName, $value);
257		}
258
259		/**
260		* @param string $name
261		* @return bool
262		*/
263	1	public function fieldExists($name)
264		{
265	1	return isset($this->row[$this->getHydratedFieldName($name)]);
266		}
267
268		/**
269		* @return void
270		*/
271	2	public function enableFieldNameCaseInSensitive()
272		{
273	2	$this->row = array_change_key_case($this->row, CASE_LOWER);
274	2	$this->originalRow = array_change_key_case($this->originalRow, CASE_LOWER);
275	2	$this->fieldNameCaseSensitive = false;
276		}
277
278		/**
279		* @return bool
280		*/
281	47	public function isFieldNameCaseSensitive()
282		{
283	47	return $this->fieldNameCaseSensitive;
284		}
285
286		/**
287		* @param string $name
288		* @return string
289		*/
290	47	protected function getHydratedFieldName($name)
291		{
292	47	if (!$this->isFieldNameCaseSensitive()) {
293	2	return strtolower($name);
294		}
295
296	47	return $name;
297		}
298		}
299

byjg / anydataset

Pull Request — master (#13)

Row::toArray() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like