Puli\Manager\Cache\CacheManagerImpl

Complexity

Total Complexity

26

Size/Duplication

Total Lines	221
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	14

Test Coverage

Coverage

98.84%

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getContext()	0	4	1
A	getCacheFile()	0	13	2
B	refreshCacheFile()	0	25	5
A	getModule()	0	9	1
A	getRootModule()	0	7	1
A	getModules()	0	12	2
A	findModules()	0	15	3
A	hasModule()	0	8	1
A	hasModules()	0	16	4
A	getInstalledModules()	0	6	1
A	buildModule()	0	7	1
A	isRootModuleFileModified()	0	23	3

<?php

/*
 * This file is part of the puli/manager Module.
 *
 * (c) Bernhard Schussek <bschussek@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Puli\Manager\Cache;

use Puli\Manager\Api\Cache\CacheFile;
use Puli\Manager\Api\Cache\CacheManager;
use Puli\Manager\Api\Config\Config;
use Puli\Manager\Api\Context\ProjectContext;
use Puli\Manager\Api\Module\Module;
use Puli\Manager\Api\Module\ModuleFile;
use Puli\Manager\Api\Module\ModuleList;
use Puli\Manager\Api\Module\ModuleManager;
use Puli\Manager\Api\Module\RootModule;
use Puli\Manager\Assert\Assert;
use Puli\Manager\Json\JsonStorage;
use Webmozart\Expression\Expr;
use Webmozart\Expression\Expression;
use Webmozart\PathUtil\Path;

/**
 * Manages cached Modules information.
 *
 * @since  1.0
 *
 * @author Mateusz Sojda <mateusz@sojda.pl>
 */
class CacheManagerImpl implements CacheManager
{
    /**
     * @var ModuleManager
     */
    private $moduleManager;

    /**
     * @var JsonStorage
     */
    private $storage;

    /**
     * @var ProjectContext
     */
    private $context;

    /**
     * @var string
     */
    private $rootDir;

    /**
     * Creates new cache manager.
     *
     * @param ModuleManager  $moduleManager The Module manager
     * @param JsonStorage    $storage       The file storage
     * @param ProjectContext $context       Project context
     */
    public function __construct(ModuleManager $moduleManager, JsonStorage $storage, ProjectContext $context)
    {
        $this->moduleManager = $moduleManager;
        $this->storage = $storage;
        $this->context = $context;
        $this->rootDir = $context->getRootDirectory();
    }

    /**
     * {@inheritdoc}
     */
    public function getContext()
    {
        return $this->context;
    }

    /**
     * {@inheritdoc}
     */
    public function getCacheFile()
    {
        $path = $this->getContext()->getConfig()->get(Config::CACHE_FILE);
        $path = Path::makeAbsolute($path, $this->rootDir);

        if (false == $this->storage->fileExists($path)) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            $this->refreshCacheFile();
        }

        $cacheFile = $this->storage->loadCacheFile($path);

        return $cacheFile;
    }

    /**
     * {@inheritdoc}
     */
    public function refreshCacheFile()
    {
        $path = $this->getContext()->getConfig()->get(Config::CACHE_FILE);
        $path = Path::makeAbsolute($path, $this->rootDir);

        if ($this->storage->fileExists($path) && false === $this->isRootModuleFileModified()) {
            return;
        }

        $cacheFile = new CacheFile(Path::makeAbsolute($path, $this->rootDir));

        foreach ($this->getInstalledModules() as $module) {
            $moduleFile = $module->getModuleFile();
            if (false === $moduleFile instanceof ModuleFile) {
                continue;
            }

            $cacheFile->addModuleFile($moduleFile);

            $installInfo = $module->getInstallInfo();
            $cacheFile->addInstallInfo($installInfo);
        }

        $this->storage->saveCacheFile($cacheFile);
    }

    /**
     * {@inheritdoc}
     */
    public function getModule($name)
    {
        Assert::string($name, 'The Module name must be a string. Got: %s');

        $cacheFile = $this->getCacheFile();
        $moduleFile = $cacheFile->getModuleFile($name);

        return $this->buildModule($moduleFile, $cacheFile);
    }

    /**
     * {@inheritdoc}
     */
    public function getRootModule()
    {
        return new RootModule(
            $this->getContext()->getRootModuleFile(),
            $this->rootDir
        );
    }

    /**
     * {@inheritdoc}
     */
    public function getModules()
    {
        $cacheFile = $this->getCacheFile();
        $modules = new ModuleList();

        foreach ($cacheFile->getModuleFiles() as $moduleFile) {
            $module = $this->buildModule($moduleFile, $cacheFile);
            $modules->add($module);
        }

        return $modules;
    }

    /**
     * {@inheritdoc}
     */
    public function findModules(Expression $expr)
    {
        $cacheFile = $this->getCacheFile();
        $modules = new ModuleList();

        foreach ($cacheFile->getModuleFiles() as $moduleFile) {
            $module = $this->buildModule($moduleFile, $cacheFile);

            if ($expr->evaluate($module)) {
                $modules->add($module);
            }
        }

        return $modules;
    }

    /**
     * {@inheritdoc}
     */
    public function hasModule($name)
    {
        Assert::string($name, 'The Module name must be a string. Got: %s');

        $cacheFile = $this->getCacheFile();

        return $cacheFile->hasModuleFile($name);
    }

    /**
     * {@inheritdoc}
     */
    public function hasModules(Expression $expr = null)
    {
        $cacheFile = $this->getCacheFile();

        if (!$expr) {
            return $cacheFile->hasModuleFiles();
        }

        foreach ($this->getModules() as $module) {
            if ($expr->evaluate($module)) {
                return true;
            }
        }

        return false;
    }

    private function getInstalledModules()

The return type could not be reliably inferred; please add a @return annotation.

    {
        $modules = $this->moduleManager->findModules(Expr::true());

        return $modules->getInstalledModules();
    }

    private function buildModule(ModuleFile $moduleFile, CacheFile $cacheFile)
    {
        $installInfo = $cacheFile->getInstallInfo($moduleFile->getModuleName());
        $installPath = Path::makeAbsolute($installInfo->getInstallPath(), $this->rootDir);

        return new Module($moduleFile, $installPath, $installInfo);
    }

    private function isRootModuleFileModified()
    {
        $cacheFilePath = $this->getContext()->getConfig()->get(Config::CACHE_FILE);
        $cacheFilePath = Path::makeAbsolute($cacheFilePath, $this->rootDir);

        clearstatcache(true, $cacheFilePath);
        $cacheFileMtime = filemtime($cacheFilePath);

        $rootModuleFilePath = $this->getRootModule()->getModuleFile()->getPath();

        if (false === $this->storage->fileExists($rootModuleFilePath)) {
            return true;
        }

        clearstatcache(true, $rootModuleFilePath);
        $rootModuleFileMtime = filemtime($rootModuleFilePath);

        if ($rootModuleFileMtime > $cacheFileMtime) {

This if statement, and the following return statement can be replaced with return $rootModuleFileMtime > $cacheFileMtime;.

            return true;
        }

        return false;
    }
}