CacheManagerImpl::getContext() - Code Metrics - Inspection of "[WIP] Cache combined puli.json files of all instal..." - puli/manager - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#47)

by Mateusz

created 2016-01-25 23:06 UTC

CacheManagerImpl::getContext() A

↳ Parent: CacheManagerImpl

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
ccs	0
cts	4
cp	0
rs	10
cc	1
eloc	2
nc	1
nop	0
crap	2

<?php

/*
 * This file is part of the puli/manager package.
 *
 * (c) Bernhard Schussek <[email protected]>
 *
 * 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\Package\Package;
use Puli\Manager\Api\Package\PackageCollection;
use Puli\Manager\Api\Package\PackageFile;
use Puli\Manager\Api\Package\PackageManager;
use Puli\Manager\Api\Package\RootPackage;
use Puli\Manager\Assert\Assert;
use Webmozart\Expression\Expr;
use Webmozart\Expression\Expression;
use Webmozart\PathUtil\Path;

/**
 * Manages cached packages information.
 *
 * @since  1.0
 *
 * @author Mateusz Sojda <[email protected]>
 */
class CacheManagerImpl implements CacheManager
{
    /**
     * @var PackageManager
     */
    private $packageManager;

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

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

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

    /**
     * Creates new cache manager.
     *
     * @param PackageManager    $packageManager  The package manager.
     * @param CacheFileStorage  $storage         The file storage.
     * @param ProjectContext    $context         Project context.
     */
    public function __construct(PackageManager $packageManager, CacheFileStorage $storage, ProjectContext $context)
    {
        $this->packageManager = $packageManager;
        $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->cacheFileExists($path)) {
            $this->refreshCacheFile();
        }

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

        return $cacheFile;
    }

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

        if ($this->storage->cacheFileExists($path) || false === $this->checkPackageFilesModified()) {
            return;
        }

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

        foreach ($this->getInstalledPackages() as $package) {
            $packageFile = $package->getPackageFile();
            if (false === $packageFile instanceof PackageFile) {
                continue;
            }

            $cacheFile->addPackageFile($packageFile);

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

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

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

        $cacheFile = $this->getCacheFile();
        $packageFile = $cacheFile->getPackageFile($name);

        return $this->buildPackage($packageFile, $cacheFile);
    }

    /**
     * {@inheritdoc}
     */
    public function getRootPackage()
    {
        return new RootPackage(
            $this->getContext()->getRootPackageFile(),
            $this->rootDir
        );
    }

    /**
     * {@inheritdoc}
     */
    public function getPackages()
    {
        $cacheFile = $this->getCacheFile();
        $packages = new PackageCollection();

        foreach ($cacheFile->getPackageFiles() as $packageFile) {
            $package = $this->buildPackage($packageFile, $cacheFile);
            $packages->add($package);
        }

        return $packages;
    }

    /**
     * {@inheritdoc}
     */
    public function findPackages(Expression $expr)
    {
        $cacheFile = $this->getCacheFile();
        $packages = new PackageCollection();

        foreach ($cacheFile->getPackageFiles() as $packageFile) {
            $package = $this->buildPackage($packageFile, $cacheFile);

            if ($expr->evaluate($package)) {
                $packages->add($package);
            }
        }

        return $packages;
    }

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

        $cacheFile = $this->getCacheFile();

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

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

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

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

        return false;
    }

    private function getInstalledPackages()
    {
        $packages = $this->packageManager->findPackages(Expr::true());

        return $packages->getInstalledPackages();
    }

    private function buildPackage(PackageFile $packageFile, CacheFile $cacheFile)
    {
        $installInfo = $cacheFile->getInstallInfo($packageFile->getPackageName());
        $installPath = Path::makeAbsolute($installInfo->getInstallPath(), $this->rootDir);

        return new Package($packageFile, $installPath, $installInfo);
    }

    private function checkPackageFilesModified()
    {
        $cacheFile = $this->getCacheFile();
        $cacheFileMtime = filemtime($cacheFile->getPath());

        foreach ($cacheFile->getInstallInfos() as $installInfo) {
            $packageFilePath = Path::makeAbsolute("{$installInfo->getInstallPath()}/puli.json", $this->rootDir);
// Instead of
$x = "foo $bar $baz";

// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);

            if (filemtime($packageFilePath) > $cacheFileMtime) {
                return true;
            }
        }

        return false;
    }
}

