YamlStandards\Model\YamlAlphabetical\YamlAlphabeticalDataFactory

Complexity

Total Complexity

34

Size/Duplication

Total Lines	166
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
C	createRightSortedYamlLines()	0	32	15
A	getCorrectYamlLines()	0	8	1
A	sortArrayKeyWithUnderscoresAsFirst()	0	9	1
A	recursiveKsort()	0	12	4
A	sortArray()	0	15	5
B	sortArrayAlphabetical()	0	35	8

<?php

declare(strict_types=1);

namespace YamlStandards\Model\YamlAlphabetical;

use YamlStandards\Model\Component\Parser\YamlParser;
use YamlStandards\Model\Component\Parser\YamlParserLineData;
use YamlStandards\Model\Component\YamlService;

class YamlAlphabeticalDataFactory
{
    public const REGEX_KEY_COMMON_LINE_WITH_NUMBER_AT_END = '/' . YamlParserLineData::KEY_COMMON_LINE . '\d+$/';
    public const REGEX_KEY_COMMENT_OR_EMPTY_LINE_WITH_NUMBER_AT_END = '/' . YamlParserLineData::KEY_COMMENT_OR_EMPTY_LINE . '\d+$/';
    public const REGEX_KEY_DASH_WITH_NUMBER_AT_END = '/' . YamlParserLineData::KEY_DASH . '\d+$/';
    public const REGEX_KEY_EMPTY_ARRAY_WITH_NUMBER_AT_END = '/' . YamlParserLineData::KEY_EMPTY_ARRAY . '\d+$/';
    public const REGEX_KEY_ARRAY_WITHOUT_KEY_WITH_NUMBER_AT_END = '/^' . YamlParserLineData::KEY_ARRAY_WITHOUT_KEY . '\d+/';
    public const REGEX_KEY_CURLY_BRACKETS_WITH_NUMBER_AT_END = '/' . YamlParserLineData::KEY_CURLY_BRACKETS . '\d+$/';

    public const REGEX_VALUE_EMPTY_LINE = '/' . YamlParserLineData::EMPTY_LINE_DEFAULT_VALUE . '$/';

    /**
     * @var int
     */
    private static $index;

    /**
     * @param string $pathToYamlFile
     * @param int $depth
     * @return string[]
     */
    public static function getCorrectYamlLines(string $pathToYamlFile, int $depth): array
    {
        self::$index = 0; // start from 0 in every file

        $yamlArrayData = YamlParser::getYamlParsedDataFromFile($pathToYamlFile);
        $yamlArrayDataSorted = self::sortArray($yamlArrayData, $depth);

        return self::createRightSortedYamlLines($yamlArrayDataSorted);

The expression return self::createRightSortedYamlLines($yamlArrayDataSorted) returns an array which contains values of type array|string[] which are incompatible with the documented value type string.

    }

    /**
     * @param string[] $yamlArrayData
     * @param int $depth
     * @return string[]
     */
    private static function sortArray(array $yamlArrayData, int $depth): array
    {
        if ($depth > 0) {
            $yamlArrayData = self::sortArrayKeyWithUnderscoresAsFirst($yamlArrayData);

            if ($depth > 1) {
                foreach ($yamlArrayData as $key => $value) {
                    if (is_array($value)) {
                        $yamlArrayData[$key] = self::recursiveKsort($value, $depth);
                    }
                }
            }
        }

        return $yamlArrayData;
    }

    /**
     * @param string[] $yamlArrayData
     * @param int $depth
     * @param int $currentDepth
     * @return string[]
     */
    private static function recursiveKsort(array $yamlArrayData, int $depth, int $currentDepth = 1): array
    {
        $yamlArrayData = self::sortArrayKeyWithUnderscoresAsFirst($yamlArrayData);
        foreach ($yamlArrayData as $key => $value) {
            if (is_array($value)) {
                if ($currentDepth <= $depth) {
                    $yamlArrayData[$key] = self::recursiveKsort($value, $depth, $currentDepth + 1);
                }
            }
        }

        return $yamlArrayData;
    }

