MagentoHackathon\Service\ScanForPhpExtensions

Complexity

Total Complexity

12

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getRegisteredPhpExtensions()	0	14	3
A	getTokensByClassesPathList()	0	9	2
A	__construct()	0	13	2
A	execute()	0	25	5

<?php

namespace MagentoHackathon\Service;

use MagentoHackathon\Api\TokenizerInterface;
use MagentoHackathon\StringTokenizer;

class ScanForPhpExtensions
{
    const EXT = 'ext-';

    /**
     * @var array|null
     */
    private $phpCheckExtensions;

    /**
     * @var arrayfl

The doc comment arrayfl at position 0 could not be parsed: Unknown type name 'arrayfl' at position 0 in arrayfl.

     */
    private $registeredExtensions;
    /**
     * @var StringTokenizer
     */
    private $tokenizer;

    /**
     * ScanForPhpExtensions constructor.
     * @param TokenizerInterface $tokenizer
     * @param array $registeredPhpExtensions
     * @param null $phpCheckExtensions

Are you sure the doc-type for parameter $phpCheckExtensions is correct as it would always require null to be passed?

     */
    public function __construct(
        TokenizerInterface $tokenizer,
        $registeredExtensions = [],
        $phpCheckExtensions = null
    ) {
        $this->tokenizer = $tokenizer;

$tokenizer is of type MagentoHackathon\Api\TokenizerInterface, but the property $tokenizer was declared to be of type MagentoHackathon\StringTokenizer. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->registeredExtensions = $registeredExtensions;

        if ($phpCheckExtensions === null) {

The condition $phpCheckExtensions === null is always true.

            $phpCheckExtensions = ['json', 'xml', 'pcre', 'gd', 'bcmath'];
        }

        $this->phpCheckExtensions = $phpCheckExtensions;
    }

    /**
     * @param array $classesPathList
     * @return array
     */
    public function execute(array $classesPathList): array
    {
        $results = [];
        $tokens = $this->getTokensByClassesPathList($classesPathList);
        $registeredPhpExtensions = $this->getRegisteredPhpExtensions();

        foreach ($this->phpCheckExtensions as $phpExtension) {
            if (array_key_exists($phpExtension, $registeredPhpExtensions)) {
                continue;
            }

            foreach (get_extension_funcs($phpExtension) as $phpExtensionFunction) {
                if (!in_array($phpExtensionFunction, $tokens, false)) {
                    continue;
                }

                $results[] = sprintf(
                    'Function "%s" requires PHP extension "ext-%s"',
                    $phpExtensionFunction,
                    $phpExtension
                );
            }
        }

        return $results;
    }

    /**
     * @param array $classesPathList
     * @return array
     */
    private function getTokensByClassesPathList(array $classesPathList): array
    {
        $stringTokens = [[]];

        foreach ($classesPathList as $classPath) {
            $stringTokens[] = $this->tokenizer->execute($classPath);
        }

        return array_unique(array_merge(...$stringTokens));
    }

    /**
     * @return array
     */
    private function getRegisteredPhpExtensions(): array
    {
        $registeredPhpExtensions = [];

        foreach ($this->registeredExtensions as $registeredExtension => $value) {
            if (strpos(substr($registeredExtension, 0, 4), self::EXT) === false) {
                continue;
            }

            $registeredExtension = str_replace(self::EXT, '', $registeredExtension);
            $registeredPhpExtensions[$registeredExtension] = '';
        }

        return $registeredPhpExtensions;
    }
}