Humbug\PhpScoper\Scoper\Composer\AutoloadPrefixer

Complexity

Total Complexity

32

Size/Duplication

Total Lines	174
Duplicated Lines	5.75 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

95.65%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	prefixPackageAutoloadStatements()	0	16	4
A	prefixAutoloadStatements()	0	20	5
A	prefixAutoload()	0	15	3
A	mergePSR0And4()	0	20	4
A	updatePSR0Path()	0	25	5
B	mergeNamespaces()	10	27	9
A	prefixLaravelProviders()	0	12	2

<?php

declare(strict_types=1);

/*
 * This file is part of the humbug/php-scoper package.
 *
 * Copyright (c) 2017 Théo FIDRY <theo.fidry@gmail.com>,
 *                    Pádraic Brady <padraic.brady@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Humbug\PhpScoper\Scoper\Composer;

use Humbug\PhpScoper\Whitelist;
use stdClass;
use function array_map;
use function is_array;
use function is_string;
use function str_replace;

/**
 * @private
 */
final class AutoloadPrefixer
{
    /**
     * @param stdClass $contents Decoded JSON
     * @param string   $prefix
     *
     * @return stdClass Prefixed decoded JSON
     */
    public static function prefixPackageAutoloadStatements(stdClass $contents, string $prefix, Whitelist $whitelist): stdClass
    {
        if (isset($contents->autoload)) {
            $contents->autoload = self::prefixAutoloadStatements($contents->autoload, $prefix, $whitelist);
        }

        if (isset($contents->{'autoload-dev'})) {
            $contents->{'autoload-dev'} = self::prefixAutoloadStatements($contents->{'autoload-dev'}, $prefix, $whitelist);
        }

        if (isset($contents->extra, $contents->extra->laravel, $contents->extra->laravel->providers)) {
            $contents->extra->laravel->providers = self::prefixLaravelProviders($contents->extra->laravel->providers, $prefix, $whitelist);
        }

        return $contents;
    }

    private static function prefixAutoloadStatements(stdClass $autoload, string $prefix, Whitelist $whitelist): stdClass
    {
        if (false === isset($autoload->{'psr-4'}) && false === isset($autoload->{'psr-0'})) {
            return $autoload;
        }

        if (isset($autoload->{'psr-0'})) {
            $autoload->{'psr-4'} = self::mergePSR0And4(
                (array) $autoload->{'psr-0'},
                (array) ($autoload->{'psr-4'} ?? new stdClass())
            );
        }
        unset($autoload->{'psr-0'});

        if (isset($autoload->{'psr-4'})) {
            $autoload->{'psr-4'} = self::prefixAutoload((array) $autoload->{'psr-4'}, $prefix, $whitelist);
        }

        return $autoload;
    }

    private static function prefixAutoload(array $autoload, string $prefix, Whitelist $whitelist): array
    {
        $loader = [];

        foreach ($autoload as $namespace => $paths) {
            $newNamespace = $whitelist->belongsToWhitelistedNamespace($namespace)
                ? $namespace
                : sprintf('%s\\%s', $prefix, $namespace)
            ;

            $loader[$newNamespace] = $paths;
        }

        return $loader;
    }

    /**
     * @param (string|string[])[] $psr0
     * @param (string|string[])[] $psr4
     *
     * @return (string|string[])[]
     */
    private static function mergePSR0And4(array $psr0, array $psr4): array
    {
        foreach ($psr0 as $namespace => $path) {
            //Append backslashes, if needed, since psr-0 does not require this
            if ('\\' !== substr($namespace, -1)) {
                $namespace .= '\\';
            }

            $path = self::updatePSR0Path($path, (string) $namespace);

            if (!isset($psr4[$namespace])) {
                $psr4[$namespace] = $path;

                continue;
            }
            $psr4[$namespace] = self::mergeNamespaces((string) $namespace, $path, $psr4);

It seems like $path defined by self::updatePSR0Path($path, (string) $namespace) on line 103 can also be of type array; however, Humbug\PhpScoper\Scoper\Composer\AutoloadPrefixer::mergeNamespaces() does only seem to accept string|array<integer,string>, maybe add an additional type check?

$psr4 is of type array<string|integer,string|array>, but the function expects a array<integer,string|array<integer,string>>.

        }

        return $psr4;
    }

    /**
     * @param string|string[] $path
     *
     * @return string|string[]
     */
    private static function updatePSR0Path($path, string $namespace)
    {
        $namespaceForPsr = str_replace('\\', '/', $namespace);

        if (false === is_array($path)) {
            if ('/' !== substr($path, -1)) {
                $path .= '/';
            }

            $path .= $namespaceForPsr.'/';

            return $path;
        }

        foreach ($path as $key => $item) {
            if ('/' !== substr($item, -1)) {
                $item .= '/';
            }

            $item .= $namespaceForPsr.'/';
            $path[$key] = $item;
        }

        return $path;
    }

    /**
     * Deals with the 4 possible scenarios:
     *       PSR0 | PSR4
     * array      |
     * string     |
     * or simply the namespace not existing as a psr-4 entry.
     *
     * @param string              $psr0Namespace
     * @param string|string[]     $psr0Path
     * @param (string|string[])[] $psr4
     *
     * @return string|string[]
     */
    private static function mergeNamespaces(string $psr0Namespace, $psr0Path, array $psr4)
    {
        // Both strings
        if (is_string($psr4[$psr0Namespace]) && is_string($psr0Path)) {
            return [$psr4[$psr0Namespace], $psr0Path];
        }

        // PSR-4 is string, and PSR-0 is array
        if (is_string($psr4[$psr0Namespace]) && is_array($psr0Path)) {

This code seems to be duplicated across your project.

            $psr0Path[] = $psr4[$psr0Namespace];

            return $psr0Path;
        }

        // Psr-4 is array and psr-0 is string
        if (is_array($psr4[$psr0Namespace]) && is_string($psr0Path)) {

This code seems to be duplicated across your project.

            $psr4[$psr0Namespace][] = $psr0Path;

            return $psr4[$psr0Namespace];
        }

        if (is_array($psr4[$psr0Namespace]) && is_array($psr0Path)) {
            return array_merge($psr4[$psr0Namespace], $psr0Path);
        }

        return $psr0Path;
    }

    private static function prefixLaravelProviders(array $providers, string $prefix, Whitelist $whitelist): array
    {
        return array_map(
            static function (string $provider) use ($prefix, $whitelist): string {
                return $whitelist->belongsToWhitelistedNamespace($provider)
                    ? $provider
                    : sprintf('%s\\%s', $prefix, $provider)
                ;
            },
            $providers
        );
    }
}