samsonframework\stringconditiontree\StructureSorter

Complexity

Total Complexity

32

Size/Duplication

Total Lines	271
Duplicated Lines	2.21 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

21.92%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	sortArrayByKeys()	0	35	4
C	getPrefixStructure()	0	42	7
C	compareStringStructure()	0	46	7
A	equalizeStructures()	0	12	2
A	fillMissingStructureGroup()	0	6	2
B	compareCSGData()	6	14	5
A	compareStructureLengths()	0	21	4

<?php declare(strict_types=1);
/**
 * Created by Vitaly Iegorov <egorov@samsonos.com>.
 * on 05.04.17 at 15:18
 */
namespace samsonframework\stringconditiontree;

use samsonframework\stringconditiontree\string\Structure;

/**
 * Parametrized strings sorting.
 *
 * @author Vitaly Egorov <egorov@samsonos.com>
 */
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) {

Expected 1 space after FUNCTION keyword; 0 found

            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));

// Convert string array keys into structure arrays $prefixes = array_map(array($this, 'getPrefixStructure'), array_keys($input)); does not seem to be reachable.

        // 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]) {

This code seems to be duplicated across your project.

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

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

This code seems to be duplicated across your project.

            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;
    }
}