SupportTrait::prepareFields() - Code Metrics - AgelxNash/modx-evo-database - Measure and Improve Code Quality continuously with Scrutinizer

SupportTrait::prepareFields() B
last analyzed 2020-12-03 15:20 UTC

↳ Parent: SupportTrait

Complexity

Conditions	7
Paths	4

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	7

Importance

Changes	1
Bugs	0	Features	0

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

<?php namespace AgelxNash\Modx\Evo\Database\Traits;

use AgelxNash\Modx\Evo\Database\Exceptions;

trait SupportTrait
{
    /**
     * @param $value
     * @return mixed
     */
    protected function convertValue($value)
    {
        switch (true) {
            case (\is_numeric($value) && ! \is_float(1 * $value)):
                $value = (int)$value;
                break;
            case \is_numeric($value) && \is_float(1*$value):
                $value = (float)$value;
                break;
            default:
                break;
        }

        return $value;
    }

    /**
     * @param int $timestamp
     * @param string $fieldType
     * @return bool|false|string
     * @deprecated
     */
    public function convertDate($timestamp, $fieldType = 'DATETIME')
    {
        $date = false;
        if (! empty($timestamp) && $timestamp > 0) {
            $format = [
                'DATE' => 'Y-m-d',
                'TIME' => 'H:i:s',
                'YEAR' => 'Y',
                'DATETIME' => 'Y-m-d H:i:s',
            ];
            $use = isset($format[$fieldType]) ? $format[$fieldType] : 'Y-m-d H:i:s';
            $date = date($use, $timestamp);
        }

        return $date;
    }

    /**
     * @param string|array $data
     * @param bool $ignoreAlias
     * @return string
     */
    protected function prepareFields($data, $ignoreAlias = false)
    {
        if (\is_array($data)) {
            $tmp = [];
            foreach ($data as $alias => $field) {
                $tmp[] = ($alias !== $field && ! \is_int($alias) && $ignoreAlias === false) ?
                    ($field . ' as `' . $alias . '`') : $field;
            }

            $data = implode(',', $tmp);
        }
        if (empty($data)) {
            $data = '*';
        }

        return $data;
    }

    /**
     * @param string|null $value
     * @return string
     * @throws Exceptions\InvalidFieldException
     */
    protected function prepareNull($value)
    {
        switch (true) {
            case ($value === null || (\is_scalar($value) && strtolower($value) === 'null')):
                $value = 'NULL';
                break;
            case \is_scalar($value):
                $value = "'" . $value . "'";
                break;
            default:
                throw (new Exceptions\InvalidFieldException('NULL'))
                    ->setData($value);
        }

        return $value;
    }

    /**
     * @param string|array $data
     * @param int $level
     * @param bool $skipFieldNames
     * @return array|string
     * @throws Exceptions\InvalidFieldException
     * @throws Exceptions\TooManyLoopsException
     */
    protected function prepareValues($data, $level = 1, $skipFieldNames = false)
    {
        $fields = [];
        $values = [];
        $maxLevel = $level;
        $wrap = false;

        if (\is_array($data)) {
            foreach ($data as $key => $value) {
                if (\is_array($value)) {
                    if ($level > 2) {
                        throw new Exceptions\TooManyLoopsException('Values');
                    }
                    $maxLevel++;
                    $out = $this->prepareValues($value, $level + 1);
                    if (empty($fields)) {
                        $fields = $out['fields'];
                    } elseif ($fields !== $out['fields'] && $skipFieldNames === false) {
                        throw (new Exceptions\InvalidFieldException("Don't match field names"))
                            ->setData($data);
                    }
                    $wrap = true;
                    $values[] = $out['values'];
                } else {
                    $fields[] = $key;
                    $values[] = $this->prepareNull($value);
                }
            }
            $values = $this->withCommaSeparator($values);
            if ($wrap === false) {
                $values = '(' . $values . ')';
            }
        }

        if (! \is_scalar($values)) {
            throw (new Exceptions\InvalidFieldException('values'))
                ->setData($values);
        }

        if (($fields = $this->checkFields($fields, $maxLevel, $skipFieldNames)) === false) {
            throw (new Exceptions\InvalidFieldException('fields name'))
                ->setData($data);
        }

        if ($level === 2) {
            return compact('fields', 'values');
        }

        return (empty($fields) ? '' : $fields . ' VALUES ') . $values;
    }

