Arcanedev\LaravelNestedSet\Utilities\TreeHelper

Complexity

Total Complexity

15

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	rebuild()	0	22	4
A	fixNodes()	0	15	2
B	rebuildDictionary()	0	31	5
B	reorderNodes()	0	28	4

<?php namespace Arcanedev\LaravelNestedSet\Utilities;

use Arcanedev\LaravelNestedSet\Contracts\Nodeable;
use Arcanedev\LaravelNestedSet\NodeTrait;
use Illuminate\Database\Eloquent\ModelNotFoundException;

/**
 * Class     TreeHelper
 *
 * @package  Arcanedev\LaravelNestedSet\Utilities
 * @author   ARCANEDEV <arcanedev.maroc@gmail.com>
 */
class TreeHelper
{
    /* ------------------------------------------------------------------------------------------------
     |  Main Functions
     | ------------------------------------------------------------------------------------------------
     */
    /**
     * @param  array                                           $data
     * @param  array                                           $existing
     * @param  \Arcanedev\LaravelNestedSet\Contracts\Nodeable  $model
     * @param  bool                                            $delete
     *
     * @return int
     */
    public static function rebuild(array $data, $existing, Nodeable $model, $delete = false)
    {
        $dictionary = [];

        self::rebuildDictionary($dictionary, $data, $existing, $model);

        if ( ! empty($existing)) {
            if ($delete) {
                $model->newScopedQuery()
                    ->whereIn($model->getKeyName(), array_keys($existing))
                    ->forceDelete();
            }
            else {
                foreach ($existing as $node) {
                    /** @var \Arcanedev\LaravelNestedSet\Contracts\Nodeable $node */
                    $dictionary[$node->getParentId()][] = $node;
                }
            }
        }

        return self::fixNodes($dictionary);
    }

    /**
     * Fix nodes.
     *
     * @param  array  $dictionary
     *
     * @return int
     */
    public static function fixNodes(array &$dictionary)
    {
        $fixed = 0;
        $cut   = self::reorderNodes($dictionary, $fixed);

        // Save nodes that have invalid parent as roots
        while ( ! empty($dictionary)) {
            $dictionary[null] = reset($dictionary);
            unset($dictionary[key($dictionary)]);

            $cut = self::reorderNodes($dictionary, $fixed, null, $cut);
        }

        return $fixed;
    }

    /* ------------------------------------------------------------------------------------------------
     |  Other Functions
     | ------------------------------------------------------------------------------------------------
     */
    /**
     * Rebuild the dictionary.
     *
     * @param  array                                           $dictionary
     * @param  array                                           $data
     * @param  array                                           $existing
     * @param  \Arcanedev\LaravelNestedSet\Contracts\Nodeable  $model
     * @param  mixed                                           $parentId
     *
     * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
     */
    protected static function rebuildDictionary(
        array &$dictionary,
        array $data,
        array &$existing,
        Nodeable &$model,
        $parentId = null
    ) {
        $keyName = $model->getKeyName();

        foreach ($data as $itemData) {
            if ( ! isset($itemData[$keyName])) {
                $node = $model->newInstance();
                // We will save it as raw node since tree will be fixed
                $node->rawNode(0, 0, $parentId);
            }
            elseif ( ! isset($existing[$key = $itemData[$keyName]])) {
                throw new ModelNotFoundException;
            }
            else {
                $node = $existing[$key];
                unset($existing[$key]);
            }

            $node->fill($itemData)->save();
            $dictionary[$parentId][] = $node;

            if (isset($itemData['children'])) {
                self::rebuildDictionary($dictionary, $itemData['children'], $existing, $model, $node->getKey());
            }
        }
    }
    /**
     * Reorder nodes.
     *
     * @param  array     $dictionary
     * @param  int       $fixed
     * @param  int|null  $parentId
     * @param  int       $cut
     *
     * @return int
     */
    protected static function reorderNodes(
        array &$dictionary,
        &$fixed,
        $parentId = null,
        $cut = 1
    ) {
        if ( ! isset($dictionary[$parentId])) {
            return $cut;
        }

        /** @var NodeTrait $model */
        foreach ($dictionary[$parentId] as $model) {
            $lft = $cut;
            $cut = self::reorderNodes($dictionary, $fixed, $model->getKey(), $cut + 1);
            $rgt = $cut;

            if ($model->rawNode($lft, $rgt, $parentId)->isDirty()) {
                $model->save();
                $fixed++;
            }

            ++$cut;
        }

        unset($dictionary[$parentId]);

        return $cut;
    }
}