Storeman\Index\Index

Complexity

Total Complexity

33

Size/Duplication

Total Lines	241
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	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
A	getIntersection()	0	18	3
A	merge()	0	25	5
A	count()	0	4	1
A	getIterator()	0	4	1
A	addDiffTo()	0	19	6

<?php

namespace Storeman\Index;

use Storeman\Exception;
use Storeman\Index\Comparison\IndexComparison;
use Storeman\Index\Comparison\IndexObjectComparison;

/**
 * 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(), '/') > 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
     * @param int $options
     * @return bool
     */
    public function equals(Index $other = null, int $options = 0): bool
    {
        if ($other === null)
        {
            return false;
        }

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

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

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

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
     * @param int $options
     * @return IndexComparison
     */
    public function getDifference(Index $other, int $options = 0): IndexComparison
    {
        $diff = new IndexComparison();

        $this->addDiffTo($other, $diff, $options, false);
        $other->addDiffTo($this, $diff, $options, true);

        return $diff;
    }

    /**
     * Returns the intersection of this and the given index.
     *
     * @param Index $other
     * @param int $options
     * @return IndexComparison
     */
    public function getIntersection(Index $other, int $options = 0): IndexComparison
    {
        $intersection = new IndexComparison();

        foreach ($this as $object)
        {
            /** @var IndexObject $object */

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

            if ($object->equals($otherObject, $options))

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

            {
                $intersection->addObjectComparison(new IndexObjectComparison($object, $otherObject));
            }
        }

        return $intersection;
    }

    /**
     * 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 IndexComparison $indexDifference
     * @param int $options
     * @param bool $flipped
     * @return IndexComparison
     */
    protected function addDiffTo(Index $other, IndexComparison $indexDifference, int $options, bool $flipped): IndexComparison
    {
        foreach ($this as $object)
        {
            /** @var IndexObject $object */

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

            if (!$object->equals($otherObject, $options) && !$indexDifference->hasObjectComparison($object->getRelativePath()))

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

            {
                $objectA = $flipped ? $otherObject : $object;
                $objectB = $flipped ? $object : $otherObject;

                $indexDifference->addObjectComparison(new IndexObjectComparison($objectA, $objectB));
            }
        }

        return $indexDifference;
    }
}