StructureSorter::sortArrayByKeys() - Code Metrics - Inspection of "Fixed main tests" - samsonframework/string-condition-tree - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e2d05f...edeffb )

by Vitaly

created 2017-04-06 13:01 UTC

StructureSorter::sortArrayByKeys() B

↳ Parent: StructureSorter

Complexity

Conditions	4
Paths	4

Size

Total Lines	35
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	35
ccs	12
cts	12
cp	1
rs	8.5806
c	0
b	0
f	0
cc	4
eloc	17
nc	4
nop	1
crap	4

<?php declare(strict_types=1);
/**
 * Created by Vitaly Iegorov <[email protected]>.
 * on 05.04.17 at 15:18
 */
namespace samsonframework\stringconditiontree;

use samsonframework\stringconditiontree\string\Structure;

/**
 * Parametrized strings sorting.
 *
 * @author Vitaly Egorov <[email protected]>
 */
class StructureSorter
{
    /** Variable length characters group */
    const G_VARIABLE = 0;

    /** Fixed length characters group */
    const G_FIXED = 1;

    /** @var string Parametrized string start marker */
    protected $parameterStartMarker;

    /** @var string Parametrized string end marker */
    protected $parameterEndMarker;

    /**
     * StructureSorter constructor.
     *
     * @param string $parameterStartMarker Parametrized string start marker
     * @param string $parameterEndMarker Parametrized string end marker
     */
    public function __construct(string $parameterStartMarker, string $parameterEndMarker)
    {
        $this->parameterStartMarker = $parameterStartMarker;
        $this->parameterEndMarker = $parameterEndMarker;
    }

    /**
     * Sort strings array considering PCG and NPCG string structure.
     *
     * @param array $input Input array for sorting
     *
     * @return array Sorted keys array
     */
    public function sortArrayByKeys(array $input): array
    {
        /** @var Structure[] $structures */
        $structures = [];
        foreach (array_keys($input) as $string) {
            $structures[$string] = new Structure($string);
        }

        usort($structures, function(Structure $initial, Structure $compared) {

            return $initial->compare($compared);
        });

        $structures = array_reverse($structures);

        // Restore initial strings sub-arrays
        $result = [];
        foreach ($structures as $structure) {
            $result[$structure->input] = $input[$structure->input];
        }
        return $result;


        // Convert string array keys into structure arrays
        $prefixes = array_map([$this, 'getPrefixStructure'], array_keys($input));
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}

        // Sort parametrized string array according sorting rules
        usort($prefixes, [$this, 'compareStringStructure']);

