PharInvocationResolver::resolve() - Code Metrics - Inspection of "Merge pull request #20 from TYPO3/task/v2-backport..." - TYPO3/phar-stream-wrapper - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — v2 (b7a21f)

by Oliver

created 2019-03-01 23:02 UTC

PharInvocationResolver::resolve() B

↳ Parent: PharInvocationResolver

Complexity

Conditions	10
Paths	24

Size

Total Lines	32
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	10
eloc	20
nc	24
nop	2
dl	0
loc	32
rs	7.6666
c	0
b	0
f	0

How to fix Complexity

<?php
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\Manager;
use TYPO3\PharStreamWrapper\Phar\Reader;
use TYPO3\PharStreamWrapper\Resolvable;

class PharInvocationResolver implements Resolvable
{
    const RESOLVE_REALPATH = 1;
    const RESOLVE_ALIAS = 2;
    const ASSERT_INTERNAL_INVOCATION = 32;

    /**
     * @var string[]
     */
    private $invocationFunctionNames = array(
        'include',
        'include_once',
        'require',
        'require_once'
    );


    /**
     * Resolves PharInvocation value object (baseName and optional alias).
     *
     * 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 PharInvocationCollection 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.
     * @see https://secure.php.net/manual/en/phar.setalias.php
     * @see https://secure.php.net/manual/en/phar.mapphar.php
     *
     * @param string $path
     * @param int|null $flags
     * @return null|PharInvocation
     */
    public function resolve($path, $flags = null)
    {
        $hasPharPrefix = Helper::hasPharPrefix($path);
        if ($flags === null) {
            $flags = static::RESOLVE_REALPATH | static::RESOLVE_ALIAS | static::ASSERT_INTERNAL_INVOCATION;
        }

        if ($hasPharPrefix && $flags & static::RESOLVE_ALIAS) {
            $invocation = $this->findByAlias($path);
            if ($invocation !== null && $this->assertInternalInvocation($invocation, $flags)) {
                return $invocation;
            } elseif ($invocation !== null) {
                return null;
            }
        }

        $baseName = Helper::determineBaseFile($path);
        if ($baseName === null) {
            return null;
        }

        if ($flags & static::RESOLVE_REALPATH) {
            $baseName = realpath($baseName);
        }
        if ($flags & static::RESOLVE_ALIAS) {
            $reader = new Reader($baseName);
            $alias = $reader->resolveContainer()->getAlias();
        } else {
            $alias = '';
        }

        return new PharInvocation($baseName, $alias);
    }

    /**
     * @param string $path
     * @return null|PharInvocation
     */
    private function findByAlias($path)
    {
        $normalizedPath = Helper::normalizePath($path);
        $possibleAlias = strstr($normalizedPath, '/', true);
        if (empty($possibleAlias)) {
            return null;
        }
        return Manager::instance()->getCollection()->findByCallback(
            function (PharInvocation $candidate) use ($possibleAlias) {
                return $candidate->getAlias() === $possibleAlias;
            },
            true
        );
    }

    /**
     * @param PharInvocation $invocation
     * @param int $flags
     * @return bool
     * @experimental
     */
    private function assertInternalInvocation(PharInvocation $invocation, $flags)
    {
        if (!($flags & static::ASSERT_INTERNAL_INVOCATION)) {
            return true;
        }

        $trace = debug_backtrace(0);
        $firstIndex = count($trace) - 1;
        // initial invocation, most probably a CLI tool
        if (isset($trace[$firstIndex]['file']) && $trace[$firstIndex]['file'] === $invocation->getBaseName()) {
            return true;
        }
        // otherwise search for include/require invocations
        foreach ($trace as $item) {
            if (!isset($item['function']) || !isset($item['args'][0])) {
                continue;
            }
            if ($item['args'][0] === $invocation->getBaseName()
                && in_array($item['function'], $this->invocationFunctionNames, true)
            ) {
                return true;
            }
        }

        return false;
    }
}


