9.5/_abstract_core_matcher_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */


use PhpParser\Node;

use PhpParser\Node\Stmt\Class_;

use PhpParser\NodeVisitorAbstract;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Install\ExtensionScanner\CodeScannerInterface;


abstract class ‪AbstractCoreMatcher extends NodeVisitorAbstract implements ‪CodeScannerInterface

{

    public const ‪NODE_RESOLVED_AS = 'nodeResolvedAs';


    protected ‪$matcherDefinitions = [];


    protected ‪$matches = [];


    protected ‪$flatMatcherDefinitions = [];


    protected ‪$currentCodeLine = 0;


    protected ‪$isCurrentLineIgnored = false;


    protected ‪$isFullFileIgnored = false;


    public function ‪getMatches(): array

    {

        return ‪$this->matches;

    }


    protected function ‪validateMatcherDefinitions(array $requiredArrayKeys = [])

    {

        foreach ($this->matcherDefinitions as $key => $matcherDefinition) {

            $this->‪validateMatcherDefinitionKeys($key, $matcherDefinition, $requiredArrayKeys);

        }

    }


    protected function ‪validateMatcherDefinitionKeys(string $key, array $matcherDefinition, array $requiredArrayKeys = []): void

    {

        // Each config must point to at least one .rst file

        if (empty($matcherDefinition['restFiles'])) {

            throw new \InvalidArgumentException(

                'Each configuration must have at least one referenced "restFiles" entry. Offending key: ' . $key,

                1500496068

            );

        }

        foreach ($matcherDefinition['restFiles'] as $file) {

            if (empty($file)) {

                throw new \InvalidArgumentException(

                    'Empty restFiles definition',

                    1500735983

                );

            }

        }

        // Config broken if not all required array keys are specified in config

        $sharedArrays = array_intersect(array_keys($matcherDefinition), $requiredArrayKeys);

        if (count($sharedArrays) !== count($requiredArrayKeys)) {

            $missingKeys = array_diff($requiredArrayKeys, array_keys($matcherDefinition));

            throw new \InvalidArgumentException(

                'Required matcher definitions missing: ' . implode(', ', $missingKeys) . ' offending key: ' . $key,

                1500492001

            );

        }

    }


    protected function ‪initializeFlatMatcherDefinitions()

    {

        $methodNameArray = [];

        foreach ($this->matcherDefinitions as $classAndMethod => $details) {

            $method = GeneralUtility::trimExplode('::', $classAndMethod);

            if (count($method) !== 2) {

                $method = GeneralUtility::trimExplode('->', $classAndMethod);

            }

            if (count($method) !== 2) {

                throw new \RuntimeException(

                    'Keys in $this->matcherDefinitions must have a Class\Name->method or Class\Name::method structure',

                    1500557309

                );

            }

            $method = $method[1];

            if (!array_key_exists($method, $methodNameArray)) {

                $methodNameArray[$method]['candidates'] = [];

            }

            $methodNameArray[$method]['candidates'][] = $details;

        }

        $this->flatMatcherDefinitions = $methodNameArray;

    }


    protected function ‪isArgumentUnpackingUsed(array $arguments = []): bool

    {

        foreach ($arguments as $arg) {

            if ($arg->unpack === true) {

                return true;

            }

        }

        return false;

    }


    protected function ‪isLineIgnored(Node $node): bool

    {

        // Early return if this line is marked as ignored

        $startLineOfNode = $node->getAttribute('startLine');

        if ($startLineOfNode === $this->currentCodeLine) {

            return ‪$this->isCurrentLineIgnored;

        }


        $currentLineIsIgnored = false;

        if ($startLineOfNode !== $this->currentCodeLine) {

            $this->currentCodeLine = $startLineOfNode;

            // First node of a new line may contain the annotation

            $comments = $node->getAttribute('comments');

            if (!empty($comments)) {

                foreach ($comments as $comment) {

                    if (strstr($comment->getText(), '@extensionScannerIgnoreLine') !== false) {

                        $this->isCurrentLineIgnored = true;

                        $currentLineIsIgnored = true;

                        break;

                    }

                }

            }

        }

        return $currentLineIsIgnored;

    }


    protected function ‪isFileIgnored(Node $node): bool

    {

        if ($this->isFullFileIgnored) {

            return true;

        }

        $currentFileIsIgnored = false;

        if ($node instanceof Class_) {

            $comments = $node->getAttribute('comments');

            if (!empty($comments)) {

                foreach ($comments as $comment) {

                    if (strstr($comment->getText(), '@extensionScannerIgnoreFile') !== false) {

                        $this->isFullFileIgnored = true;

                        $currentFileIsIgnored = true;

                        break;

                    }

                }

            }

        }

        return $currentFileIsIgnored;

    }

}