    /**
     * @param mixed $fields
     * @param int $level
     * @param bool $skipFieldNames
     * @return bool|string
     */
    protected function checkFields($fields, $level = 1, $skipFieldNames = false)
    {
        if (\is_array($fields) && $skipFieldNames === false) {
            if ($this->arrayOnlyNumeric($fields) === true) {
                $fields = ($level === 2) ? false : '';
            } else {
                $fields = '(`' . implode('`, `', $fields) . '`)';
            }
        }

        return $fields;
    }

    /**
     * @param array $data
     * @return bool
     */
    protected function arrayOnlyNumeric(array $data)
    {
        $onlyNumbers = true;
        foreach ($data as $value) {
            if (! \is_numeric($value)) {
                $onlyNumbers = false;
                break;
            }
        }

        return $onlyNumbers;
    }

    /**
     * @param string|array $data
     * @return string
     * @throws Exceptions\InvalidFieldException
     */
    protected function prepareValuesSet($data)
    {
        if (\is_array($data)) {
            foreach ($data as $key => $value) {
                $data[$key] = $this->prepareNull($value);
            }

            foreach ($data as $key => $value) {
                $data[$key] = "`{$key}` = " . $value;
            }
        }

        return $this->withCommaSeparator($data);
    }

    /**
     * @param string|array $data
     * @param bool $hasArray
     * @return string
     * @throws Exceptions\TableNotDefinedException
     */
    protected function prepareFrom($data, $hasArray = false)
    {
        if (\is_array($data) && $hasArray === true) {
            $tmp = [];
            foreach ($data as $table) {
                $tmp[] = $table;
            }
            $data = implode(' ', $tmp);
        }
        if (! is_scalar($data) || empty($data)) {
            throw new Exceptions\TableNotDefinedException($data);
        }

        return $data;
    }

    /**
     * @param array|string $data
     * @return string
     * @throws Exceptions\InvalidFieldException
     */
    protected function prepareWhere($data)
    {
        if (\is_array($data)) {
            if ($this->arrayOnlyNumeric(array_keys($data)) === true) {
                $data = implode(' ', $data);
            } else {
                throw (new Exceptions\InvalidFieldException('WHERE'))
                    ->setData($data);
            }
        }
        $data = trim($data);
        if (! empty($data) && stripos($data, 'WHERE') !== 0) {
            $data = "WHERE {$data}";
        }

        return $data;
    }

    /**
     * @param string $data
     * @return string
     */
    protected function prepareOrder($data)
    {
        $data = trim($data);
        if (! empty($data) && stripos($data, 'ORDER') !== 0) {
            $data = "ORDER BY {$data}";
        }

        return $data;
    }

    /**
     * @param string $data
     * @return string
     */
    protected function prepareLimit($data)
    {
        $data = trim($data);
        if (! empty($data) && stripos($data, 'LIMIT') !== 0) {
            $data = "LIMIT {$data}";
        }

        return $data;
    }

    /**
     * @param $values
     * @return string
     */
    protected function withCommaSeparator($values)
    {
        if (\is_array($values)) {
            $values = implode(', ', $values);
        }

        return trim($values);
    }
}


