StandardIndexMerger::merge() - Code Metrics - Inspection of "Minor refactoring for reduced code duplication" - storeman-io/storeman - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 44a00f...9727c6 )

by Arne
created 2018-07-12 02:01 UTC
StandardIndexMerger::merge() B

↳ Parent: StandardIndexMerger
Complexity

Conditions	8
Paths	48
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	46
rs	7.9337
c	0
b	0
f	0
cc	8
nc	48
nop	5
<?php

namespace Storeman\IndexMerger;

use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\NullLogger;
use Storeman\Config\Configuration;
use Storeman\ConflictHandler\ConflictHandlerInterface;
use Storeman\Hash\HashProvider;
use Storeman\Index\Index;
use Storeman\Index\IndexObject;

class StandardIndexMerger implements IndexMergerInterface, LoggerAwareInterface
{
    use LoggerAwareTrait;

    public const VERIFY_CONTENT = 2;

    /**
     * @var Configuration
     */
    protected $configuration;

    /**
     * @var HashProvider
     */
    protected $hashProvider;

    public function __construct(Configuration $configuration, HashProvider $hashProvider)
    {
        $this->configuration = $configuration;
        $this->hashProvider = $hashProvider;
        $this->logger = new NullLogger();
    }

    /**
     * {@inheritdoc}
     */
    public function merge(ConflictHandlerInterface $conflictHandler, Index $remoteIndex, Index $localIndex, ?Index $lastLocalIndex, int $options = 0): Index
    {
        $this->logger->info(sprintf("Merging indices using %s (Options: %s)", static::class, static::getOptionsDebugString($options)));

        $mergedIndex = new Index();
        $lastLocalIndex = $lastLocalIndex ?: new Index();

        foreach ($localIndex as $localObject)
        {
            /** @var IndexObject $localObject */

            $remoteObject = $remoteIndex->getObjectByPath($localObject->getRelativePath());
            $lastLocalObject = $lastLocalIndex->getObjectByPath($localObject->getRelativePath());

            if ($mergedObject = $this->mergeObject1($conflictHandler, $remoteObject, $localObject, $lastLocalObject, $options))
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            {
                $mergedIndex->addObject($mergedObject);
            }
        }

        foreach ($remoteIndex as $remoteObject)
        {
            /** @var IndexObject $remoteObject */

            $localObject = $localIndex->getObjectByPath($remoteObject->getRelativePath());
            $lastLocalObject = $lastLocalIndex->getObjectByPath($remoteObject->getRelativePath());

            if ($localObject !== null)
            {
                // already taken care of in local index iteration
                continue;
            }

            if ($mergedObject = $this->mergeObject1($conflictHandler, $remoteObject, $localObject, $lastLocalObject, $options))
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            {
                $mergedIndex->addObject($mergedObject);
            }
        }

        if ($options & static::INJECT_BLOBID)
        {
            $this->injectBlobIds($mergedIndex, $localIndex);
        }

        return $mergedIndex;
    }

    /**
     * First stage object merging looking at primarily at pure existence.
     *
     * @param ConflictHandlerInterface $conflictHandler
     * @param IndexObject $remoteObject
     * @param IndexObject $localObject
     * @param IndexObject $lastLocalObject
     * @param int $options
     * @return IndexObject
     */
    protected function mergeObject1(ConflictHandlerInterface $conflictHandler, ?IndexObject $remoteObject, ?IndexObject $localObject, ?IndexObject $lastLocalObject, int $options = 0): ?IndexObject
    {
        if ($remoteObject === null && $localObject === null)
        {
            // locally and remotely deleted
            return null;
        }
        elseif ($lastLocalObject === null)
        {
            if ($remoteObject === null)
            {
                // locally created
                return clone $localObject;
            }
            elseif ($localObject === null)
            {
                // remotely created
                return clone $remoteObject;
            }
            elseif ($remoteObject !== null && $localObject !== null)
            {
                // remotely and locally created
                return $this->resolveConflict($conflictHandler, $remoteObject, $localObject, $lastLocalObject);
            }
        }
        elseif ($remoteObject === null)
        {
            // remotely deleted and locally changed
            return $this->resolveConflict($conflictHandler, $remoteObject, $localObject, $lastLocalObject);
        }
        elseif ($localObject === null)
        {
            if ($remoteObject->equals($lastLocalObject))
            {
                // locally deleted
                return null;
            }
            else
            {
                // remotely changed and locally deleted
                return $this->resolveConflict($conflictHandler, $remoteObject, $localObject, $lastLocalObject);
            }
        }

        return $this->mergeObject2($conflictHandler, $remoteObject, $localObject, $lastLocalObject, $options);
    }

