DataExtension::assignTopPage() - Code Metrics - Inspection of "Top page feature (performance enhancement)" - dnadesign/silverstripe-elemental - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#774)

unknown
created 2020-02-06 20:55 UTC
DataExtension::assignTopPage() A

↳ Parent: DataExtension
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	3
rs	10
<?php

namespace DNADesign\Elemental\TopPage;

use DNADesign\Elemental\Models\BaseElement;
use DNADesign\Elemental\Models\ElementalArea;
use Page;
filter:
    dependency_paths: ["lib/*"]
use SilverStripe\ORM\DataExtension as BaseDataExtension;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\ValidationException;
use SilverStripe\Versioned\Versioned;

/**
 * Class DataExtension
 *
 * Top page data cache for improved performance
 * intended owners of this extension are @see BaseElement and @see ElementalArea
 * applying this extension to just one of these owners will not hinder top page functionality
 * but the performance gain will be smaller
 * it is recommended to apply this extension to BaseElement and for setups with deeper block nesting
 * it is recommended to cover ElementalArea as well
 *
 * @property int $TopPageID
 * @method Page TopPage()
 * @property BaseElement|ElementalArea|$this $owner
 * @package DNADesign\Elemental\TopPage
 */
class DataExtension extends BaseDataExtension
{
    /**
     * @config
     * @var array
     */
    private static $has_one = [

        'TopPage' => Page::class,
    ];

    /**
     * @config
     * @var array
     */
    private static $indexes = [

        'TopPageID' => true,
    ];

    /**
     * @var bool
     */
    private $skipTopPageUpdate = false;

    /**
     * Exension point in @see DataObject::onAfterWrite()
     */
    public function onAfterWrite(): void
    {
        $this->setTopPage();
    }

    /**
     * Exension point in @see DataObject::duplicate()
     */
    public function onBeforeDuplicate(): void
    {
        $this->clearTopPage();
    }

    /**
     * Exension point in @see DataObject::duplicate()
     */
    public function onAfterDuplicate(): void
    {
        $this->updateTopPage();
    }

    /**
     * Find top level page of a block or elemental area
     * this is very useful in case blocks are deeply nested
     *
     * for example:
     * page -> elemental area -> block -> elemental area -> block
     *
     * this lookup is very performant as is safe to use in a template as well
     *
     * @return Page|null
     * @throws ValidationException
     */
    public function getTopPage(): ?Page
    {
        $list = [$this->owner];

        while (count($list) > 0) {
            /** @var DataObject|DataExtension $item */
            $item = array_shift($list);

            if ($item instanceof Page) {
                // trivial case
                return $item;
            }

            if ($item->hasExtension(DataExtension::class) && $item->TopPageID > 0) {
            if ($item->/** @scrutinizer ignore-call */ hasExtension(DataExtension::class) && $item->TopPageID > 0) {
                // top page is stored inside data object - just fetch it via cached call
                $page = Page::get_by_id($item->TopPageID);

                if ($page !== null && $page->exists()) {
                    return $page;
                }
            }

            if ($item instanceof BaseElement) {
                // parent lookup via block
                $parent = $item->Parent();

                if ($parent !== null && $parent->exists()) {
                    array_push($list, $parent);
                }

                continue;
            }

            if ($item instanceof ElementalArea) {
                // parent lookup via elemental area
                $parent = $item->getOwnerPage();

                if ($parent !== null && $parent->exists()) {
                    array_push($list, $parent);
                }

                continue;
            }
        }

        return null;
    }

    /**
     * @param Page|null $page
     * @throws ValidationException
     */
    public function setTopPage(?Page $page = null): void
    {
        if ($this->skipTopPageUpdate) {
            return;
        }

        /** @var BaseElement|ElementalArea|Versioned|DataExtension $owner */
        $owner = $this->owner;

        if (!$owner->hasExtension(DataExtension::class)) {
            return;
        }

        if ($owner->TopPageID > 0) {

            return;
        }

        $page = $page ?? $owner->getTopPage();
        $page = $page ?? $owner->/** @scrutinizer ignore-call */ getTopPage();

        if ($page === null) {
            return;
        }

        // set the page to properties in case this object is re-used later
        $this->assignTopPage($page);

        if ($owner->hasExtension(Versioned::class)) {
            $owner->writeWithoutVersion();
                    writeWithoutVersion();

            return;
        }

        $owner->write();
                write();
    }

    /**
     * Use this to wrap any code which is supposed to run without doing any top page updates
     *
     * @param callable $callback
     * @return mixed
     */
    public function withoutTopPageUpdate(callable $callback)
    {
        $this->skipTopPageUpdate = true;

        try {
            return $callback();
        } finally {
            $this->skipTopPageUpdate = false;
        }
    }

    /**
     * Register the object for top page update
     * this is a little bit roundabout way to do it, but it's necessary because when cloned object is written
     * the relations are not yet written so it's impossible to do a parent lookup at that time
     */
    protected function updateTopPage(): void
    {
        /** @var SiteTreeExtension $extension */
        $extension = singleton(SiteTreeExtension::class);
        $extension->addDuplicatedObject($this->owner);
        $extension->addDuplicatedObject(/** @scrutinizer ignore-type */ $this->owner);
    }

    protected function assignTopPage(Page $page): void
    {
        $this->owner->TopPageID = (int) $page->ID;

    }

    /**
     * Clears top page relation, this is useful when duplicating object as the new object doesn't necessarily
     * belong to the original page
     */
    protected function clearTopPage(): void
    {
        $this->owner->TopPageID = 0;

    }
}

dnadesign / silverstripe-elemental

Pull Request — master (#774)

DataExtension::assignTopPage() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