    /**
     * @param string[] $yamlArrayData
     * @return string[]|string[][]
     */
    private static function sortArrayKeyWithUnderscoresAsFirst(array $yamlArrayData): array
    {
        $arrayWithUnderscoreKeys = array_filter($yamlArrayData, [YamlService::class, 'hasArrayKeyUnderscoreAsFirstCharacter'], ARRAY_FILTER_USE_KEY);
        $arrayWithOtherKeys = array_filter($yamlArrayData, [YamlService::class, 'hasNotArrayKeyUnderscoreAsFirstCharacter'], ARRAY_FILTER_USE_KEY);

        uksort($arrayWithUnderscoreKeys, ['self', 'sortArrayAlphabetical']);
        uksort($arrayWithOtherKeys, ['self', 'sortArrayAlphabetical']);

        return array_merge($arrayWithUnderscoreKeys, $arrayWithOtherKeys);
    }

    /**
     * @param string $key1
     * @param string $key2
     * @return int
     */
    private static function sortArrayAlphabetical(string $key1, string $key2): int
    {
        // remove added text for empty line and comment line
        $key1WithoutNumberAtEnd = preg_replace(self::REGEX_KEY_COMMENT_OR_EMPTY_LINE_WITH_NUMBER_AT_END, '', $key1);
        $key2WithoutNumberAtEnd = preg_replace(self::REGEX_KEY_COMMENT_OR_EMPTY_LINE_WITH_NUMBER_AT_END, '', $key2);

        // add key number to end for fix situation when keys are same
        preg_match('/\d+$/', $key1WithoutNumberAtEnd, $key1NumberAtEnd);
        preg_match('/\d+$/', $key2WithoutNumberAtEnd, $key2NumberAtEnd);
        $key1NumberAtEnd = count($key1NumberAtEnd) === 0 ? 0 : reset($key1NumberAtEnd);
        $key2NumberAtEnd = count($key2NumberAtEnd) === 0 ? 0 : reset($key2NumberAtEnd);

        $key1WithoutNumberAtEnd = preg_match(self::REGEX_KEY_COMMON_LINE_WITH_NUMBER_AT_END, $key1WithoutNumberAtEnd) === 0 ? $key1WithoutNumberAtEnd : preg_replace(self::REGEX_KEY_COMMON_LINE_WITH_NUMBER_AT_END, '', $key1WithoutNumberAtEnd);
        $key1WithoutNumberAtEnd = preg_match(self::REGEX_KEY_ARRAY_WITHOUT_KEY_WITH_NUMBER_AT_END, $key1WithoutNumberAtEnd) === 0 ? $key1WithoutNumberAtEnd : preg_replace(self::REGEX_KEY_ARRAY_WITHOUT_KEY_WITH_NUMBER_AT_END, '', $key1WithoutNumberAtEnd);

        $key2WithoutNumberAtEnd = preg_match(self::REGEX_KEY_COMMON_LINE_WITH_NUMBER_AT_END, $key2WithoutNumberAtEnd) === 0 ? $key2WithoutNumberAtEnd : preg_replace(self::REGEX_KEY_COMMON_LINE_WITH_NUMBER_AT_END, '', $key2WithoutNumberAtEnd);
        $key2WithoutNumberAtEnd = preg_match(self::REGEX_KEY_ARRAY_WITHOUT_KEY_WITH_NUMBER_AT_END, $key2WithoutNumberAtEnd) === 0 ? $key2WithoutNumberAtEnd : preg_replace(self::REGEX_KEY_ARRAY_WITHOUT_KEY_WITH_NUMBER_AT_END, '', $key2WithoutNumberAtEnd);

        /*
         * add exclamation mark (!) to penultimate position in string for fix order for "dot" key scenario, e.g:
         * foo.bar:
         * foo.bar.baz:
         * ":" is in alphabetical higher as ".", https://s2799303.files.wordpress.com/2013/08/ascii-codes-table1.jpg
         */
        $key1WithoutNumberAtEnd = substr_replace($key1WithoutNumberAtEnd, '!', -1, 0);
        $key2WithoutNumberAtEnd = substr_replace($key2WithoutNumberAtEnd, '!', -1, 0);

        $key1WithoutNumberAtEnd .= $key1NumberAtEnd;
        $key2WithoutNumberAtEnd .= $key2NumberAtEnd;

        if ($key1WithoutNumberAtEnd === $key2WithoutNumberAtEnd) {
            return strnatcmp(trim($key2), trim($key1));
        }

        return strnatcmp(trim($key1WithoutNumberAtEnd), trim($key2WithoutNumberAtEnd));
    }

