SilverStripe\Core\Manifest\VersionProvider

Complexity

Total Complexity

16

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getModules()	0	4	2
A	getModuleVersionFromComposer()	0	12	6
A	getVersion()	0	12	3
A	getComposerLock()	0	28	5

<?php

namespace SilverStripe\Core\Manifest;

use SilverStripe\Core\Config\Config;
use Psr\SimpleCache\CacheInterface;
use SilverStripe\Core\Convert;
use SilverStripe\Core\Injector\Injector;

/**
 * The version provider will look up configured modules and examine the composer.lock file
 * to find the current version installed for each. This is used for the logo title in the CMS
 * via {@link LeftAndMain::CMSVersion()}
 *
 * Example configuration:
 *
 * <code>
 * SilverStripe\Core\Manifest\VersionProvider:
 *   modules:
 *     # package/name: Package Title
 *     silverstripe/framework: Framework
 *     silverstripe/cms: CMS
 * </code>
 */
class VersionProvider
{
    /**
     * Gets a comma delimited string of package titles and versions
     *
     * @return string
     */
    public function getVersion()
    {
        $modules = $this->getModules();
        $lockModules = $this->getModuleVersionFromComposer(array_keys($modules));
        $output = [];
        foreach ($modules as $module => $title) {
            $version = isset($lockModules[$module])
                ? $lockModules[$module]
                : _t(__CLASS__ . '.VERSIONUNKNOWN', 'Unknown');
            $output[] = $title . ': ' . $version;
        }
        return implode(', ', $output);
    }

    /**
     * Gets the configured core modules to use for the SilverStripe application version. Filtering
     * is used to ensure that modules can turn the result off for other modules, e.g. CMS can disable Framework.
     *
     * @return array
     */
    public function getModules()
    {
        $modules = Config::inst()->get(self::class, 'modules');
        return $modules ? array_filter($modules) : [];
    }

    /**
     * Tries to obtain version number from composer.lock if it exists
     *
     * @param  array $modules
     * @return array
     */
    public function getModuleVersionFromComposer($modules = [])
    {
        $versions = [];
        $lockData = $this->getComposerLock();
        if ($lockData && !empty($lockData['packages'])) {

The expression $lockData of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($lockData['packages'] as $package) {
                if (in_array($package['name'], $modules) && isset($package['version'])) {
                    $versions[$package['name']] = $package['version'];
                }
            }
        }
        return $versions;
    }

    /**
     * Load composer.lock's contents and return it
     *
     * @param  bool $cache
     * @return array
     */
    protected function getComposerLock($cache = true)
    {
        $composerLockPath = BASE_PATH . '/composer.lock';
        if (!file_exists($composerLockPath)) {
            return [];
        }

        $jsonData = file_get_contents($composerLockPath);

        //  TODO: The benefit of this cache isn't clear
        if ($cache) {
            $cache = Injector::inst()->get(CacheInterface::class . '.VersionProvider_composerlock');
            $cacheKey = md5($jsonData);

            if ($versions = $cache->get($cacheKey)) {
                $lockData = json_decode($versions, true);

The assignment to $lockData is dead and can be removed.

            }

            $lockData = json_decode($jsonData, true);

            $cache->set($cacheKey, $jsonData);
        } elseif ($jsonData) {
            $lockData = json_decode($jsonData, true);
        } else {
            $lockData = [];
        }

        return $lockData;
    }
}