    /**
     * Second stage object merging.
     *
     * @param ConflictHandlerInterface $conflictHandler
     * @param IndexObject $remoteObject
     * @param IndexObject $localObject
     * @param IndexObject $lastLocalObject
     * @param int $options
     * @return IndexObject
     */
    protected function mergeObject2(ConflictHandlerInterface $conflictHandler, IndexObject $remoteObject, IndexObject $localObject, IndexObject $lastLocalObject, int $options = 0): IndexObject
    {
        if ($remoteObject->getType() !== $localObject->getType())
        {
            return $this->resolveConflict($conflictHandler, $remoteObject, $localObject, $lastLocalObject);
        }

        $attributes = [
            'size' => null,
            'inode' => null,
            'blobId' => null,
            'hashes' => null,
        ];

        foreach (['permissions', 'mtime', 'linkTarget'] as $attribute)
        {
            $modifiedRemote = $lastLocalObject[$attribute] !== $remoteObject[$attribute];
            $modifiedLocal = $lastLocalObject[$attribute] !== $localObject[$attribute];

            if ($modifiedRemote && $modifiedLocal)
            {
                switch ($conflictHandler->handleConflict($remoteObject, $localObject, $lastLocalObject))
                {
                    case ConflictHandlerInterface::USE_LOCAL: $modifiedRemote = false; break;
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                    case ConflictHandlerInterface::USE_REMOTE: $modifiedLocal = false; break;
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                    default: throw new \LogicException();
switch ($expr) {
    default:
        doSomething(); //right
        break;
}


switch ($expr) {
    default:

        doSomething(); //wrong
        break;
}
                }
            }

            if ($modifiedRemote || !$modifiedLocal)
            {
                $attributes[$attribute] = $remoteObject[$attribute];
            }
            else
            {
                $attributes[$attribute] = $localObject[$attribute];
            }
        }

        if ($localObject->isFile())
        {
            $remoteFileContentModified = $this->isRemoteFileContentModified($remoteObject, $lastLocalObject);
            $localFileContentModified = $this->isLocalFileContentModified($localObject, $lastLocalObject, $options);

            if ($remoteFileContentModified && $localFileContentModified)
            {
                switch ($conflictHandler->handleConflict($remoteObject, $localObject, $lastLocalObject))
                {
                    case ConflictHandlerInterface::USE_LOCAL: $remoteFileContentModified = false; break;
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
                    case ConflictHandlerInterface::USE_REMOTE: $localFileContentModified = false; break;
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
                    default: throw new \LogicException();
switch ($expr) {
    default:
        doSomething(); //right
        break;
}


switch ($expr) {
    default:

        doSomething(); //wrong
        break;
}
                }
            }

            if ($remoteFileContentModified || !$localFileContentModified)
            {
                $attributes['size'] = $remoteObject->getSize();
                $attributes['blobId'] = $remoteObject->getBlobId();
                $attributes['hashes'] = clone $remoteObject->getHashes();
            }
            else
            {
                $attributes['size'] = $localObject->getSize();
                $attributes['inode'] = $localObject->getInode();
                $attributes['hashes'] = clone $localObject->getHashes();
            }
        }

        return new IndexObject(
            $localObject->getRelativePath(),
            $localObject->getType(),
            $attributes['mtime'],
            null,
            $attributes['permissions'],
            $attributes['size'],
            $attributes['inode'],
            $attributes['linkTarget'],
            $attributes['blobId'],
            $attributes['hashes']
        );
    }

