RepositoryManagerImpl - Code Metrics - Inspection of "Merge pull request #39 from webmozart/fix-empty-pa..." - puli/manager - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fa0673...7f3713 )

by Bernhard

created 2016-01-04 12:29 UTC

RepositoryManagerImpl F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	513
Duplicated Lines	20.27 %

Coupling/Cohesion

Components	1
Dependencies	28

Test Coverage

Coverage

100%

Importance

Changes	15
Bugs	1	Features	7

Metric	Value
wmc	65
c	15
b	1
f	7
lcom	1
cbo	28
dl	104
loc	513
ccs	216
cts	216
cp	1
rs	1.3043

33 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	getContext()	0	4	1
A	getRepository()	0	4	1
B	addRootPathMapping()	0	37	5
B	removeRootPathMapping()	0	32	3
B	removeRootPathMappings()	29	29	4
A	clearRootPathMappings()	0	4	1
A	getRootPathMapping()	0	4	1
A	findRootPathMappings()	7	7	1
A	getRootPathMappings()	15	15	3
A	hasRootPathMapping()	0	4	1
A	hasRootPathMappings()	10	10	2
A	getPathMapping()	0	13	2
A	getPathMappings()	0	14	3
A	findPathMappings()	16	16	4
A	hasPathMapping()	0	9	1
B	hasPathMappings()	18	18	5
A	getPathConflicts()	0	6	1
A	buildRepository()	0	20	4
A	clearRepository()	0	4	1
B	loadPathMappings()	9	22	4
A	addPathMappingToPackageFile()	0	4	1
A	removePathMappingFromPackageFile()	0	4	1
A	loadPathMapping()	0	4	1
A	unloadPathMapping()	0	4	1
A	syncRepositoryPath()	0	4	1
A	populateRepository()	0	4	1
A	updateConflicts()	0	4	1
A	overrideConflictingPackages()	0	4	1
A	saveRootPackageFile()	0	4	1
A	removeResolvedConflicts()	0	8	3
A	assertMappingsLoaded()	0	6	2
A	assertNoLoadErrors()	0	9	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like RepositoryManagerImpl often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use RepositoryManagerImpl, and based on these observations, apply Extract Interface, too.

<?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\Repository;

use Exception;
use Puli\Manager\Api\Config\Config;
use Puli\Manager\Api\Context\ProjectContext;
use Puli\Manager\Api\Event\BuildRepositoryEvent;
use Puli\Manager\Api\Event\PuliEvents;
use Puli\Manager\Api\Package\Package;
use Puli\Manager\Api\Package\PackageCollection;
use Puli\Manager\Api\Package\RootPackage;
use Puli\Manager\Api\Package\RootPackageFile;
use Puli\Manager\Api\Repository\DuplicatePathMappingException;
use Puli\Manager\Api\Repository\NoSuchPathMappingException;
use Puli\Manager\Api\Repository\PathMapping;
use Puli\Manager\Api\Repository\RepositoryManager;
use Puli\Manager\Assert\Assert;
use Puli\Manager\Conflict\OverrideGraph;
use Puli\Manager\Conflict\PackageConflictDetector;
use Puli\Manager\Package\PackageFileStorage;
use Puli\Manager\Repository\Mapping\AddPathMappingToPackageFile;
use Puli\Manager\Repository\Mapping\ConflictCollection;
use Puli\Manager\Repository\Mapping\LoadPathMapping;
use Puli\Manager\Repository\Mapping\OverrideConflictingPackages;
use Puli\Manager\Repository\Mapping\PathMappingCollection;
use Puli\Manager\Repository\Mapping\PopulateRepository;
use Puli\Manager\Repository\Mapping\RemovePathMappingFromPackageFile;
use Puli\Manager\Repository\Mapping\SyncRepositoryPath;
use Puli\Manager\Repository\Mapping\UnloadPathMapping;
use Puli\Manager\Repository\Mapping\UpdateConflicts;
use Puli\Manager\Transaction\Transaction;
use Puli\Repository\Api\EditableRepository;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Webmozart\Expression\Expr;
use Webmozart\Expression\Expression;

/**
 * Manages the resource repository of a Puli project.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <[email protected]>
 */
class RepositoryManagerImpl implements RepositoryManager
{
    /**
     * @var ProjectContext
     */
    private $context;

