Storeman\Index\Index

Complexity

Total Complexity

28

Size/Duplication

Total Lines	207
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	addObject()	0	23	4
A	getObjectByPath()	0	6	2
A	getObjectByBlobId()	0	14	3
A	equals()	0	9	3
A	isSubsetOf()	0	14	3
A	getDifference()	0	9	1
B	merge()	0	25	5
A	count()	0	4	1
A	getIterator()	0	4	1
A	addDiffTo()	0	16	4

<?php

namespace Storeman\Index;

use Storeman\Exception\Exception;
use Storeman\Index\Diff\IndexDifference;
use Storeman\Index\Diff\IndexObjectDifference;

/**
 * As the name suggests an index is a representation of the vault at some point in time.
 * On iteration the objects are returned sorted by topological order.
 */
class Index implements \Countable, \IteratorAggregate
{
    /**
     * @var IndexNode
     */
    protected $rootNode;

    public function __construct()
    {
        $this->rootNode = new IndexNode();
    }

    /**
     * Adds the given object to the index.
     *
     * @param IndexObject $indexObject
     * @return Index
     * @throws Exception
     */
    public function addObject(IndexObject $indexObject): Index
    {
        $parentNode = $this->rootNode;

        // ensure existence of containing directory
        if (substr_count($indexObject->getRelativePath(), DIRECTORY_SEPARATOR) > 0)
        {
            $parentNode = $this->rootNode->getNodeByPath(dirname($indexObject->getRelativePath()));

            if ($parentNode === null)
            {
                throw new Exception("Trying to add object {$indexObject->getRelativePath()} without existing parent node");
            }
            elseif (!$parentNode->getIndexObject()->isDirectory())
            {
                throw new Exception("Trying to add object {$indexObject->getRelativePath()} under parent node which is not a directory");
            }
        }

        $parentNode->addChild(new IndexNode($indexObject, $parentNode));

        return $this;
    }

    /**
     * Returns an index object by a given relative path.
     *
     * @param string $path
     * @return IndexObject|null
     */
    public function getObjectByPath(string $path): ?IndexObject
    {
        $node = $this->rootNode->getNodeByPath($path);

        return $node ? $node->getIndexObject() : null;
    }

    /**
     * Returns an index object by a given blob id.
     *
     * @param string $blobId
     * @return IndexObject|null
     */
    public function getObjectByBlobId(string $blobId): ?IndexObject
    {
        foreach ($this as $object)
        {
            /** @var IndexObject $object */

            if ($object->getBlobId() === $blobId)
            {
                return $object;
            }
        }

        return null;
    }

    /**
     * Compares this index to the given index and returns the comparison result as boolean indicator.
     *
     * @param Index|null $other
     * @return bool
     */
    public function equals(Index $other = null): bool
    {
        if ($other === null)
        {
            return false;
        }

        return $this->isSubsetOf($other) && $other->isSubsetOf($this);
    }

    /**
     * Returns true if this index is a subset of the given index.
     *
     * @param Index $other
     * @return bool
     */
    public function isSubsetOf(Index $other): bool
    {
        foreach ($this as $indexObject)
        {
            /** @var IndexObject $indexObject */

            if (!$indexObject->equals($other->getObjectByPath($indexObject->getRelativePath())))

It seems like $other->getObjectByPath($indexObject->getRelativePath()) can be null; however, equals() does not accept null, maybe add an additional type check?

            {
                return false;
            }
        }

        return true;
    }

    /**
     * Returns the difference between this and the given index.
     * The resulting difference contains objects from this index that are not present in or different to the
     * corresponding object in the given index and objects from the given index that do not have a correspondence in
     * this index.
     *
     * @param Index $other
     * @return IndexDifference
     */
    public function getDifference(Index $other): IndexDifference
    {
        $diff = new IndexDifference();

        $this->addDiffTo($other, $diff);
        $other->addDiffTo($this, $diff);

        return $diff;
    }

    /**
     * Merges the given index into this index instance.
     * Eventually existing objects with the same path are overridden.
     * The contents of directories under the same path are merged together.
     *
     * @param Index $other
     * @return Index
     */
    public function merge(Index $other): Index
    {
        foreach ($other as $object)
        {
            /** @var IndexObject $object */

            $existingObject = $this->getObjectByPath($object->getRelativePath());

            // merge directory contents
            if ($existingObject && $existingObject->isDirectory() && $object->isDirectory())
            {
                $existingNode = $this->rootNode->getNodeByPath($object->getRelativePath());
                $existingNode->setIndexObject($object);
                $existingNode->addChildren($other->rootNode->getNodeByPath($object->getRelativePath())->getChildren());
            }

            // add object or override existing
            else
            {
                $this->addObject($object);
            }
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function count(): int
    {
        return $this->rootNode->recursiveCount();
    }

    /**
     * {@inheritdoc}
     */
    public function getIterator(): \Traversable
    {
        return new IndexIterator(new RecursiveIndexIterator($this->rootNode));
    }

    /**
     * Returns all those objects in this index that are not existent or are different in the given index.
     *
     * @param Index $other
     * @param IndexDifference $indexDifference
     * @return IndexDifference
     */
    protected function addDiffTo(Index $other, IndexDifference $indexDifference): IndexDifference
    {
        foreach ($this as $object)
        {
            /** @var IndexObject $object */

            $otherObject = $other->getObjectByPath($object->getRelativePath());

            if (!$object->equals($otherObject) && !$indexDifference->hasDifference($object->getRelativePath()))

It seems like $otherObject defined by $other->getObjectByPath($object->getRelativePath()) on line 209 can be null; however, Storeman\Index\IndexObject::equals() does not accept null, maybe add an additional type check?

            {
                $indexDifference->addDifference(new IndexObjectDifference($object, $otherObject));
            }
        }

        return $indexDifference;
    }
}