Changers::castColumns() - Code Metrics - Inspection of "Breaking one huge class into several smaller trait..." - ajant/SimpleArrayLibrary - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b87405...9bfa56 )

by Aleksandar

created 2016-08-21 13:45 UTC

Changers::castColumns() C

↳ Parent: Changers

Complexity

Conditions	15
Paths	14

Size

Total Lines	45
Code Lines	34

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	45
rs	5.0504
cc	15
eloc	34
nc	14
nop	3

How to fix Complexity

<?php

namespace SimpleArrayLibrary\Categories;

use InvalidArgumentException;
use UnexpectedValueException;

trait Changers
{
    /**
     * @param array $config
     * @param array $keys
     * @param mixed $value
     *
     * @return array
     */
    public static function addConfigRow(array $config, array $keys, $value)
    {
        // validation
        if (self::isAssociative($keys)) {
            throw new UnexpectedValueException('Array of config keys must be numeric');
        }

        $row = $value;
        for ($i = count($keys) - 1; $i >= 0; $i--) {
            $row = [$keys[$i] => $row];
        }
        $config = self::insertSubArray($config, $row);

        return $config;
    }

    /**
     * @param array $matrix
     * @param array $castMap
     * @param bool  $allKeysMustBePresent
     *
     * @return array
     */
    public static function castColumns(array $matrix, array $castMap, $allKeysMustBePresent = true)
    {
        if (!is_bool($allKeysMustBePresent)) {
            throw new InvalidArgumentException('Third parameter must be a boolean');
        }
        if (empty($matrix)) {
            return $matrix;
        }
        if (self::countMinDepth($matrix) < 2) {
            throw new UnexpectedValueException('Can not cast columns on one dimensional array');
        }

        foreach ($matrix as $key => $row) {
            foreach ($castMap as $column => $type) {
                if (isset($row[$column]) || array_key_exists($column, $row)) {
                    switch ($type) {
                        case self::TYPE_INT:
                            $matrix[$key][$column] = (int)$row[$column];
                            break;
                        case self::TYPE_STRING:
                            $matrix[$key][$column] = (string)$row[$column];
                            break;
                        case self::TYPE_FLOAT:
                            $matrix[$key][$column] = (float)$row[$column];
                            break;
                        case self::TYPE_BOOL:
                            $matrix[$key][$column] = (bool)$row[$column];
                            break;
                        case self::TYPE_ARRAY:
                            $matrix[$key][$column] = (array)$row[$column];
                            break;
                        case self::TYPE_OBJECT:
                            $matrix[$key][$column] = (object)$row[$column];
                            break;
                        default:
                            throw new UnexpectedValueException('Invalid type: ' . $type);
                    }
                } elseif ($allKeysMustBePresent) {
                    throw new UnexpectedValueException('Column: ' . $column . ' missing in row: ' . $key);
                }
            }
        }

        return $matrix;
    }

    /**
     * @param array $matrix
     * @param mixed $columns
     *
     * @return array
     */
    public static function deleteColumns(array $matrix, array $columns)
    {
        // validate input
        if (self::countMinDepth($matrix) < 2) {
            throw new UnexpectedValueException('Can not delete columns on one dimensional array');
        }
        if (self::countMinDepth($columns) != 1) {
            throw new InvalidArgumentException('Invalid column');
        }

        // remove columns in every row
        foreach ($matrix as $key => $row) {
            foreach ($columns as $column) {
                unset($matrix[$key][$column]);
            }
        }

        return $matrix;
    }

