Storeman\IndexMerger\StandardIndexMerger

Complexity

Total Complexity

24

Size/Duplication

Total Lines	142
Duplicated Lines	18.31 %

Coupling/Cohesion

Components	0
Dependencies	3

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
F	merge()	26	109	19
B	conflict()	0	29	5

<?php

namespace Storeman\IndexMerger;

use Storeman\ConflictHandler\ConflictHandlerInterface;
use Storeman\Index;
use Storeman\IndexObject;

class StandardIndexMerger implements IndexMergerInterface
{
    public function merge(ConflictHandlerInterface $conflictHandler, Index $remoteIndex, Index $localIndex, Index $lastLocalIndex = null): Index
    {
        $mergedIndex = new Index();

        if ($lastLocalIndex === null)
        {
            // lets make our life easier
            $lastLocalIndex = new Index();
        }

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

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


            // compare existing to known object
            if ($lastLocalObject)
            {
                $localObjectModified = false;
                $localObjectModified = $localObjectModified || ($localObject->getType() !== $lastLocalObject->getType());
                $localObjectModified = $localObjectModified || ($localObject->getMtime() !== $lastLocalObject->getMtime());
                $localObjectModified = $localObjectModified || ($localObject->getCtime() !== $lastLocalObject->getCtime());
                $localObjectModified = $localObjectModified || ($localObject->getMode() !== $lastLocalObject->getMode());
                $localObjectModified = $localObjectModified || ($localObject->getSize() !== $lastLocalObject->getSize());
                $localObjectModified = $localObjectModified || ($localObject->getLinkTarget() !== $lastLocalObject->getLinkTarget());

                // remote object has been modified if it does not equal the object on its last synchronization
                // we explicitly want to use equality instead of identity
                $remoteObjectModified = !($lastLocalObject == $remoteObject);
            }

            // object has been created
            else
            {
                $localObjectModified = true;

                // object has been created since last synchronization
                $remoteObjectModified = $remoteObject !== null;
            }


            // conflict if both the local and the remote object has been changed
            if ($localObjectModified && $remoteObjectModified)

This code seems to be duplicated across your project.

            {
                $this->conflict($conflictHandler, $mergedIndex, $remoteObject, $localObject, $lastLocalObject);

It seems like $remoteObject defined by $remoteIndex->getObjectByPath($localObject->getRelativePath()) on line 25 can be null; however, Storeman\IndexMerger\StandardIndexMerger::conflict() does not accept null, maybe add an additional type check?

            }

            // add the remote object if only it has been modified
            elseif ($remoteObjectModified)
            {
                $mergedIndex->addObject($remoteObject);

It seems like $remoteObject defined by $remoteIndex->getObjectByPath($localObject->getRelativePath()) on line 25 can be null; however, Storeman\Index::addObject() does not accept null, maybe add an additional type check?

            }

            // add the local object otherwise if only it or none has been modified
            else
            {
                $mergedIndex->addObject($localObject);
            }
        }

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

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

            // only consider objects not existing locally as those are already considered by the first loop
            if (!$localObject)
            {
                if ($lastLocalObject)
                {
                    // local object has been deleted
                    $localObjectModified = true;

                    // compare remote object to object state at last sync
                    // we explicitly want to use equality instead of identity
                    $remoteObjectModified = !($remoteObject == $lastLocalObject);
                }

                else
                {
                    // object already didn't exist locally at the last sync
                    $localObjectModified = false;

                    // another client added the remote object
                    $remoteObjectModified = true;
                }


                // conflict if both the local and the remote object has been changed
                if ($localObjectModified && $remoteObjectModified)

This code seems to be duplicated across your project.

                {
                    $this->conflict($conflictHandler, $mergedIndex, $remoteObject, $localObject, $lastLocalObject);
                }

                // another client added the remote object
                elseif (!$lastLocalObject)
                {
                    $mergedIndex->addObject($remoteObject);
                }
            }
        }

        return $mergedIndex;
    }

    protected function conflict(ConflictHandlerInterface $conflictHandler, Index $mergedIndex, IndexObject $remoteObject, IndexObject $localObject = null, IndexObject $lastLocalObject = null): void
    {
        $solution = $conflictHandler->handleConflict($remoteObject, $localObject, $lastLocalObject);

        switch ($solution)
        {
            case ConflictHandlerInterface::USE_LOCAL:

The case body in a switch statement must start on the line following the statement.

                if ($localObject)
                {
                    $mergedIndex->addObject($localObject);
                }

                break;

            case ConflictHandlerInterface::USE_REMOTE:

The case body in a switch statement must start on the line following the statement.

                if ($remoteObject)
                {
                    $mergedIndex->addObject($remoteObject);
                }

                break;

            default:

The default body in a switch statement must start on the line following the statement.

                throw new \LogicException();
        }
    }
}