        // Restore initial strings sub-arrays
        $result = [];
        foreach ($prefixes as $sortingData) {
            $result[$sortingData[0][2]] = $input[$sortingData[0][2]];
        }
        return $result;
    }

    /**
     * Build string character group structure considering parametrized
     * and not parametrized character groups and their length(PCG, NPCG).
     *
     * @param string $prefix Prefix string
     *
     * @return array String character groups structure
     */
    protected function getPrefixStructure(string $prefix): array
    {
        /** @var array $structureMatrix String PCG(0)/NPCG(1) structure matrix for comparison */
        $structureMatrix = [];

        // Flags for showing current string character group
        /** @var bool $isPCG Flags showing PCG started */
        $isPCG = false;
        /** @var bool $isNPCG Flags showing NPCG started */
        $isNPCG = true;

        // Pointer to current CG to count string NPCG length
        $currentCG = 0;

        /**
         * TODO: Try to find PCG filter :... pattern and process it also as
         * PCG with filters should be prioritized over PSG without filter
         * even if filter is .*
         */

        // Iterate string by characters
        for ($i = 0, $length = strlen($prefix); $i < $length; $i++) {
            if (!$isPCG && $prefix{$i} === $this->parameterStartMarker) {
                $isPCG = true;
                $isNPCG = false;
                $structureMatrix[] = [0, 0, $prefix];
                $currentCG = &$structureMatrix[count($structureMatrix) - 1][1];
            } elseif ($isPCG && $prefix{$i} === $this->parameterEndMarker) {
                $isPCG = false;
                $isNPCG = true;
            } elseif ($isNPCG) {
                $isNPCG = false;
                $structureMatrix[] = [1, 0, $prefix];
                $currentCG = &$structureMatrix[count($structureMatrix) - 1][1];
            }

            // Store current character group length
            $currentCG++;
        }

        return $structureMatrix;
    }

    /**
     * Compare string structures.
     *
     * @param array $initial  Initial string structure
     * @param array $compared Compared string structure
     *
     * @return int Result of array elements comparison
     */
    protected function compareStringStructure(array $initial, array $compared): int
    {
        $this->equalizeStructures($initial, $compared);

        /**
         * If all CG in structure are fixed then shortest should have higher priority
         * If first CG is variable and second is fixed then longest fixed should have higher priority.
         */

        // Iterate every CGS
        foreach ($initial as $key => $initialGroup) {
            $comparedGroup = $compared[$key];

            /**
             * FCG has higher priority then VCG.
             * Compare CG type
             */
            $return = $this->compareCSGData($initialGroup, $comparedGroup, self::G_VARIABLE, 0);

            // If CG are equal and are fixed type
            if ($key > 0 && $return === 0 && $initialGroup[0] === self::G_FIXED) {
                /**
                 * Compare fixed CG lengths. Fixed CG longer
                 * should have higher priority.
                 */
                $return = $this->compareCSGData($initialGroup, $comparedGroup, self::G_VARIABLE, 1);
            }

            if ($return !== 0) {
                return $return;
            }

            // They are equal continue to next structure group comparison
        }

        // Compare fixed length CGS
        $return = $this->compareStructureLengths($initial, $compared, self::G_FIXED);

        // Fixed CGS are equal
        if ($return === 0) {
            // Compare variable length CGS
            $return = $this->compareStructureLengths($initial, $compared, self::G_VARIABLE);
        }

        return $return;
    }

    /**
     * Make CGS equals size.
     *
     * @param array $initial Initial CGS, will be changed
     * @param array $compared Compared CGS, will be changed
     *
     * @return int Longest CGS size(now they are both equal)
     */
    protected function equalizeStructures(array &$initial, array &$compared): int
    {
        $size = max(count($initial), count($compared));

        // Make structures same size preserving previous existing structure value
        for ($i = 1; $i < $size; $i++) {
            $this->fillMissingStructureGroup($initial, $i);
            $this->fillMissingStructureGroup($compared, $i);
        }

        return $size;
    }

    /**
     * Fill CSG with previous group value if not present.
     *
     * @param array $groups CSG for filling
     * @param int   $index  CSG index
     */
    private function fillMissingStructureGroup(array &$groups, int $index)
    {
        if (!array_key_exists($index, $groups)) {
            $groups[$index] = $groups[$index - 1];
        }
    }

    /**
     * Compare longer CGS considering that:
     * - Shortest fixed CGS should have higher priority
     * - Longest variable CGS should have higher priority
     *
     * @param array $initialGroup  Initial CGS
     * @param array $comparedGroup Compared CGS
     * @param int   $type          Fixed/Variable CGS
     * @param int   $dataIndex CSG creationData index
     *
     * @return int 0 if initial CGS is not longer than compared,
     *                  otherwise -1/1 depending on CGS type.
     */
    private function compareCSGData(array $initialGroup, array $comparedGroup, int $type, int $dataIndex = 1): int
    {
        // Compare character group length
        if ($initialGroup[$dataIndex] > $comparedGroup[$dataIndex]) {

            return ($type === self::G_FIXED ? 1 : -1);
        }

        if ($initialGroup[$dataIndex] < $comparedGroup[$dataIndex]) {

            return ($type === self::G_FIXED ? -1 : 1);
        }

        // Cannot define
        return 0;
    }

    /**
     * Compare two character group structure(CGS) length and define
     * which one is longer.
     *
     * @param array $initial Initial CGS
     * @param array $compared Compared CGS
     * @param int   $type CGS type (Variable|Fixed length)
     *
     * @return int -1 if initial CGS longer
     *             0 if initial and compared CGS are equal
     *             1 if compared CGS longer
     */
    protected function compareStructureLengths(array $initial, array $compared, int $type = self::G_FIXED): int
    {
        // Iterate character group structures
        foreach ($initial as $index => $initialGroup) {
            $comparedGroup = $compared[$index];
            // Check if character group matches passed character group type
            if ($initialGroup[0] === $type) {
                $return = $this->compareCSGData($initialGroup, $comparedGroup, $type);

                // Compare character group length
                if ($return !== 0) {
                    return $return;
                }

                // Continue to next CGS
            }
        }

        // CGS have equal length
        return 0;
    }
}