    /**
     * @var EventDispatcherInterface
     */
    private $dispatcher;

    /**
     * @var Config
     */
    private $config;

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

    /**
     * @var RootPackage
     */
    private $rootPackage;

    /**
     * @var RootPackageFile
     */
    private $rootPackageFile;

    /**
     * @var EditableRepository
     */
    private $repo;

    /**
     * @var PackageCollection
     */
    private $packages;

    /**
     * @var PackageFileStorage
     */
    private $packageFileStorage;

    /**
     * @var OverrideGraph
     */
    private $overrideGraph;

    /**
     * @var PackageConflictDetector
     */
    private $conflictDetector;

    /**
     * @var PathMappingCollection
     */
    private $mappings;

    /**
     * @var PathMappingCollection
     */
    private $mappingsByResource;

    /**
     * @var ConflictCollection
     */
    private $conflicts;

    /**
     * Creates a repository manager.
     *
     * @param ProjectContext     $context
     * @param EditableRepository $repo
     * @param PackageCollection  $packages
     * @param PackageFileStorage $packageFileStorage
     */
    public function __construct(ProjectContext $context, EditableRepository $repo, PackageCollection $packages, PackageFileStorage $packageFileStorage)
    {
        $this->context = $context;
        $this->dispatcher = $context->getEventDispatcher();
        $this->repo = $repo;
        $this->config = $context->getConfig();
        $this->rootDir = $context->getRootDirectory();
        $this->rootPackage = $packages->getRootPackage();
        $this->rootPackageFile = $context->getRootPackageFile();
        $this->packages = $packages;
        $this->packageFileStorage = $packageFileStorage;
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function addRootPathMapping(PathMapping $mapping, $flags = 0)
    {
        Assert::integer($flags, 'The argument $flags must be a boolean.');

        $this->assertMappingsLoaded();

        if (!($flags & self::OVERRIDE) && $this->rootPackageFile->hasPathMapping($mapping->getRepositoryPath())) {
            throw DuplicatePathMappingException::forRepositoryPath($mapping->getRepositoryPath(), $this->rootPackage->getName());
        }

        $tx = new Transaction();

        try {
            $syncOp = $this->syncRepositoryPath($mapping->getRepositoryPath());
            $syncOp->takeSnapshot();

            $tx->execute($this->loadPathMapping($mapping, $this->rootPackage));

            if (!($flags & self::IGNORE_FILE_NOT_FOUND)) {
                $this->assertNoLoadErrors($mapping);
            }

            $tx->execute($this->updateConflicts($mapping->listRepositoryPaths()));
            $tx->execute($this->overrideConflictingPackages($mapping));
            $tx->execute($this->updateConflicts());
            $tx->execute($this->addPathMappingToPackageFile($mapping));
            $tx->execute($syncOp);

            $this->saveRootPackageFile();

            $tx->commit();
        } catch (Exception $e) {
            $tx->rollback();

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeRootPathMapping($repositoryPath)
    {
        Assert::path($repositoryPath);

        $this->assertMappingsLoaded();

        if (!$this->mappings->contains($repositoryPath, $this->rootPackage->getName())) {
            return;
        }

        $mapping = $this->mappings->get($repositoryPath, $this->rootPackage->getName());
        $tx = new Transaction();

        try {
            $syncOp = $this->syncRepositoryPath($repositoryPath);
            $syncOp->takeSnapshot();

            $tx->execute($this->unloadPathMapping($mapping));
            $tx->execute($this->removePathMappingFromPackageFile($repositoryPath));
            $tx->execute($syncOp);

            $this->saveRootPackageFile();

            $tx->commit();
        } catch (Exception $e) {
            $tx->rollback();

            throw $e;
        }

        $this->removeResolvedConflicts();
    }

    /**
     * {@inheritdoc}
     */
    public function removeRootPathMappings(Expression $expr)

    {
        $this->assertMappingsLoaded();

        $tx = new Transaction();

        try {
            foreach ($this->getRootPathMappings() as $mapping) {
                if ($expr->evaluate($mapping)) {
                    $syncOp = $this->syncRepositoryPath($mapping->getRepositoryPath());
                    $syncOp->takeSnapshot();

                    $tx->execute($this->unloadPathMapping($mapping));
                    $tx->execute($this->removePathMappingFromPackageFile($mapping->getRepositoryPath()));
                    $tx->execute($syncOp);
                }
            }

            $this->saveRootPackageFile();

            $tx->commit();
        } catch (Exception $e) {
            $tx->rollback();

            throw $e;
        }

        $this->removeResolvedConflicts();
    }

    /**
     * {@inheritdoc}
     */
    public function clearRootPathMappings()
    {
        $this->removeRootPathMappings(Expr::true());
    }

    /**
     * {@inheritdoc}
     */
    public function getRootPathMapping($repositoryPath)
    {
        return $this->getPathMapping($repositoryPath, $this->rootPackage->getName());
    }

    /**
     * {@inheritdoc}
     */
    public function findRootPathMappings(Expression $expr)

    {
        $expr = Expr::method('getContainingPackage', Expr::same($this->rootPackage))
            ->andX($expr);

        return $this->findPathMappings($expr);
    }

    /**
     * {@inheritdoc}
     */
    public function getRootPathMappings()

    {
        $this->assertMappingsLoaded();

        $mappings = array();
        $rootPackageName = $this->rootPackage->getName();

        foreach ($this->mappings->toArray() as $mappingsByPackage) {
            if (isset($mappingsByPackage[$rootPackageName])) {
                $mappings[] = $mappingsByPackage[$rootPackageName];
            }
        }

        return $mappings;
    }

    /**
     * {@inheritdoc}
     */
    public function hasRootPathMapping($repositoryPath)
    {
        return $this->hasPathMapping($repositoryPath, $this->rootPackage->getName());
    }

    /**
     * {@inheritdoc}
     */
    public function hasRootPathMappings(Expression $expr = null)

    {
        $expr2 = Expr::method('getContainingPackage', Expr::same($this->rootPackage));

        if ($expr) {
            $expr2 = $expr2->andX($expr);
        }

        return $this->hasPathMappings($expr2);
    }

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

        $this->assertMappingsLoaded();

        if (!$this->mappings->contains($repositoryPath, $packageName)) {
            throw NoSuchPathMappingException::forRepositoryPathAndPackage($repositoryPath, $packageName);
        }

        return $this->mappings->get($repositoryPath, $packageName);
    }

    /**
     * {@inheritdoc}
     */
    public function getPathMappings()
    {
        $this->assertMappingsLoaded();

        $mappings = array();

        foreach ($this->mappings->toArray() as $mappingsByPackage) {
            foreach ($mappingsByPackage as $mapping) {
                $mappings[] = $mapping;
            }
        }

        return $mappings;
    }

    /**
     * {@inheritdoc}
     */
    public function findPathMappings(Expression $expr)

    {
        $this->assertMappingsLoaded();

        $mappings = array();

        foreach ($this->mappings->toArray() as $mappingsByPackage) {
            foreach ($mappingsByPackage as $mapping) {
                if ($expr->evaluate($mapping)) {
                    $mappings[] = $mapping;
                }
            }
        }

        return $mappings;
    }

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

        $this->assertMappingsLoaded();

        return $this->mappings->contains($repositoryPath, $packageName);
    }

    /**
     * {@inheritdoc}
     */
    public function hasPathMappings(Expression $expr = null)

    {
        $this->assertMappingsLoaded();

        if (!$expr) {
            return !$this->mappings->isEmpty();
        }

        foreach ($this->mappings->toArray() as $mappingsByPackage) {
            foreach ($mappingsByPackage as $mapping) {
                if ($expr->evaluate($mapping)) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function getPathConflicts()
    {
        $this->assertMappingsLoaded();

        return array_values($this->conflicts->toArray());
    }

    /**
     * {@inheritdoc}
     */
    public function buildRepository()
    {
        $this->assertMappingsLoaded();

        if ($this->dispatcher->hasListeners(PuliEvents::PRE_BUILD_REPOSITORY)) {
            $event = new BuildRepositoryEvent($this);

            $this->dispatcher->dispatch(PuliEvents::PRE_BUILD_REPOSITORY, $event);

            if ($event->isBuildSkipped()) {
                return;
            }
        }

        $this->populateRepository()->execute();

        if ($this->dispatcher->hasListeners(PuliEvents::POST_BUILD_REPOSITORY)) {
            $this->dispatcher->dispatch(PuliEvents::POST_BUILD_REPOSITORY, new BuildRepositoryEvent($this));
        }
    }

    /**
     * {@inheritdoc}
     */
    public function clearRepository()
    {
        $this->repo->clear();
    }

    private function loadPathMappings()
    {
        $this->overrideGraph = OverrideGraph::forPackages($this->packages);
        $this->conflictDetector = new PackageConflictDetector($this->overrideGraph);
        $this->mappings = new PathMappingCollection();
        $this->mappingsByResource = new PathMappingCollection();
        $this->conflicts = new ConflictCollection();

        // Load mappings
        foreach ($this->packages as $package) {

            if (null === $package->getPackageFile()) {
                continue;
            }

            foreach ($package->getPackageFile()->getPathMappings() as $mapping) {
                $this->loadPathMapping($mapping, $package)->execute();
            }
        }

        // Scan all paths for conflicts
        $this->updateConflicts($this->mappingsByResource->getRepositoryPaths())->execute();
    }

    private function addPathMappingToPackageFile(PathMapping $mapping)
    {
        return new AddPathMappingToPackageFile($mapping, $this->rootPackageFile);
    }

    private function removePathMappingFromPackageFile($repositoryPath)
    {
        return new RemovePathMappingFromPackageFile($repositoryPath, $this->rootPackageFile);
    }

    private function loadPathMapping(PathMapping $mapping, Package $package)
    {
        return new LoadPathMapping($mapping, $package, $this->packages, $this->mappings, $this->mappingsByResource, $this->conflictDetector);
    }

    private function unloadPathMapping(PathMapping $mapping)
    {
        return new UnloadPathMapping($mapping, $this->packages, $this->mappings, $this->mappingsByResource, $this->conflictDetector);
    }

    private function syncRepositoryPath($repositoryPath)
    {
        return new SyncRepositoryPath($repositoryPath, $this->repo, $this->mappings, $this->overrideGraph);
    }

    private function populateRepository()
    {
        return new PopulateRepository($this->repo, $this->mappings, $this->overrideGraph);
    }

    private function updateConflicts(array $repositoryPaths = array())
    {
        return new UpdateConflicts($repositoryPaths, $this->conflictDetector, $this->conflicts, $this->mappingsByResource);
    }

    private function overrideConflictingPackages(PathMapping $mapping)
    {
        return new OverrideConflictingPackages($mapping, $this->rootPackage, $this->overrideGraph);
    }

    private function saveRootPackageFile()
    {
        $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
    }

    private function removeResolvedConflicts()
    {
        foreach ($this->conflicts as $conflictPath => $conflict) {
            if ($conflict->isResolved()) {
                unset($this->conflicts[$conflictPath]);
            }
        }
    }

    private function assertMappingsLoaded()
    {
        if (!$this->overrideGraph) {
            $this->loadPathMappings();
        }
    }

    private function assertNoLoadErrors(PathMapping $mapping)
    {
        $loadErrors = $mapping->getLoadErrors();

        if (count($loadErrors) > 0) {
            // Rethrow first error
            throw reset($loadErrors);
        }
    }
}


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\Repository;
13
14			use Exception;
15			use Puli\Manager\Api\Config\Config;
16			use Puli\Manager\Api\Context\ProjectContext;
17			use Puli\Manager\Api\Event\BuildRepositoryEvent;
18			use Puli\Manager\Api\Event\PuliEvents;
19			use Puli\Manager\Api\Package\Package;
20			use Puli\Manager\Api\Package\PackageCollection;
21			use Puli\Manager\Api\Package\RootPackage;
22			use Puli\Manager\Api\Package\RootPackageFile;
23			use Puli\Manager\Api\Repository\DuplicatePathMappingException;
24			use Puli\Manager\Api\Repository\NoSuchPathMappingException;
25			use Puli\Manager\Api\Repository\PathMapping;
26			use Puli\Manager\Api\Repository\RepositoryManager;
27			use Puli\Manager\Assert\Assert;
28			use Puli\Manager\Conflict\OverrideGraph;
29			use Puli\Manager\Conflict\PackageConflictDetector;
30			use Puli\Manager\Package\PackageFileStorage;
31			use Puli\Manager\Repository\Mapping\AddPathMappingToPackageFile;
32			use Puli\Manager\Repository\Mapping\ConflictCollection;
33			use Puli\Manager\Repository\Mapping\LoadPathMapping;
34			use Puli\Manager\Repository\Mapping\OverrideConflictingPackages;
35			use Puli\Manager\Repository\Mapping\PathMappingCollection;
36			use Puli\Manager\Repository\Mapping\PopulateRepository;
37			use Puli\Manager\Repository\Mapping\RemovePathMappingFromPackageFile;
38			use Puli\Manager\Repository\Mapping\SyncRepositoryPath;
39			use Puli\Manager\Repository\Mapping\UnloadPathMapping;
40			use Puli\Manager\Repository\Mapping\UpdateConflicts;
41			use Puli\Manager\Transaction\Transaction;
42			use Puli\Repository\Api\EditableRepository;
43			use Symfony\Component\EventDispatcher\EventDispatcherInterface;
44			use Webmozart\Expression\Expr;
45			use Webmozart\Expression\Expression;
46
47			/**
48			* Manages the resource repository of a Puli project.
49			*
50			* @since 1.0
51			*
52			* @author Bernhard Schussek <[email protected]>
53			*/
54			class RepositoryManagerImpl implements RepositoryManager
55			{
56			/**
57			* @var ProjectContext
58			*/
59			private $context;
60
61			/**
62			* @var EventDispatcherInterface
63			*/
64			private $dispatcher;
65
66			/**
67			* @var Config
68			*/
69			private $config;
70
71			/**
72			* @var string
73			*/
74			private $rootDir;
75
76			/**
77			* @var RootPackage
78			*/
79			private $rootPackage;
80
81			/**
82			* @var RootPackageFile
83			*/
84			private $rootPackageFile;
85
86			/**
87			* @var EditableRepository
88			*/
89			private $repo;
90
91			/**
92			* @var PackageCollection
93			*/
94			private $packages;
95
96			/**
97			* @var PackageFileStorage
98			*/
99			private $packageFileStorage;
100
101			/**
102			* @var OverrideGraph
103			*/
104			private $overrideGraph;
105
106			/**
107			* @var PackageConflictDetector
108			*/
109			private $conflictDetector;
110
111			/**
112			* @var PathMappingCollection
113			*/
114			private $mappings;
115
116			/**
117			* @var PathMappingCollection
118			*/
119			private $mappingsByResource;
120
121			/**
122			* @var ConflictCollection
123			*/
124			private $conflicts;
125
126			/**
127			* Creates a repository manager.
128			*
129			* @param ProjectContext $context
130			* @param EditableRepository $repo
131			* @param PackageCollection $packages
132			* @param PackageFileStorage $packageFileStorage
133			*/
134	65		public function __construct(ProjectContext $context, EditableRepository $repo, PackageCollection $packages, PackageFileStorage $packageFileStorage)
135			{
136	65		$this->context = $context;
137	65		$this->dispatcher = $context->getEventDispatcher();
138	65		$this->repo = $repo;
139	65		$this->config = $context->getConfig();
140	65		$this->rootDir = $context->getRootDirectory();
141	65		$this->rootPackage = $packages->getRootPackage();
142	65		$this->rootPackageFile = $context->getRootPackageFile();
143	65		$this->packages = $packages;
144	65		$this->packageFileStorage = $packageFileStorage;
145	65		}
146
147			/**
148			* {@inheritdoc}
149			*/
150	1		public function getContext()
151			{
152	1		return $this->context;
153			}
154
155			/**
156			* {@inheritdoc}
157			*/
158	1		public function getRepository()
159			{
160	1		return $this->repo;
161			}
162
163			/**
164			* {@inheritdoc}
165			*/
166	15		public function addRootPathMapping(PathMapping $mapping, $flags = 0)
167			{
168	15		Assert::integer($flags, 'The argument $flags must be a boolean.');
169
170	15		$this->assertMappingsLoaded();
171
172	15		if (!($flags & self::OVERRIDE) && $this->rootPackageFile->hasPathMapping($mapping->getRepositoryPath())) {
173	1		throw DuplicatePathMappingException::forRepositoryPath($mapping->getRepositoryPath(), $this->rootPackage->getName());
174			}
175
176	14		$tx = new Transaction();
177
178			try {
179	14		$syncOp = $this->syncRepositoryPath($mapping->getRepositoryPath());
180	14		$syncOp->takeSnapshot();
181
182	14		$tx->execute($this->loadPathMapping($mapping, $this->rootPackage));
183
184	14		if (!($flags & self::IGNORE_FILE_NOT_FOUND)) {
185	13		$this->assertNoLoadErrors($mapping);
186	12		}
187
188	13		$tx->execute($this->updateConflicts($mapping->listRepositoryPaths()));
189	13		$tx->execute($this->overrideConflictingPackages($mapping));
190	13		$tx->execute($this->updateConflicts());
191	13		$tx->execute($this->addPathMappingToPackageFile($mapping));
192	13		$tx->execute($syncOp);
193
194	13		$this->saveRootPackageFile();
195
196	11		$tx->commit();
197	14		} catch (Exception $e) {
198	3		$tx->rollback();
199
200	3		throw $e;
201			}
202	11		}
203
204			/**
205			* {@inheritdoc}
206			*/
207	11		public function removeRootPathMapping($repositoryPath)
208			{
209	11		Assert::path($repositoryPath);
210
211	11		$this->assertMappingsLoaded();
212
213	11		if (!$this->mappings->contains($repositoryPath, $this->rootPackage->getName())) {
214	2		return;
215			}
216
217	9		$mapping = $this->mappings->get($repositoryPath, $this->rootPackage->getName());
218	9		$tx = new Transaction();
219
220			try {
221	9		$syncOp = $this->syncRepositoryPath($repositoryPath);
222	9		$syncOp->takeSnapshot();
223
224	9		$tx->execute($this->unloadPathMapping($mapping));
225	9		$tx->execute($this->removePathMappingFromPackageFile($repositoryPath));
226	9		$tx->execute($syncOp);
227
228	9		$this->saveRootPackageFile();
229
230	6		$tx->commit();
231	9		} catch (Exception $e) {
232	3		$tx->rollback();
233
234	3		throw $e;
235			}
236
237	6		$this->removeResolvedConflicts();
238	6		}
239
240			/**
241			* {@inheritdoc}
242			*/
243	3	View Code Duplication	public function removeRootPathMappings(Expression $expr)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
244			{
245	3		$this->assertMappingsLoaded();
246
247	3		$tx = new Transaction();
248
249			try {
250	3		foreach ($this->getRootPathMappings() as $mapping) {
251	3		if ($expr->evaluate($mapping)) {
252	3		$syncOp = $this->syncRepositoryPath($mapping->getRepositoryPath());
253	3		$syncOp->takeSnapshot();
254
255	3		$tx->execute($this->unloadPathMapping($mapping));
256	3		$tx->execute($this->removePathMappingFromPackageFile($mapping->getRepositoryPath()));
257	3		$tx->execute($syncOp);
258	3		}
259	3		}
260
261	3		$this->saveRootPackageFile();
262
263	2		$tx->commit();
264	3		} catch (Exception $e) {
265	1		$tx->rollback();
266
267	1		throw $e;
268			}
269
270	2		$this->removeResolvedConflicts();
271	2		}
272
273			/**
274			* {@inheritdoc}
275			*/
276	1		public function clearRootPathMappings()
277			{
278	1		$this->removeRootPathMappings(Expr::true());
279	1		}
280
281			/**
282			* {@inheritdoc}
283			*/
284	3		public function getRootPathMapping($repositoryPath)
285			{
286	3		return $this->getPathMapping($repositoryPath, $this->rootPackage->getName());
287			}
288
289			/**
290			* {@inheritdoc}
291			*/
292	1	View Code Duplication	public function findRootPathMappings(Expression $expr)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
293			{
294	1		$expr = Expr::method('getContainingPackage', Expr::same($this->rootPackage))
295	1		->andX($expr);
296
297	1		return $this->findPathMappings($expr);
298			}
299
300			/**
301			* {@inheritdoc}
302			*/
303	4	View Code Duplication	public function getRootPathMappings()
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
304			{
305	4		$this->assertMappingsLoaded();
306
307	4		$mappings = array();
308	4		$rootPackageName = $this->rootPackage->getName();
309
310	4		foreach ($this->mappings->toArray() as $mappingsByPackage) {
311	4		if (isset($mappingsByPackage[$rootPackageName])) {
312	4		$mappings[] = $mappingsByPackage[$rootPackageName];
313	4		}
314	4		}
315
316	4		return $mappings;
317			}
318
319			/**
320			* {@inheritdoc}
321			*/
322	1		public function hasRootPathMapping($repositoryPath)
323			{
324	1		return $this->hasPathMapping($repositoryPath, $this->rootPackage->getName());
325			}
326
327			/**
328			* {@inheritdoc}
329			*/
330	1	View Code Duplication	public function hasRootPathMappings(Expression $expr = null)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
331			{
332	1		$expr2 = Expr::method('getContainingPackage', Expr::same($this->rootPackage));
333
334	1		if ($expr) {
335	1		$expr2 = $expr2->andX($expr);
336	1		}
337
338	1		return $this->hasPathMappings($expr2);
339			}
340
341			/**
342			* {@inheritdoc}
343			*/
344	6		public function getPathMapping($repositoryPath, $packageName)
345			{
346	6		Assert::string($repositoryPath, 'The repository path must be a string. Got: %s');
347	6		Assert::string($packageName, 'The package name must be a string. Got: %s');
348
349	6		$this->assertMappingsLoaded();
350
351	6		if (!$this->mappings->contains($repositoryPath, $packageName)) {
352	4		throw NoSuchPathMappingException::forRepositoryPathAndPackage($repositoryPath, $packageName);
353			}
354
355	2		return $this->mappings->get($repositoryPath, $packageName);
356			}
357
358			/**
359			* {@inheritdoc}
360			*/
361	2		public function getPathMappings()
362			{
363	2		$this->assertMappingsLoaded();
364
365	2		$mappings = array();
366
367	2		foreach ($this->mappings->toArray() as $mappingsByPackage) {
368	1		foreach ($mappingsByPackage as $mapping) {
369	1		$mappings[] = $mapping;
370	1		}
371	2		}
372
373	2		return $mappings;
374			}
375
376			/**
377			* {@inheritdoc}
378			*/
379	2	View Code Duplication	public function findPathMappings(Expression $expr)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
380			{
381	2		$this->assertMappingsLoaded();
382
383	2		$mappings = array();
384
385	2		foreach ($this->mappings->toArray() as $mappingsByPackage) {
386	2		foreach ($mappingsByPackage as $mapping) {
387	2		if ($expr->evaluate($mapping)) {
388	2		$mappings[] = $mapping;
389	2		}
390	2		}
391	2		}
392
393	2		return $mappings;
394			}
395
396			/**
397			* {@inheritdoc}
398			*/
399	2		public function hasPathMapping($repositoryPath, $packageName)
400			{
401	2		Assert::string($repositoryPath, 'The repository path must be a string. Got: %s');
402	2		Assert::string($packageName, 'The package name must be a string. Got: %s');
403
404	2		$this->assertMappingsLoaded();
405
406	2		return $this->mappings->contains($repositoryPath, $packageName);
407			}
408
409			/**
410			* {@inheritdoc}
411			*/
412	3	View Code Duplication	public function hasPathMappings(Expression $expr = null)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
413			{
414	3		$this->assertMappingsLoaded();
415
416	3		if (!$expr) {
417	2		return !$this->mappings->isEmpty();
418			}
419
420	2		foreach ($this->mappings->toArray() as $mappingsByPackage) {
421	2		foreach ($mappingsByPackage as $mapping) {
422	2		if ($expr->evaluate($mapping)) {
423	2		return true;
424			}
425	2		}
426	2		}
427
428	2		return false;
429			}
430
431			/**
432			* {@inheritdoc}
433			*/
434	10		public function getPathConflicts()
435			{
436	10		$this->assertMappingsLoaded();
437
438	10		return array_values($this->conflicts->toArray());
439			}
440
441			/**
442			* {@inheritdoc}
443			*/
444	15		public function buildRepository()
445			{
446	15		$this->assertMappingsLoaded();
447
448	15		if ($this->dispatcher->hasListeners(PuliEvents::PRE_BUILD_REPOSITORY)) {
449	2		$event = new BuildRepositoryEvent($this);
450
451	2		$this->dispatcher->dispatch(PuliEvents::PRE_BUILD_REPOSITORY, $event);
452
453	2		if ($event->isBuildSkipped()) {
454	1		return;
455			}
456	1		}
457
458	14		$this->populateRepository()->execute();
459
460	14		if ($this->dispatcher->hasListeners(PuliEvents::POST_BUILD_REPOSITORY)) {
461	1		$this->dispatcher->dispatch(PuliEvents::POST_BUILD_REPOSITORY, new BuildRepositoryEvent($this));
462	1		}
463	14		}
464
465			/**
466			* {@inheritdoc}
467			*/
468	1		public function clearRepository()
469			{
470	1		$this->repo->clear();
471	1		}
472
473	63		private function loadPathMappings()
474			{
475	63		$this->overrideGraph = OverrideGraph::forPackages($this->packages);
476	63		$this->conflictDetector = new PackageConflictDetector($this->overrideGraph);
477	63		$this->mappings = new PathMappingCollection();
478	63		$this->mappingsByResource = new PathMappingCollection();
479	63		$this->conflicts = new ConflictCollection();
480
481			// Load mappings
482	63	View Code Duplication	foreach ($this->packages as $package) {
			0 ignored issues – show Duplication introduced 2015-12-30 11:06 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
483	63		if (null === $package->getPackageFile()) {
484	1		continue;
485			}
486
487	63		foreach ($package->getPackageFile()->getPathMappings() as $mapping) {
488	51		$this->loadPathMapping($mapping, $package)->execute();
489	63		}
490	63		}
491
492			// Scan all paths for conflicts
493	63		$this->updateConflicts($this->mappingsByResource->getRepositoryPaths())->execute();
494	63		}
495
496	13		private function addPathMappingToPackageFile(PathMapping $mapping)
497			{
498	13		return new AddPathMappingToPackageFile($mapping, $this->rootPackageFile);
499			}
500
501	12		private function removePathMappingFromPackageFile($repositoryPath)
502			{
503	12		return new RemovePathMappingFromPackageFile($repositoryPath, $this->rootPackageFile);
504			}
505
506	57		private function loadPathMapping(PathMapping $mapping, Package $package)
507			{
508	57		return new LoadPathMapping($mapping, $package, $this->packages, $this->mappings, $this->mappingsByResource, $this->conflictDetector);
509			}
510
511	12		private function unloadPathMapping(PathMapping $mapping)
512			{
513	12		return new UnloadPathMapping($mapping, $this->packages, $this->mappings, $this->mappingsByResource, $this->conflictDetector);
514			}
515
516	26		private function syncRepositoryPath($repositoryPath)
517			{
518	26		return new SyncRepositoryPath($repositoryPath, $this->repo, $this->mappings, $this->overrideGraph);
519			}
520
521	14		private function populateRepository()
522			{
523	14		return new PopulateRepository($this->repo, $this->mappings, $this->overrideGraph);
524			}
525
526	63		private function updateConflicts(array $repositoryPaths = array())
527			{
528	63		return new UpdateConflicts($repositoryPaths, $this->conflictDetector, $this->conflicts, $this->mappingsByResource);
529			}
530
531	13		private function overrideConflictingPackages(PathMapping $mapping)
532			{
533	13		return new OverrideConflictingPackages($mapping, $this->rootPackage, $this->overrideGraph);
534			}
535
536	25		private function saveRootPackageFile()
537			{
538	25		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
539	19		}
540
541	8		private function removeResolvedConflicts()
542			{
543	8		foreach ($this->conflicts as $conflictPath => $conflict) {
544	2		if ($conflict->isResolved()) {
545	1		unset($this->conflicts[$conflictPath]);
546	1		}
547	8		}
548	8		}
549
550	63		private function assertMappingsLoaded()
551			{
552	63		if (!$this->overrideGraph) {
553	63		$this->loadPathMappings();
554	63		}
555	63		}
556
557	13		private function assertNoLoadErrors(PathMapping $mapping)
558			{
559	13		$loadErrors = $mapping->getLoadErrors();
560
561	13		if (count($loadErrors) > 0) {
562			// Rethrow first error
563	1		throw reset($loadErrors);
564			}
565	12		}
566			}
567

puli / manager