1		<?php namespace AgelxNash\Modx\Evo\Database\Traits;
2
3		use AgelxNash\Modx\Evo\Database\Exceptions;
4
5		trait SupportTrait
6		{
7		/**
8		* @param $value
9		* @return mixed
10		*/
11	19	protected function convertValue($value)
12		{
13		switch (true) {
14	19	case (\is_numeric($value) && ! \is_float(1 * $value)):
15	15	$value = (int)$value;
16	15	break;
17	15	case \is_numeric($value) && \is_float(1*$value):
18	1	$value = (float)$value;
19	1	break;
20		default:
21	15	break;
22		}
23
24	19	return $value;
25		}
26
27		/**
28		* @param int $timestamp
29		* @param string $fieldType
30		* @return bool\|false\|string
31		* @deprecated
32		*/
33	1	public function convertDate($timestamp, $fieldType = 'DATETIME')
34		{
35	1	$date = false;
36	1	if (! empty($timestamp) && $timestamp > 0) {
37		$format = [
38	1	'DATE' => 'Y-m-d',
39		'TIME' => 'H:i:s',
40		'YEAR' => 'Y',
41		'DATETIME' => 'Y-m-d H:i:s',
42		];
43	1	$use = isset($format[$fieldType]) ? $format[$fieldType] : 'Y-m-d H:i:s';
44	1	$date = date($use, $timestamp);
45		}
46
47	1	return $date;
48		}
49
50		/**
51		* @param string\|array $data
52		* @param bool $ignoreAlias
53		* @return string
54		*/
55	9	protected function prepareFields($data, $ignoreAlias = false)
56		{
57	9	if (\is_array($data)) {
58	5	$tmp = [];
59	5	foreach ($data as $alias => $field) {
60	4	$tmp[] = ($alias !== $field && ! \is_int($alias) && $ignoreAlias === false) ?
61	4	($field . ' as `' . $alias . '`') : $field;
62		}
63
64	5	$data = implode(',', $tmp);
65		}
66	9	if (empty($data)) {
67	1	$data = '*';
68		}
69
70	9	return $data;
71		}
72
73		/**
74		* @param string\|null $value
75		* @return string
76		* @throws Exceptions\InvalidFieldException
77		*/
78	17	protected function prepareNull($value)
79		{
80		switch (true) {
81	17	case ($value === null \|\| (\is_scalar($value) && strtolower($value) === 'null')):
82	5	$value = 'NULL';
83	5	break;
84	17	case \is_scalar($value):
85	17	$value = "'" . $value . "'";
86	17	break;
87		default:
88	1	throw (new Exceptions\InvalidFieldException('NULL'))
89	1	->setData($value);
90		}
91
92	17	return $value;
93		}
94
95		/**
96		* @param string\|array $data
97		* @param int $level
98		* @param bool $skipFieldNames
99		* @return array\|string
100		* @throws Exceptions\InvalidFieldException
101		* @throws Exceptions\TooManyLoopsException
102		*/
103	13	protected function prepareValues($data, $level = 1, $skipFieldNames = false)
104		{
105	13	$fields = [];
106	13	$values = [];
107	13	$maxLevel = $level;
108	13	$wrap = false;
109
110	13	if (\is_array($data)) {
111	13	foreach ($data as $key => $value) {
112	13	if (\is_array($value)) {
113	1	if ($level > 2) {
114		throw new Exceptions\TooManyLoopsException('Values');
115		}
116	1	$maxLevel++;
117	1	$out = $this->prepareValues($value, $level + 1);
118	1	if (empty($fields)) {
119	1	$fields = $out['fields'];
120	1	} elseif ($fields !== $out['fields'] && $skipFieldNames === false) {
121		throw (new Exceptions\InvalidFieldException("Don't match field names"))
122		->setData($data);
123		}
124	1	$wrap = true;
125	1	$values[] = $out['values'];
126		} else {
127	13	$fields[] = $key;
128	13	$values[] = $this->prepareNull($value);
129		}
130		}
131	13	$values = $this->withCommaSeparator($values);
132	13	if ($wrap === false) {
133	13	$values = '(' . $values . ')';
134		}
135		}
136
137	13	if (! \is_scalar($values)) {
138		throw (new Exceptions\InvalidFieldException('values'))
139		->setData($values);
140		}
141
142	13	if (($fields = $this->checkFields($fields, $maxLevel, $skipFieldNames)) === false) {
143		throw (new Exceptions\InvalidFieldException('fields name'))
144		->setData($data);
145		}
146
147	13	if ($level === 2) {
148	1	return compact('fields', 'values');
149		}
150
151	13	return (empty($fields) ? '' : $fields . ' VALUES ') . $values;
152		}
153
154		/**
155		* @param mixed $fields
156		* @param int $level
157		* @param bool $skipFieldNames
158		* @return bool\|string
159		*/
160	13	protected function checkFields($fields, $level = 1, $skipFieldNames = false)
161		{
162	13	if (\is_array($fields) && $skipFieldNames === false) {
163	13	if ($this->arrayOnlyNumeric($fields) === true) {
164	1	$fields = ($level === 2) ? false : '';
165		} else {
166	13	$fields = '(`' . implode('`, `', $fields) . '`)';
167		}
168		}
169
170	13	return $fields;
171		}
172
173		/**
174		* @param array $data
175		* @return bool
176		*/
177	16	protected function arrayOnlyNumeric(array $data)
178		{
179	16	$onlyNumbers = true;
180	16	foreach ($data as $value) {
181	16	if (! \is_numeric($value)) {
182	14	$onlyNumbers = false;
183	16	break;
184		}
185		}
186
187	16	return $onlyNumbers;
188		}
189
190		/**
191		* @param string\|array $data
192		* @return string
193		* @throws Exceptions\InvalidFieldException
194		*/
195	5	protected function prepareValuesSet($data)
196		{
197	5	if (\is_array($data)) {
198	5	foreach ($data as $key => $value) {
199	5	$data[$key] = $this->prepareNull($value);
200		}
201
202	5	foreach ($data as $key => $value) {
203	5	$data[$key] = "`{$key}` = " . $value;
204		}
205		}
206
207	5	return $this->withCommaSeparator($data);
208		}
209
210		/**
211		* @param string\|array $data
212		* @param bool $hasArray
213		* @return string
214		* @throws Exceptions\TableNotDefinedException
215		*/
216	22	protected function prepareFrom($data, $hasArray = false)
217		{
218	22	if (\is_array($data) && $hasArray === true) {
219	3	$tmp = [];
220	3	foreach ($data as $table) {
221	3	$tmp[] = $table;
222		}
223	3	$data = implode(' ', $tmp);
224		}
225	22	if (! is_scalar($data) \|\| empty($data)) {
226	1	throw new Exceptions\TableNotDefinedException($data);
227		}
228
229	22	return $data;
230		}
231
232		/**
233		* @param array\|string $data
234		* @return string
235		* @throws Exceptions\InvalidFieldException
236		*/
237	13	protected function prepareWhere($data)
238		{
239	13	if (\is_array($data)) {
240	3	if ($this->arrayOnlyNumeric(array_keys($data)) === true) {
241	3	$data = implode(' ', $data);
242		} else {
243	1	throw (new Exceptions\InvalidFieldException('WHERE'))
244	1	->setData($data);
245		}
246		}
247	13	$data = trim($data);
248	13	if (! empty($data) && stripos($data, 'WHERE') !== 0) {
249	11	$data = "WHERE {$data}";
250		}
251
252	13	return $data;
253		}
254
255		/**
256		* @param string $data
257		* @return string
258		*/
259	9	protected function prepareOrder($data)
260		{
261	9	$data = trim($data);
262	9	if (! empty($data) && stripos($data, 'ORDER') !== 0) {
263	5	$data = "ORDER BY {$data}";
264		}
265
266	9	return $data;
267		}
268
269		/**
270		* @param string $data
271		* @return string
272		*/
273	11	protected function prepareLimit($data)
274		{
275	11	$data = trim($data);
276	11	if (! empty($data) && stripos($data, 'LIMIT') !== 0) {
277	5	$data = "LIMIT {$data}";
278		}
279
280	11	return $data;
281		}
282
283		/**
284		* @param $values
285		* @return string
286		*/
287	16	protected function withCommaSeparator($values)
288		{
289	16	if (\is_array($values)) {
290	16	$values = implode(', ', $values);
291		}
292
293	16	return trim($values);
294		}
295		}
296

AgelxNash / modx-evo-database

SupportTrait::prepareFields() B last analyzed 2020-12-03 15:20 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

SupportTrait::prepareFields() B
last analyzed 2020-12-03 15:20 UTC