TYPO3\PharStreamWrapper\Resolver\BaseNameResolver

Complexity

Total Complexity

18

Size/Duplication

Total Lines	95
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	resolveBaseNameFromAliasMap()	0	5	2
A	purgeBaseName()	0	3	1
A	__construct()	0	6	2
A	learnAlias()	0	8	4
B	resolveBaseName()	0	21	9

<?php
declare(strict_types=1);
namespace TYPO3\PharStreamWrapper\Resolver;

/*
 * This file is part of the TYPO3 project.
 *
 * It is free software; you can redistribute it and/or modify it under the terms
 * of the MIT License (MIT). For the full copyright and license information,
 * please read the LICENSE file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\PharStreamWrapper\Helper;
use TYPO3\PharStreamWrapper\Phar\Reader;
use TYPO3\PharStreamWrapper\Resolvable;

class BaseNameResolver implements Resolvable
{
    const RESOLVE_REALPATH = 1;
    const RESOLVE_ALIAS = 2;

    /**
     * @var AliasMap
     */
    private $aliasMap = [];

    /**
     * @param null|AliasMap $aliasMap
     */
    public function __construct(AliasMap $aliasMap = null)
    {
        if ($aliasMap === null) {
            $aliasMap = new AliasMap();
        }
        $this->aliasMap = $aliasMap;
    }

    /**
     * @param string $path
     * @param int|null $flags
     * @return null|string
     */
    public function resolveBaseName(string $path, int $flags = null)
    {
        $hasPharPrefix = Helper::hasPharPrefix($path);
        $flags = $flags ?? static::RESOLVE_REALPATH | static::RESOLVE_ALIAS;

        if ($hasPharPrefix && $flags & static::RESOLVE_ALIAS) {
            $baseNameFromAliasMap = $this->resolveBaseNameFromAliasMap($path);
            if ($baseNameFromAliasMap !== null) {
                return $baseNameFromAliasMap->getBaseName();
            }
        }

        $baseName = Helper::determineBaseFile($path);
        if ($baseName !== null && $flags & static::RESOLVE_REALPATH) {
            $baseName = realpath($baseName);
        }
        if ($baseName !== null && $hasPharPrefix && $flags & static::RESOLVE_ALIAS) {
            $this->learnAlias($baseName);
        }

        return $baseName;
    }

    /**
     * @param string $baseName
     * @return bool
     * @todo Enhance design, wrapping does not make much sense in this class
     */
    public function purgeBaseName(string $baseName): bool
    {
        return $this->aliasMap->purgeByBaseName($baseName);
    }

    /**
     * @param string $path
     * @return null|AliasReference
     */
    private function resolveBaseNameFromAliasMap(string $path)
    {
        $normalizedPath = Helper::normalizePath($path);
        $possibleAlias = strstr($normalizedPath, '/', true);
        return $this->aliasMap->findLastByAlias($possibleAlias ?: '');
    }


    /**
     * Learns (possible) Phar alias for given $baseName.
     *
     * Phar aliases are intended to be used only inside Phar archives, however
     * PharStreamWrapper needs this information exposed outside of Phar as well
     *
     * It is possible that same alias is used for different $baseName values.
     * That's why AliasMap behaves like a stack when resolving base-name for a
     * given alias. On the other hand it is not possible that one $baseName is
     * referring to multiple aliases.
     *
     * @param string $basePath
     *
     * @see https://secure.php.net/manual/en/phar.setalias.php
     * @see https://secure.php.net/manual/en/phar.mapphar.php
     */
    private function learnAlias(string $basePath)
    {
        if ($this->aliasMap->findFirstByBaseName($basePath) !== null) {
            return;
        }
        $alias = (new Reader($basePath))->resolveContainer()->getAlias();
        if ($alias !== '' && $alias !== $basePath) {
            $this->aliasMap->append($basePath, $alias);
        }
    }
}