1			<?php
2			namespace TYPO3\PharStreamWrapper\Resolver;
3
4			/*
5			* This file is part of the TYPO3 project.
6			*
7			* It is free software; you can redistribute it and/or modify it under the terms
8			* of the MIT License (MIT). For the full copyright and license information,
9			* please read the LICENSE file that was distributed with this source code.
10			*
11			* The TYPO3 project - inspiring people to share!
12			*/
13
14			use TYPO3\PharStreamWrapper\Helper;
15			use TYPO3\PharStreamWrapper\Manager;
16			use TYPO3\PharStreamWrapper\Phar\Reader;
17			use TYPO3\PharStreamWrapper\Resolvable;
18
19			class PharInvocationResolver implements Resolvable
20			{
21			const RESOLVE_REALPATH = 1;
22			const RESOLVE_ALIAS = 2;
23			const ASSERT_INTERNAL_INVOCATION = 32;
24
25			/**
26			* @var string[]
27			*/
28			private $invocationFunctionNames = array(
29			'include',
30			'include_once',
31			'require',
32			'require_once'
33			);
34
35
36			/**
37			* Resolves PharInvocation value object (baseName and optional alias).
38			*
39			* Phar aliases are intended to be used only inside Phar archives, however
40			* PharStreamWrapper needs this information exposed outside of Phar as well
41			* It is possible that same alias is used for different $baseName values.
42			* That's why PharInvocationCollection behaves like a stack when resolving
43			* base-name for a given alias. On the other hand it is not possible that
44			* one $baseName is referring to multiple aliases.
45			* @see https://secure.php.net/manual/en/phar.setalias.php
46			* @see https://secure.php.net/manual/en/phar.mapphar.php
47			*
48			* @param string $path
49			* @param int\|null $flags
50			* @return null\|PharInvocation
51			*/
52			public function resolve($path, $flags = null)
53			{
54			$hasPharPrefix = Helper::hasPharPrefix($path);
55			if ($flags === null) {
56			$flags = static::RESOLVE_REALPATH \| static::RESOLVE_ALIAS \| static::ASSERT_INTERNAL_INVOCATION;
57			}
58
59			if ($hasPharPrefix && $flags & static::RESOLVE_ALIAS) {
60			$invocation = $this->findByAlias($path);
61			if ($invocation !== null && $this->assertInternalInvocation($invocation, $flags)) {
62			return $invocation;
63			} elseif ($invocation !== null) {
64			return null;
65			}
66			}
67
68			$baseName = Helper::determineBaseFile($path);
69			if ($baseName === null) {
70			return null;
71			}
72
73			if ($flags & static::RESOLVE_REALPATH) {
74			$baseName = realpath($baseName);
75			}
76			if ($flags & static::RESOLVE_ALIAS) {
77			$reader = new Reader($baseName);
78			$alias = $reader->resolveContainer()->getAlias();
79			} else {
80			$alias = '';
81			}
82
83			return new PharInvocation($baseName, $alias);
84			}
85
86			/**
87			* @param string $path
88			* @return null\|PharInvocation
89			*/
90			private function findByAlias($path)
91			{
92			$normalizedPath = Helper::normalizePath($path);
93			$possibleAlias = strstr($normalizedPath, '/', true);
94			if (empty($possibleAlias)) {
95			return null;
96			}
97			return Manager::instance()->getCollection()->findByCallback(
98			function (PharInvocation $candidate) use ($possibleAlias) {
99			return $candidate->getAlias() === $possibleAlias;
100			},
101			true
102			);
103			}
104
105			/**
106			* @param PharInvocation $invocation
107			* @param int $flags
108			* @return bool
109			* @experimental
110			*/
111			private function assertInternalInvocation(PharInvocation $invocation, $flags)
112			{
113			if (!($flags & static::ASSERT_INTERNAL_INVOCATION)) {
114			return true;
115			}
116
117			$trace = debug_backtrace(0);
118			$firstIndex = count($trace) - 1;
119			// initial invocation, most probably a CLI tool
120			if (isset($trace[$firstIndex]['file']) && $trace[$firstIndex]['file'] === $invocation->getBaseName()) {
121			return true;
122			}
123			// otherwise search for include/require invocations
124			foreach ($trace as $item) {
125			if (!isset($item['function']) \|\| !isset($item['args'][0])) {
126			continue;
127			}
128			if ($item['args'][0] === $invocation->getBaseName()
129			&& in_array($item['function'], $this->invocationFunctionNames, true)
130			) {
131			return true;
132			}
133			}
134
135			return false;
136			}
137			}
138

GitHub Access Token became invalid

Branch — v2 (b7a21f)

PharInvocationResolver::resolve() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

TYPO3 / phar-stream-wrapper

GitHub Access Token became invalid

Branch — v2 (b7a21f)

PharInvocationResolver::resolve() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like