    /**
     * @param mixed $array
     * @param mixed $subArray
     * @param bool  $overwrite
     * @param bool  $ignoreIfExists
     *
     * @return array
     */
    public static function insertSubArray($array, $subArray, $overwrite = false, $ignoreIfExists = false)
    {
        // validate
        if (!is_bool($overwrite)) {
            throw new InvalidArgumentException('Overwrite indicator must be a boolean');
        }
        if (!is_bool($ignoreIfExists)) {
            throw new InvalidArgumentException('Ignore if exists indicator must be a boolean');
        }

        if (!is_array($subArray) || !is_array($array)) {
            // $subArray[$key] is leaf of the array
            if ($overwrite) {
                $array = $subArray;
            } elseif (!$ignoreIfExists) {
                throw new UnexpectedValueException('Sub-array already exists');
            }
        } else {
            $key = key($subArray);
            if (isset($array[$key]) || array_key_exists($key, $array)) {
                $array[$key] = self::insertSubArray($array[$key], $subArray[$key], $overwrite, $ignoreIfExists);
            } else {
                $array[$key] = $subArray[$key];
            }
        }

        return $array;
    }

    /**
     * @param array $matrix
     * @param mixed $column
     * @param mixed $value
     * @param bool  $insertIfMissing
     * @param bool  $overwrite
     *
     * @return array
     */
    public static function setColumn(array $matrix, $column, $value, $insertIfMissing = true, $overwrite = true)
    {
        // validate input
        if (self::countMinDepth($matrix) < 2) {
            throw new UnexpectedValueException('Can not set columns on one dimensional array');
        }
        if (!is_scalar($column)) {
            throw new InvalidArgumentException('Invalid column');
        }
        if (!is_bool($insertIfMissing)) {
            throw new InvalidArgumentException('Insert if missing indicator must be a boolean');
        }
        if (!is_bool($overwrite)) {
            throw new InvalidArgumentException('Overwrite indicator must be a boolean');
        }

        foreach ($matrix as $key => $row) {
            if (isset($row[$column]) || array_key_exists($column, $row)) {
                $matrix[$key][$column] = ($overwrite ? $value : $matrix[$key][$column]);
            } elseif ($insertIfMissing) {
                $matrix[$key][$column] = $value;
            }
        }

        return $matrix;
    }
}