    /**
     * @param string[]|string[][] $sortedYamlData
     * @return string[]
     */
    private static function createRightSortedYamlLines(array $sortedYamlData): array
    {
        $rightSortedYamlLines = [];

        foreach ($sortedYamlData as $yamlKey => $yamlValue) {
            if (is_array($yamlValue) === false && ($yamlValue === YamlParserLineData::EMPTY_LINE_DEFAULT_VALUE || YamlService::isLineComment($yamlValue))) {

$yamlValue of type array is incompatible with the type string expected by parameter $yamlLine of YamlStandards\Model\Component\YamlService::isLineComment().

                $rightSortedYamlLines[] = preg_match(self::REGEX_VALUE_EMPTY_LINE, $yamlValue) === 0 ? $yamlValue : preg_replace(self::REGEX_VALUE_EMPTY_LINE, '', $yamlValue);

$yamlValue of type array is incompatible with the type string expected by parameter $subject of preg_match().

                continue;
            }

            $yamlKey = is_int($yamlKey) ? (string)$yamlKey : $yamlKey;
            if (preg_match(self::REGEX_KEY_COMMENT_OR_EMPTY_LINE_WITH_NUMBER_AT_END, $yamlKey) === 0 &&
                preg_match(self::REGEX_KEY_EMPTY_ARRAY_WITH_NUMBER_AT_END, $yamlKey) === 0
            ) {
                $key = preg_match(self::REGEX_KEY_COMMON_LINE_WITH_NUMBER_AT_END, $yamlKey) === 0 ? $yamlKey : preg_replace(self::REGEX_KEY_COMMON_LINE_WITH_NUMBER_AT_END, '', $yamlKey);
                $key = preg_match(self::REGEX_KEY_DASH_WITH_NUMBER_AT_END, $key) === 0 ? $key : preg_replace(self::REGEX_KEY_DASH_WITH_NUMBER_AT_END, '-', $key);
                $key = preg_match(self::REGEX_KEY_CURLY_BRACKETS_WITH_NUMBER_AT_END, $key) === 0 ? $key : preg_replace(self::REGEX_KEY_CURLY_BRACKETS_WITH_NUMBER_AT_END, '', $key);
                $key = preg_match(self::REGEX_KEY_ARRAY_WITHOUT_KEY_WITH_NUMBER_AT_END, $key) === 0 ? $key : preg_replace(self::REGEX_KEY_ARRAY_WITHOUT_KEY_WITH_NUMBER_AT_END, '', $key);
                $value = is_array($yamlValue) ? '' : $yamlValue;
                $rightSortedYamlLines[] = $key . $value;

                self::$index++;
            }

            if (is_array($yamlValue)) {
                $result = self::createRightSortedYamlLines($yamlValue);
                $rightSortedYamlLines = array_merge($rightSortedYamlLines, $result);
            }
        }

        return $rightSortedYamlLines;

The expression return $rightSortedYamlLines returns an array which contains values of type array|string[] which are incompatible with the documented value type string.

    }
}