Puli\Manager\Repository\Mapping\UpdateConflicts

Complexity

Total Complexity

18

Size/Duplication

Total Lines	125
Duplicated Lines	8.8 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	rollback()	5	16	4
A	__construct()	0	7	1
B	execute()	6	33	6
C	deduplicateModuleConflicts()	0	24	7

<?php

/*
 * This file is part of the puli/manager package.
 *
 * (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\Repository\Mapping;

use Puli\Manager\Api\Repository\PathConflict;
use Puli\Manager\Api\Repository\PathMapping;
use Puli\Manager\Conflict\ModuleConflict;
use Puli\Manager\Conflict\ModuleConflictDetector;
use Puli\Manager\Transaction\AtomicOperation;
use Webmozart\PathUtil\Path;

/**
 * Updates the resource path conflicts.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <bschussek@gmail.com>
 */
class UpdateConflicts implements AtomicOperation
{
    /**
     * @var string[]
     */
    private $repositoryPaths;

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

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

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

    /**
     * @var string[]
     */
    private $addedConflicts = array();

    /**
     * @var PathMapping[][]
     */
    private $removedConflicts = array();

    public function __construct(array $repositoryPaths, ModuleConflictDetector $conflictDetector, ConflictCollection $conflicts, PathMappingCollection $mappingsByResource)
    {
        $this->repositoryPaths = $repositoryPaths;
        $this->conflictDetector = $conflictDetector;
        $this->conflicts = $conflicts;
        $this->mappingsByResource = $mappingsByResource;
    }

    /**
     * {@inheritdoc}
     */
    public function execute()
    {
        if (!$this->repositoryPaths) {

The expression $this->repositoryPaths of type string[] 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.

            // Check all paths if none are passed
            $this->repositoryPaths = $this->conflicts->getRepositoryPaths();

It seems like $this->conflicts->getRepositoryPaths() of type array<integer,integer> is incompatible with the declared type array<integer,string> of property $repositoryPaths.

        }

        // Mark all as resolved
        foreach ($this->repositoryPaths as $repositoryPath) {
            if ($this->conflicts->has($repositoryPath)) {

This code seems to be duplicated across your project.

                $conflict = $this->conflicts->get($repositoryPath);
                $this->conflicts->remove($repositoryPath);
                $this->removedConflicts[$repositoryPath] = $conflict->getMappings();
                $conflict->resolve();
            }
        }

        $moduleConflicts = $this->conflictDetector->detectConflicts($this->repositoryPaths);

        $this->deduplicateModuleConflicts($moduleConflicts);

        foreach ($moduleConflicts as $moduleConflict) {
            $repositoryPath = $moduleConflict->getConflictingToken();
            $conflict = new PathConflict($repositoryPath);

            foreach ($moduleConflict->getModuleNames() as $moduleName) {
                $conflict->addMapping($this->mappingsByResource->get($repositoryPath, $moduleName));
            }

            $this->conflicts->add($conflict);
            $this->addedConflicts[] = $repositoryPath;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function rollback()
    {
        foreach ($this->addedConflicts as $repositoryPath) {
            if ($this->conflicts->has($repositoryPath)) {

This code seems to be duplicated across your project.

                $conflict = $this->conflicts->get($repositoryPath);
                $conflict->resolve();
                $this->conflicts->remove($repositoryPath);
            }
        }

        foreach ($this->removedConflicts as $repositoryPath => $conflictingMappings) {
            $conflict = new PathConflict($repositoryPath);
            $conflict->addMappings($conflictingMappings);
            $this->conflicts->add($conflict);
        }
    }

    /**
     * @param ModuleConflict[] $moduleConflicts
     */
    private function deduplicateModuleConflicts(array &$moduleConflicts)
    {
        $indicesByPath = array();
        $indicesToRemove = array();

        foreach ($moduleConflicts as $index => $moduleConflict) {
            $indicesByPath[$moduleConflict->getConflictingToken()] = $index;
        }

        foreach ($indicesByPath as $repositoryPath => $index) {
            foreach ($indicesByPath as $otherPath => $otherIndex) {
                if ($otherPath !== $repositoryPath && Path::isBasePath($otherPath, $repositoryPath)) {
                    $indicesToRemove[$index] = true;
                }
            }
        }

        foreach ($indicesToRemove as $index => $true) {
            unset($moduleConflicts[$index]);
        }

        // Reorganize indices
        $moduleConflicts = array_values($moduleConflicts);
    }
}