1			<?php
2
3			/*
4			* This file is part of the puli/manager package.
5			*
6			* (c) Bernhard Schussek <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Puli\Manager\Cache;
13
14			use Puli\Manager\Api\Cache\CacheFile;
15			use Puli\Manager\Api\Cache\CacheManager;
16			use Puli\Manager\Api\Config\Config;
17			use Puli\Manager\Api\Context\ProjectContext;
18			use Puli\Manager\Api\Package\Package;
19			use Puli\Manager\Api\Package\PackageCollection;
20			use Puli\Manager\Api\Package\PackageFile;
21			use Puli\Manager\Api\Package\PackageManager;
22			use Puli\Manager\Api\Package\RootPackage;
23			use Puli\Manager\Assert\Assert;
24			use Webmozart\Expression\Expr;
25			use Webmozart\Expression\Expression;
26			use Webmozart\PathUtil\Path;
27
28			/**
29			* Manages cached packages information.
30			*
31			* @since 1.0
32			*
33			* @author Mateusz Sojda <[email protected]>
34			*/
35			class CacheManagerImpl implements CacheManager
36			{
37			/**
38			* @var PackageManager
39			*/
40			private $packageManager;
41
42			/**
43			* @var CacheFileStorage
44			*/
45			private $storage;
46
47			/**
48			* @var ProjectContext
49			*/
50			private $context;
51
52			/**
53			* @var string
54			*/
55			private $rootDir;
56
57			/**
58			* Creates new cache manager.
59			*
60			* @param PackageManager $packageManager The package manager.
61			* @param CacheFileStorage $storage The file storage.
62			* @param ProjectContext $context Project context.
63			*/
64			public function __construct(PackageManager $packageManager, CacheFileStorage $storage, ProjectContext $context)
65			{
66			$this->packageManager = $packageManager;
67			$this->storage = $storage;
68			$this->context = $context;
69			$this->rootDir = $context->getRootDirectory();
70			}
71
72			/**
73			* {@inheritdoc}
74			*/
75			public function getContext()
76			{
77			return $this->context;
78			}
79
80			/**
81			* {@inheritdoc}
82			*/
83			public function getCacheFile()
84			{
85			$path = $this->getContext()->getConfig()->get(Config::CACHE_FILE);
86			$path = Path::makeAbsolute($path, $this->rootDir);
87
88			if (false === $this->storage->cacheFileExists($path)) {
89			$this->refreshCacheFile();
90			}
91
92			$cacheFile = $this->storage->loadCacheFile($path);
93
94			return $cacheFile;
95			}
96
97			/**
98			* {@inheritdoc}
99			*/
100			public function refreshCacheFile()
101			{
102			$path = $this->getContext()->getConfig()->get(Config::CACHE_FILE);
103
104			if ($this->storage->cacheFileExists($path) \|\| false === $this->checkPackageFilesModified()) {
105			return;
106			}
107
108			$cacheFile = new CacheFile(Path::makeAbsolute($path, $this->rootDir));
109
110			foreach ($this->getInstalledPackages() as $package) {
111			$packageFile = $package->getPackageFile();
112			if (false === $packageFile instanceof PackageFile) {
113			continue;
114			}
115
116			$cacheFile->addPackageFile($packageFile);
117
118			$installInfo = $package->getInstallInfo();
119			$cacheFile->addInstallInfo($installInfo);
120			}
121
122			$this->storage->saveCacheFile($cacheFile);
123			}
124
125			/**
126			* {@inheritdoc}
127			*/
128			public function getPackage($name)
129			{
130			Assert::string($name, 'The package name must be a string. Got: %s');
131
132			$cacheFile = $this->getCacheFile();
133			$packageFile = $cacheFile->getPackageFile($name);
134
135			return $this->buildPackage($packageFile, $cacheFile);
136			}
137
138			/**
139			* {@inheritdoc}
140			*/
141			public function getRootPackage()
142			{
143			return new RootPackage(
144			$this->getContext()->getRootPackageFile(),
145			$this->rootDir
146			);
147			}
148
149			/**
150			* {@inheritdoc}
151			*/
152			public function getPackages()
153			{
154			$cacheFile = $this->getCacheFile();
155			$packages = new PackageCollection();
156
157			foreach ($cacheFile->getPackageFiles() as $packageFile) {
158			$package = $this->buildPackage($packageFile, $cacheFile);
159			$packages->add($package);
160			}
161
162			return $packages;
163			}
164
165			/**
166			* {@inheritdoc}
167			*/
168			public function findPackages(Expression $expr)
169			{
170			$cacheFile = $this->getCacheFile();
171			$packages = new PackageCollection();
172
173			foreach ($cacheFile->getPackageFiles() as $packageFile) {
174			$package = $this->buildPackage($packageFile, $cacheFile);
175
176			if ($expr->evaluate($package)) {
177			$packages->add($package);
178			}
179			}
180
181			return $packages;
182			}
183
184			/**
185			* {@inheritdoc}
186			*/
187			public function hasPackage($name)
188			{
189			Assert::string($name, 'The package name must be a string. Got: %s');
190
191			$cacheFile = $this->getCacheFile();
192
193			return $cacheFile->hasPackageFile($name);
194			}
195
196			/**
197			* {@inheritdoc}
198			*/
199			public function hasPackages(Expression $expr = null)
200			{
201			$cacheFile = $this->getCacheFile();
202
203			if (!$expr) {
204			return $cacheFile->hasPackageFiles();
205			}
206
207			foreach ($this->getPackages() as $package) {
208			if ($expr->evaluate($package)) {
209			return true;
210			}
211			}
212
213			return false;
214			}
215
216			private function getInstalledPackages()
217			{
218			$packages = $this->packageManager->findPackages(Expr::true());
219
220			return $packages->getInstalledPackages();
221			}
222
223			private function buildPackage(PackageFile $packageFile, CacheFile $cacheFile)
224			{
225			$installInfo = $cacheFile->getInstallInfo($packageFile->getPackageName());
226			$installPath = Path::makeAbsolute($installInfo->getInstallPath(), $this->rootDir);
227
228			return new Package($packageFile, $installPath, $installInfo);
229			}
230
231			private function checkPackageFilesModified()
232			{
233			$cacheFile = $this->getCacheFile();
234			$cacheFileMtime = filemtime($cacheFile->getPath());
235
236			foreach ($cacheFile->getInstallInfos() as $installInfo) {
237			$packageFilePath = Path::makeAbsolute("{$installInfo->getInstallPath()}/puli.json", $this->rootDir);
			0 ignored issues – show Coding Style Best Practice introduced 2016-01-25 23:30 UTC by Report Bug Copy Issue Report As per coding-style, please use concatenation or `sprintf` for the variable `$installInfo` instead of interpolation. It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of $x = "foo $bar $baz"; // Better use either $x = "foo " . $bar . " " . $baz; $x = sprintf("foo %s %s", $bar, $baz); Loading history...
238
239			if (filemtime($packageFilePath) > $cacheFileMtime) {
240			return true;
241			}
242			}
243
244			return false;
245			}
246			}

puli / manager

Pull Request — master (#47)

CacheManagerImpl::getContext() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like