Exen\Konfig\Utils::trimWhitespace()

Complexity

Conditions	11
Paths	37

Size

Total Lines	82
Code Lines	34

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public static function trimWhitespace($string, array $options = [])
    {
        if (!is_string($string)) {
            return '';
        }

        $o = array_merge(
            [
                'leading' => true,
                'inside' => true,
                'blankLines' => 0,
                'tabWidth' => 4,
            ],
            $options
        );

        // Looking for spaces *and* tab characters is way too costly
        // (running times go x4 or x10) so we forcefully replace tab characters
        // with spaces, but make it configurable.
        $tabw = $o['tabWidth'];

        if (!is_int($tabw) || $tabw < 1 || $tabw > 8) {
            $tabw = 4;
        }

        // Replacement patterns should be applied in a specific order
        $patterns = [];

        // Trim leading whitespace first (if active). In typical scenarios,
        // especially for indented HTML, this will remove of the target whitespace
        // and it turns out to be really quick.
        if ($o['leading']) {
            $patterns[] = ['/^ {2,}/m', ''];
        }

        // Always trim at the end. Warning: this seems to be the costlier
        // operation, perhaps because looking ahead is harder?
        $patterns[] = ['/ +$/m', ''];

        // Collapse space sequences inside lines (excluding leading/trailing)
        if ($o['inside']) {
            // No leading spaces? We can avoid a very costly condition!
            // Using a look-behind (or similar solutions) seems to make the whole
            // function go 2x-4x slower (PHP7) or up to 10x slower (PHP 5.6),
            // except on very big strings where whatever perf penalty was incurred
            // seems to be more limited (or at least not exponential).
            $spaces = ($o['leading'] ? ' ' : '(?<=\b) ') . '{2,}';
            $patterns[] = ['/' . $spaces . '/', ' '];
        }

        // Remove empty lines
        if (is_int($l = $o['blankLines']) && $l >= 0) {
            // We need blank lines to be truly empty; if trimStart is disabled
            // we have to fall back to this slightly more costly regex.
            if (!$o['leading']) {
                $patterns[] = ['/^ +$/m', ''];
            }

            // Not using '\R' because it's too slow, so we must do it by hand
            // and replace CRLF before touching any LF.
            $patterns[] = ['/(\r\n){' . ($l + 2) . ',}/m', str_repeat("\r\n", $l + 1)];
            $patterns[] = ['/\n{' . ($l + 2) . ',}/m', str_repeat("\n", $l + 1)];
        }

        // Doing the replacement in one go without storing intermediary
        // values helps a bit for big strings (around 20 percent quicker).
        return preg_replace(
            array_map(
                function ($x) {
                    return $x[0];
                },
                $patterns
            ),
            array_map(
                function ($x) {
                    return $x[1];
                },
                $patterns
            ),
            str_replace("\t", str_repeat(' ', $tabw), $string)
        );
    }