StructureSorter::compareStringStructure() - Code Metrics - Inspection of "Refactored string comparison" - samsonframework/string-condition-tree - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 166358...a3a10e )

by Vitaly

created 2017-04-05 13:59 UTC

StructureSorter::compareStringStructure() C

↳ Parent: StructureSorter

Complexity

Conditions	16
Paths	140

Size

Total Lines	63
Code Lines	27

Duplication

Lines	14
Ratio	22.22 %

Importance

Changes

Metric	Value
dl	14
loc	63
rs	5.5345
c	0
b	0
f	0
cc	16
eloc	27
nc	140
nop	2

How to fix Long Method Complexity

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

/**
 * 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
    {
        // Convert string array keys into structure arrays
        $prefixes = array_map([$this, 'getPrefixStructure'], array_keys($input));

        // 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
    {
        $maxStructureSize = max(count($initial), count($compared));

        // Make structures same size preserving previous existing structure value
        for ($i = 1; $i < $maxStructureSize; $i++) {
            if (!array_key_exists($i, $initial)) {
                $initial[$i] = $initial[$i - 1];
            }
            if (!array_key_exists($i, $compared)) {
                $compared[$i] = $compared[$i - 1];
            }
        }

        // Iterate every structure group
        for ($i = 0; $i < $maxStructureSize; $i++) {
            // If initial structure has NPCG than it has higher priority
            if ($initial[$i][0] > $compared[$i][0]) {
                return -1;
            }

            // If compared structure has NPCG than it has higher priority
            if ($initial[$i][0] < $compared[$i][0]) {
                return 1;
            }

            // Compare NOT starting NPCG length
            if ($i > 0 && $initial[$i][0] === 1) {
                if ($initial[$i][1] > $compared[$i][1]) {
                    return -1;
                }

                if ($initial[$i][1] < $compared[$i][1]) {
                    return 1;
                }
            }

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

        // If both structures are equal compare lengths of NPCG
        for ($i = 0; $i < $maxStructureSize; $i++) {

            // If current CG is NPCG
            if ($initial[$i][0] === 1) {
                if ($initial[$i][1] > $compared[$i][1]) {
                    return 1;
                }

                if ($initial[$i][1] < $compared[$i][1]) {
                    return -1;
                }
            }

            // Current NPCG character groups have equal length - continue
        }

        $return = $this->compareStructureLengths($maxStructureSize, $initial, $compared, self::G_FIXED);
        if ($return === 0) {
            $return = $this->compareStructureLengths($maxStructureSize, $initial, $compared, self::G_VARIABLE);
        }

        return $return;
    }

    /**
     * Compare two character group structure(CGS) length and define
     * which one is longer.
     *
     * @param int   $size CGS size
     * @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(int $size, array $initial, array $compared, int $type = self::G_FIXED): int
    {
        // Iterate character group structures
        for ($i = 0; $i < $size; $i++) {

            // Check if character group matches passed character group type
            if ($initial[$i][$type] === $type) {
                // Compare character group length
                if ($initial[$i][1] > $compared[$i][1]) {
                    return -1;
                }

                if ($initial[$i][1] < $compared[$i][1]) {
                    return 1;
                }

                // Continue to next character group structure
            }
        }

        // Character group structures 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		/**
9		* Parametrized strings sorting.
10		*
11		* @author Vitaly Egorov <[email protected]>
12		*/
13		class StructureSorter
14		{
15		/** Variable length characters group */
16		const G_VARIABLE = 0;
17
18		/** Fixed length characters group */
19		const G_FIXED = 1;
20
21		/** @var string Parametrized string start marker */
22		protected $parameterStartMarker;
23
24		/** @var string Parametrized string end marker */
25		protected $parameterEndMarker;
26
27		/**
28		* StructureSorter constructor.
29		*
30		* @param string $parameterStartMarker Parametrized string start marker
31		* @param string $parameterEndMarker Parametrized string end marker
32		*/
33		public function __construct(string $parameterStartMarker, string $parameterEndMarker)
34		{
35		$this->parameterStartMarker = $parameterStartMarker;
36		$this->parameterEndMarker = $parameterEndMarker;
37		}
38
39		/**
40		* Sort strings array considering PCG and NPCG string structure.
41		*
42		* @param array $input Input array for sorting
43		*
44		* @return array Sorted keys array
45		*/
46		public function sortArrayByKeys(array $input): array
47		{
48		// Convert string array keys into structure arrays
49		$prefixes = array_map([$this, 'getPrefixStructure'], array_keys($input));
50
51		// Sort parametrized string array according sorting rules
52		usort($prefixes, [$this, 'compareStringStructure']);
53
54		// Restore initial strings sub-arrays
55		$result = [];
56		foreach ($prefixes as $sortingData) {
57		$result[$sortingData[0][2]] = $input[$sortingData[0][2]];
58		}
59		return $result;
60		}
61
62		/**
63		* Build string character group structure considering parametrized
64		* and not parametrized character groups and their length(PCG, NPCG).
65		*
66		* @param string $prefix Prefix string
67		*
68		* @return array String character groups structure
69		*/
70		protected function getPrefixStructure(string $prefix): array
71		{
72		/** @var array $structureMatrix String PCG(0)/NPCG(1) structure matrix for comparison */
73		$structureMatrix = [];
74
75		// Flags for showing current string character group
76		/** @var bool $isPCG Flags showing PCG started */
77		$isPCG = false;
78		/** @var bool $isNPCG Flags showing NPCG started */
79		$isNPCG = true;
80
81		// Pointer to current CG to count string NPCG length
82		$currentCG = 0;
83
84		/**
85		* TODO: Try to find PCG filter :... pattern and process it also as
86		* PCG with filters should be prioritized over PSG without filter
87		* even if filter is .*
88		*/
89
90		// Iterate string by characters
91		for ($i = 0, $length = strlen($prefix); $i < $length; $i++) {
92		if (!$isPCG && $prefix{$i} === $this->parameterStartMarker) {
93		$isPCG = true;
94		$isNPCG = false;
95		$structureMatrix[] = [0, 0, $prefix];
96		$currentCG = &$structureMatrix[count($structureMatrix) - 1][1];
97		} elseif ($isPCG && $prefix{$i} === $this->parameterEndMarker) {
98		$isPCG = false;
99		$isNPCG = true;
100		} elseif ($isNPCG) {
101		$isNPCG = false;
102		$structureMatrix[] = [1, 0, $prefix];
103		$currentCG = &$structureMatrix[count($structureMatrix) - 1][1];
104		}
105
106		// Store current character group length
107		$currentCG++;
108		}
109
110		return $structureMatrix;
111		}
112
113		/**
114		* Compare string structures.
115		*
116		* @param array $initial Initial string structure
117		* @param array $compared Compared string structure
118		*
119		* @return int Result of array elements comparison
120		*/
121		protected function compareStringStructure(array $initial, array $compared): int
122		{
123		$maxStructureSize = max(count($initial), count($compared));
124
125		// Make structures same size preserving previous existing structure value
126		for ($i = 1; $i < $maxStructureSize; $i++) {
127		if (!array_key_exists($i, $initial)) {
128		$initial[$i] = $initial[$i - 1];
129		}
130		if (!array_key_exists($i, $compared)) {
131		$compared[$i] = $compared[$i - 1];
132		}
133		}
134
135		// Iterate every structure group
136		for ($i = 0; $i < $maxStructureSize; $i++) {
137		// If initial structure has NPCG than it has higher priority
138		if ($initial[$i][0] > $compared[$i][0]) {
139		return -1;
140		}
141
142		// If compared structure has NPCG than it has higher priority
143		if ($initial[$i][0] < $compared[$i][0]) {
144		return 1;
145		}
146
147		// Compare NOT starting NPCG length
148		if ($i > 0 && $initial[$i][0] === 1) {
149		if ($initial[$i][1] > $compared[$i][1]) {
150		return -1;
151		}
152
153		if ($initial[$i][1] < $compared[$i][1]) {
154		return 1;
155		}
156		}
157
158		// They are equal continue to next structure group comparison
159		}
160
161		// If both structures are equal compare lengths of NPCG
162	View Code Duplication	for ($i = 0; $i < $maxStructureSize; $i++) {
		0 ignored issues – show Duplication introduced 2017-04-05 13:34 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...
163		// If current CG is NPCG
164		if ($initial[$i][0] === 1) {
165		if ($initial[$i][1] > $compared[$i][1]) {
166		return 1;
167		}
168
169		if ($initial[$i][1] < $compared[$i][1]) {
170		return -1;
171		}
172		}
173
174		// Current NPCG character groups have equal length - continue
175		}
176
177		$return = $this->compareStructureLengths($maxStructureSize, $initial, $compared, self::G_FIXED);
178		if ($return === 0) {
179		$return = $this->compareStructureLengths($maxStructureSize, $initial, $compared, self::G_VARIABLE);
180		}
181
182		return $return;
183		}
184
185		/**
186		* Compare two character group structure(CGS) length and define
187		* which one is longer.
188		*
189		* @param int $size CGS size
190		* @param array $initial Initial CGS
191		* @param array $compared Compared CGS
192		* @param int $type CGS type (Variable\|Fixed length)
193		*
194		* @return int -1 if initial CGS longer
195		* 0 if initial and compared CGS are equal
196		* 1 if compared CGS longer
197		*/
198		protected function compareStructureLengths(int $size, array $initial, array $compared, int $type = self::G_FIXED): int
199		{
200		// Iterate character group structures
201	View Code Duplication	for ($i = 0; $i < $size; $i++) {
		0 ignored issues – show Duplication introduced 2017-04-05 14:03 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...
202		// Check if character group matches passed character group type
203		if ($initial[$i][$type] === $type) {
204		// Compare character group length
205		if ($initial[$i][1] > $compared[$i][1]) {
206		return -1;
207		}
208
209		if ($initial[$i][1] < $compared[$i][1]) {
210		return 1;
211		}
212
213		// Continue to next character group structure
214		}
215		}
216
217		// Character group structures have equal length
218		return 0;
219		}
220		}
221

samsonframework / string-condition-tree

Push — master ( 166358...a3a10e )

StructureSorter::compareStringStructure() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like