1			<?php declare(strict_types=1);
2			/**
3			* Created by Vitaly Iegorov <[email protected]>.
4			* on 05.04.17 at 15:18
5			*/
6			namespace samsonframework\stringconditiontree;
7
8			use samsonframework\stringconditiontree\string\Structure;
9
10			/**
11			* Parametrized strings sorting.
12			*
13			* @author Vitaly Egorov <[email protected]>
14			*/
15			class StructureSorter
16			{
17			/** Variable length characters group */
18			const G_VARIABLE = 0;
19
20			/** Fixed length characters group */
21			const G_FIXED = 1;
22
23			/** @var string Parametrized string start marker */
24			protected $parameterStartMarker;
25
26			/** @var string Parametrized string end marker */
27			protected $parameterEndMarker;
28
29			/**
30			* StructureSorter constructor.
31			*
32			* @param string $parameterStartMarker Parametrized string start marker
33			* @param string $parameterEndMarker Parametrized string end marker
34			*/
35	1		public function __construct(string $parameterStartMarker, string $parameterEndMarker)
36			{
37	1		$this->parameterStartMarker = $parameterStartMarker;
38	1		$this->parameterEndMarker = $parameterEndMarker;
39	1		}
40
41			/**
42			* Sort strings array considering PCG and NPCG string structure.
43			*
44			* @param array $input Input array for sorting
45			*
46			* @return array Sorted keys array
47			*/
48	1		public function sortArrayByKeys(array $input): array
49			{
50			/** @var Structure[] $structures */
51	1		$structures = [];
52	1		foreach (array_keys($input) as $string) {
53	1		$structures[$string] = new Structure($string);
54			}
55
56	1		usort($structures, function(Structure $initial, Structure $compared) {
			0 ignored issues – show Coding Style introduced 2017-04-06 13:10 UTC by Report Bug Copy Issue Report Expected 1 space after FUNCTION keyword; 0 found Loading history...
57	1		return $initial->compare($compared);
58	1		});
59
60	1		$structures = array_reverse($structures);
61
62			// Restore initial strings sub-arrays
63	1		$result = [];
64	1		foreach ($structures as $structure) {
65	1		$result[$structure->input] = $input[$structure->input];
66			}
67	1		return $result;
68
69
70			// Convert string array keys into structure arrays
71			$prefixes = array_map([$this, 'getPrefixStructure'], array_keys($input));
			0 ignored issues – show Unused Code introduced 2017-04-06 13:10 UTC by Report Bug Copy Issue Report `// Convert string array ...), array_keys($input));` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
72
73			// Sort parametrized string array according sorting rules
74			usort($prefixes, [$this, 'compareStringStructure']);
75
76			// Restore initial strings sub-arrays
77			$result = [];
78			foreach ($prefixes as $sortingData) {
79			$result[$sortingData[0][2]] = $input[$sortingData[0][2]];
80			}
81			return $result;
82			}
83
84			/**
85			* Build string character group structure considering parametrized
86			* and not parametrized character groups and their length(PCG, NPCG).
87			*
88			* @param string $prefix Prefix string
89			*
90			* @return array String character groups structure
91			*/
92			protected function getPrefixStructure(string $prefix): array
93			{
94			/** @var array $structureMatrix String PCG(0)/NPCG(1) structure matrix for comparison */
95			$structureMatrix = [];
96
97			// Flags for showing current string character group
98			/** @var bool $isPCG Flags showing PCG started */
99			$isPCG = false;
100			/** @var bool $isNPCG Flags showing NPCG started */
101			$isNPCG = true;
102
103			// Pointer to current CG to count string NPCG length
104			$currentCG = 0;
105
106			/**
107			* TODO: Try to find PCG filter :... pattern and process it also as
108			* PCG with filters should be prioritized over PSG without filter
109			* even if filter is .*
110			*/
111
112			// Iterate string by characters
113			for ($i = 0, $length = strlen($prefix); $i < $length; $i++) {
114			if (!$isPCG && $prefix{$i} === $this->parameterStartMarker) {
115			$isPCG = true;
116			$isNPCG = false;
117			$structureMatrix[] = [0, 0, $prefix];
118			$currentCG = &$structureMatrix[count($structureMatrix) - 1][1];
119			} elseif ($isPCG && $prefix{$i} === $this->parameterEndMarker) {
120			$isPCG = false;
121			$isNPCG = true;
122			} elseif ($isNPCG) {
123			$isNPCG = false;
124			$structureMatrix[] = [1, 0, $prefix];
125			$currentCG = &$structureMatrix[count($structureMatrix) - 1][1];
126			}
127
128			// Store current character group length
129			$currentCG++;
130			}
131
132			return $structureMatrix;
133			}
134
135			/**
136			* Compare string structures.
137			*
138			* @param array $initial Initial string structure
139			* @param array $compared Compared string structure
140			*
141			* @return int Result of array elements comparison
142			*/
143			protected function compareStringStructure(array $initial, array $compared): int
144			{
145			$this->equalizeStructures($initial, $compared);
146
147			/**
148			* If all CG in structure are fixed then shortest should have higher priority
149			* If first CG is variable and second is fixed then longest fixed should have higher priority.
150			*/
151
152			// Iterate every CGS
153			foreach ($initial as $key => $initialGroup) {
154			$comparedGroup = $compared[$key];
155
156			/**
157			* FCG has higher priority then VCG.
158			* Compare CG type
159			*/
160			$return = $this->compareCSGData($initialGroup, $comparedGroup, self::G_VARIABLE, 0);
161
162			// If CG are equal and are fixed type
163			if ($key > 0 && $return === 0 && $initialGroup[0] === self::G_FIXED) {
164			/**
165			* Compare fixed CG lengths. Fixed CG longer
166			* should have higher priority.
167			*/
168			$return = $this->compareCSGData($initialGroup, $comparedGroup, self::G_VARIABLE, 1);
169			}
170
171			if ($return !== 0) {
172			return $return;
173			}
174
175			// They are equal continue to next structure group comparison
176			}
177
178			// Compare fixed length CGS
179			$return = $this->compareStructureLengths($initial, $compared, self::G_FIXED);
180
181			// Fixed CGS are equal
182			if ($return === 0) {
183			// Compare variable length CGS
184			$return = $this->compareStructureLengths($initial, $compared, self::G_VARIABLE);
185			}
186
187			return $return;
188			}
189
190			/**
191			* Make CGS equals size.
192			*
193			* @param array $initial Initial CGS, will be changed
194			* @param array $compared Compared CGS, will be changed
195			*
196			* @return int Longest CGS size(now they are both equal)
197			*/
198			protected function equalizeStructures(array &$initial, array &$compared): int
199			{
200			$size = max(count($initial), count($compared));
201
202			// Make structures same size preserving previous existing structure value
203			for ($i = 1; $i < $size; $i++) {
204			$this->fillMissingStructureGroup($initial, $i);
205			$this->fillMissingStructureGroup($compared, $i);
206			}
207
208			return $size;
209			}
210
211			/**
212			* Fill CSG with previous group value if not present.
213			*
214			* @param array $groups CSG for filling
215			* @param int $index CSG index
216			*/
217			private function fillMissingStructureGroup(array &$groups, int $index)
218			{
219			if (!array_key_exists($index, $groups)) {
220			$groups[$index] = $groups[$index - 1];
221			}
222			}
223
224			/**
225			* Compare longer CGS considering that:
226			* - Shortest fixed CGS should have higher priority
227			* - Longest variable CGS should have higher priority
228			*
229			* @param array $initialGroup Initial CGS
230			* @param array $comparedGroup Compared CGS
231			* @param int $type Fixed/Variable CGS
232			* @param int $dataIndex CSG creationData index
233			*
234			* @return int 0 if initial CGS is not longer than compared,
235			* otherwise -1/1 depending on CGS type.
236			*/
237			private function compareCSGData(array $initialGroup, array $comparedGroup, int $type, int $dataIndex = 1): int
238			{
239			// Compare character group length
240		View Code Duplication	if ($initialGroup[$dataIndex] > $comparedGroup[$dataIndex]) {
			0 ignored issues – show Duplication introduced 2017-04-05 17:17 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
241			return ($type === self::G_FIXED ? 1 : -1);
242			}
243
244		View Code Duplication	if ($initialGroup[$dataIndex] < $comparedGroup[$dataIndex]) {
			0 ignored issues – show Duplication introduced 2017-04-05 14:16 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
245			return ($type === self::G_FIXED ? -1 : 1);
246			}
247
248			// Cannot define
249			return 0;
250			}
251
252			/**
253			* Compare two character group structure(CGS) length and define
254			* which one is longer.
255			*
256			* @param array $initial Initial CGS
257			* @param array $compared Compared CGS
258			* @param int $type CGS type (Variable\|Fixed length)
259			*
260			* @return int -1 if initial CGS longer
261			* 0 if initial and compared CGS are equal
262			* 1 if compared CGS longer
263			*/
264			protected function compareStructureLengths(array $initial, array $compared, int $type = self::G_FIXED): int
265			{
266			// Iterate character group structures
267			foreach ($initial as $index => $initialGroup) {
268			$comparedGroup = $compared[$index];
269			// Check if character group matches passed character group type
270			if ($initialGroup[0] === $type) {
271			$return = $this->compareCSGData($initialGroup, $comparedGroup, $type);
272
273			// Compare character group length
274			if ($return !== 0) {
275			return $return;
276			}
277
278			// Continue to next CGS
279			}
280			}
281
282			// CGS have equal length
283			return 0;
284			}
285			}
286

samsonframework / string-condition-tree

Push — master ( e2d05f...edeffb )

StructureSorter::sortArrayByKeys() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like