    protected function isLocalFileContentModified(IndexObject $localObject, IndexObject $lastLocalObject, int $options): bool
    {
        assert($localObject->isFile());
        assert($lastLocalObject->isFile());

        $modified = false;
        $modified |= !$localObject->getHashes()->equals($lastLocalObject->getHashes());
        $modified |= $localObject->getSize() !== $lastLocalObject->getSize();
        $modified |= $localObject->getInode() !== $lastLocalObject->getInode();
        $modified |= $localObject->getMtime() !== $lastLocalObject->getMtime();

        $verifyContent = false;
        $verifyContent |= !$modified && $localObject->getCtime() !== $lastLocalObject->getCtime();
        $verifyContent |= !$modified && $options & static::VERIFY_CONTENT;

        if ($verifyContent)
        {
            $existingHashes = iterator_to_array($lastLocalObject->getHashes());
            $configuredAlgorithms = $this->configuration->getFileChecksums();

            if (!empty($comparableAlgorithms = array_intersect($configuredAlgorithms, array_keys($existingHashes))))
            {
                $this->hashProvider->loadHashes($localObject, $comparableAlgorithms);

                foreach ($comparableAlgorithms as $algorithm)
                {
                    if ($this->hashProvider->getHash($localObject, $algorithm) !== $existingHashes[$algorithm])
                    {
                        $modified = true;
                    }
                }
            }
        }

        return $modified;
    }

    protected function isRemoteFileContentModified(IndexObject $remoteObject, IndexObject $lastLocalObject): bool
    {
        return $remoteObject->getBlobId() !== $lastLocalObject->getBlobId();
    }

    protected function resolveConflict(ConflictHandlerInterface $conflictHandler, IndexObject $remoteObject, ?IndexObject $localObject, ?IndexObject $lastLocalObject): IndexObject
    {
        $this->logger->notice("Resolving conflict at {$remoteObject->getRelativePath()}...");

        assert(($localObject === null) || ($localObject->getRelativePath() === $remoteObject->getRelativePath()));
        assert(($lastLocalObject === null) || ($lastLocalObject->getRelativePath() === $remoteObject->getRelativePath()));

        $solution = $conflictHandler->handleConflict($remoteObject, $localObject, $lastLocalObject);

        $return = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        switch ($solution)
        {
            case ConflictHandlerInterface::USE_LOCAL:
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}

                $this->logger->info("Using local version for conflict at {$remoteObject->getRelativePath()}");

                $return = clone $localObject;

                break;

            case ConflictHandlerInterface::USE_REMOTE:
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;

                $this->logger->info("Using remote version for conflict at {$remoteObject->getRelativePath()}");

                $return = clone $remoteObject;

                break;

            default:
switch ($expr) {
    default:
        doSomething(); //right
        break;
}


switch ($expr) {
    default:

        doSomething(); //wrong
        break;
}

                throw new \LogicException();
        }

        return $return;
    }

    protected function injectBlobIds(Index $mergedIndex, Index $localIndex): void
    {
        foreach ($mergedIndex as $object)
        {
            /** @var IndexObject $object*/

            if ($object->getBlobId() !== null)
            {
                if ($localObject = $localIndex->getObjectByPath($object->getRelativePath()))
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                {
                    $localObject->setBlobId($object->getBlobId());
                }
            }
        }
    }

    public static function getOptionsDebugString(int $options): string
    {
        $strings = [];

        if ($options & static::VERIFY_CONTENT)
        {
            $strings[] = 'VERIFY_CONTENT';
        }

        return empty($strings) ? '-' : implode(',', $strings);
    }
}

1			<?php
2
3			namespace Storeman\IndexMerger;
4
5			use Psr\Log\LoggerAwareInterface;
6			use Psr\Log\LoggerAwareTrait;
7			use Psr\Log\NullLogger;
8			use Storeman\Config\Configuration;
9			use Storeman\ConflictHandler\ConflictHandlerInterface;
10			use Storeman\Hash\HashProvider;
11			use Storeman\Index\Index;
12			use Storeman\Index\IndexObject;
13
14			class StandardIndexMerger implements IndexMergerInterface, LoggerAwareInterface
15			{
16			use LoggerAwareTrait;
17
18			public const VERIFY_CONTENT = 2;
19
20			/**
21			* @var Configuration
22			*/
23			protected $configuration;
24
25			/**
26			* @var HashProvider
27			*/
28			protected $hashProvider;
29
30			public function __construct(Configuration $configuration, HashProvider $hashProvider)
31			{
32			$this->configuration = $configuration;
33			$this->hashProvider = $hashProvider;
34			$this->logger = new NullLogger();
35			}
36
37			/**
38			* {@inheritdoc}
39			*/
40			public function merge(ConflictHandlerInterface $conflictHandler, Index $remoteIndex, Index $localIndex, ?Index $lastLocalIndex, int $options = 0): Index
storeman-io / storeman

Push — master ( 44a00f...9727c6 )

StandardIndexMerger::merge() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