1			<?php
2
3			namespace SimpleArrayLibrary\Categories;
4
5			use InvalidArgumentException;
6			use UnexpectedValueException;
7
8			trait Changers
9			{
10			/**
11			* @param array $config
12			* @param array $keys
13			* @param mixed $value
14			*
15			* @return array
16			*/
17			public static function addConfigRow(array $config, array $keys, $value)
18			{
19			// validation
20			if (self::isAssociative($keys)) {
21			throw new UnexpectedValueException('Array of config keys must be numeric');
22			}
23
24			$row = $value;
25			for ($i = count($keys) - 1; $i >= 0; $i--) {
26			$row = [$keys[$i] => $row];
27			}
28			$config = self::insertSubArray($config, $row);
29
30			return $config;
31			}
32
33			/**
34			* @param array $matrix
35			* @param array $castMap
36			* @param bool $allKeysMustBePresent
37			*
38			* @return array
39			*/
40			public static function castColumns(array $matrix, array $castMap, $allKeysMustBePresent = true)
41			{
42			if (!is_bool($allKeysMustBePresent)) {
43			throw new InvalidArgumentException('Third parameter must be a boolean');
44			}
45			if (empty($matrix)) {
46			return $matrix;
47			}
48			if (self::countMinDepth($matrix) < 2) {
49			throw new UnexpectedValueException('Can not cast columns on one dimensional array');
50			}
51
52			foreach ($matrix as $key => $row) {
53			foreach ($castMap as $column => $type) {
54			if (isset($row[$column]) \|\| array_key_exists($column, $row)) {
55			switch ($type) {
56			case self::TYPE_INT:
57			$matrix[$key][$column] = (int)$row[$column];
58			break;
59			case self::TYPE_STRING:
60			$matrix[$key][$column] = (string)$row[$column];
61			break;
62			case self::TYPE_FLOAT:
63			$matrix[$key][$column] = (float)$row[$column];
64			break;
65			case self::TYPE_BOOL:
66			$matrix[$key][$column] = (bool)$row[$column];
67			break;
68			case self::TYPE_ARRAY:
69			$matrix[$key][$column] = (array)$row[$column];
70			break;
71			case self::TYPE_OBJECT:
72			$matrix[$key][$column] = (object)$row[$column];
73			break;
74			default:
75			throw new UnexpectedValueException('Invalid type: ' . $type);
76			}
77			} elseif ($allKeysMustBePresent) {
78			throw new UnexpectedValueException('Column: ' . $column . ' missing in row: ' . $key);
79			}
80			}
81			}
82
83			return $matrix;
84			}
85
86			/**
87			* @param array $matrix
88			* @param mixed $columns
89			*
90			* @return array
91			*/
92			public static function deleteColumns(array $matrix, array $columns)
93			{
94			// validate input
95			if (self::countMinDepth($matrix) < 2) {
96			throw new UnexpectedValueException('Can not delete columns on one dimensional array');
97			}
98			if (self::countMinDepth($columns) != 1) {
99			throw new InvalidArgumentException('Invalid column');
100			}
101
102			// remove columns in every row
103			foreach ($matrix as $key => $row) {
104			foreach ($columns as $column) {
105			unset($matrix[$key][$column]);
106			}
107			}
108
109			return $matrix;
110			}
111
112			/**
113			* @param mixed $array
114			* @param mixed $subArray
115			* @param bool $overwrite
116			* @param bool $ignoreIfExists
117			*
118			* @return array
119			*/
120			public static function insertSubArray($array, $subArray, $overwrite = false, $ignoreIfExists = false)
121			{
122			// validate
123			if (!is_bool($overwrite)) {
124			throw new InvalidArgumentException('Overwrite indicator must be a boolean');
125			}
126			if (!is_bool($ignoreIfExists)) {
127			throw new InvalidArgumentException('Ignore if exists indicator must be a boolean');
128			}
129
130			if (!is_array($subArray) \|\| !is_array($array)) {
131			// $subArray[$key] is leaf of the array
132			if ($overwrite) {
133			$array = $subArray;
134			} elseif (!$ignoreIfExists) {
135			throw new UnexpectedValueException('Sub-array already exists');
136			}
137			} else {
138			$key = key($subArray);
139			if (isset($array[$key]) \|\| array_key_exists($key, $array)) {
140			$array[$key] = self::insertSubArray($array[$key], $subArray[$key], $overwrite, $ignoreIfExists);
141			} else {
142			$array[$key] = $subArray[$key];
143			}
144			}
145
146			return $array;
147			}
148
149			/**
150			* @param array $matrix
151			* @param mixed $column
152			* @param mixed $value
153			* @param bool $insertIfMissing
154			* @param bool $overwrite
155			*
156			* @return array
157			*/
158			public static function setColumn(array $matrix, $column, $value, $insertIfMissing = true, $overwrite = true)
159			{
160			// validate input
161			if (self::countMinDepth($matrix) < 2) {
162			throw new UnexpectedValueException('Can not set columns on one dimensional array');
163			}
164			if (!is_scalar($column)) {
165			throw new InvalidArgumentException('Invalid column');
166			}
167			if (!is_bool($insertIfMissing)) {
168			throw new InvalidArgumentException('Insert if missing indicator must be a boolean');
169			}
170			if (!is_bool($overwrite)) {
171			throw new InvalidArgumentException('Overwrite indicator must be a boolean');
172			}
173
174			foreach ($matrix as $key => $row) {
175			if (isset($row[$column]) \|\| array_key_exists($column, $row)) {
176			$matrix[$key][$column] = ($overwrite ? $value : $matrix[$key][$column]);
177			} elseif ($insertIfMissing) {
178			$matrix[$key][$column] = $value;
179			}
180			}
181
182			return $matrix;
183			}
184			}

ajant / SimpleArrayLibrary

Push — master ( b87405...9bfa56 )

Changers::castColumns() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like