SiteTreeExtension::addDuplicatedObject() - 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
SiteTreeExtension::addDuplicatedObject() A

↳ Parent: SiteTreeExtension
Complexity

Conditions	4
Paths	4
Size

Total Lines	19
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	4
eloc	9
c	1
b	0
f	0
nc	4
nop	1
dl	0
loc	19
rs	9.9666
<?php

namespace DNADesign\Elemental\TopPage;

use DNADesign\Elemental\Extensions\ElementalPageExtension;
use DNADesign\Elemental\Models\ElementalArea;
use Page;
filter:
    dependency_paths: ["lib/*"]
use SilverStripe\CMS\Model\SiteTreeExtension as BaseSiteTreeExtension;
use SilverStripe\ORM\DataObject;

/**
 * Class SiteTreeExtension
 *
 * This extension is mandatory for any pages that need to support top page functionality
 * it is safe to apply this extension directly to Page as the functionality detects presence of elemental area
 * alternatively, this extension can be applied to top level block page or all block pages individually
 * in case no common parent exists
 *
 * @property Page|$this $owner
 * @package DNADesign\Elemental\TopPage
 */
class SiteTreeExtension extends BaseSiteTreeExtension
{
    /**
     * List of pages currently undergoing duplication
     *
     * @var array
     */
    protected $duplicatedPages = [];

    /**
     * List of objects that need to udate their top page reference
     *
     * @var array
     */
    protected $duplicatedObjects = [];

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

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

    /**
     * Exension point in @see DataObject::duplicate()
     *
     * @param Page $original
     * @param bool $doWrite
     */
    public function onAfterDuplicate(Page $original, $doWrite): void
    {
        $this->processDuplication($original, (bool) $doWrite);
    }

    public function getDuplicationKey(): ?string
    {
        $owner = $this->owner;

        if (!$owner->isInDB()) {
        if (!$owner->/** @scrutinizer ignore-call */ isInDB()) {
            return null;
        }

        return sprintf('%s-%d', $owner->ClassName, $owner->ID);

    }

    /**
     * This is a very roundabout way on how to update top page reference for data objects
     * the main reason why we're doing it like this is the fact that duplication process goes top-down
     * when it comes to model creation, but it goes bottom-up when it comes to writes
     * as a consequence the relations are not available when model is written
     *
     * Instead of updating the page reference during model write, we will simply push the object into a list
     * and update the reference later when page is available
     *
     * note that when going top-down on the relationship tree the models are not written yet so we can't use
     * page IDs as identifiers
     * instead we use IDs of the original objects that we are cloning from
     *
     * Additionally, the duplication process has to support nested pages which makes things more complicated
     * this is handled by using a stack like data structure to keep track on multiple pages
     * each with it's own duplication list
     *
     * @param DataObject $object
     */
    public function addDuplicatedObject(DataObject $object): void
    {
        if (!$object->hasExtension(DataExtension::class)) {
            return;
        }

        $key = $this->getDuplicatedPageKey();

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

        if (array_key_exists($key, $this->duplicatedObjects)) {
            array_unshift($this->duplicatedObjects[$key], $object);

            return;
        }

        $this->duplicatedObjects[$key] = [$object];
    }

    /**
     * Find currently duplicated page
     * note: this doesn't change any stored data
     *
     * @return string|null
     */
    protected function getDuplicatedPageKey(): ?string
    {
        $pages = $this->duplicatedPages;

        if (count($pages) === 0) {
            return null;
        }

        return array_shift($pages);
    }

    /**
     * @param Page|SiteTreeExtension $original
     */
    protected function initDuplication(Page $original): void
    {
        $key = $original->getDuplicationKey();

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

        if (in_array($key, $this->duplicatedPages)) {
            // this should never happen as it would indicate a duplication loop
            return;
        }

        array_unshift($this->duplicatedPages, $key);
    }

    protected function processDuplication(Page $original, bool $written): void
    {
        if ($written) {
            $this->writeDuplication($original);

            return;
        }


        // write may not be triggered as the page maybe have come up via relation
        // in this case we have to delay the processing until the page is written
        // store the origin reference on the object (in memory only) so we can pick it up later
        $this->owner->duplicationOriginal = $original;

    }

    /**
     * Relevant only for duplicated object that were not written at the time of duplication
     */
    protected function processDuplicationFromOriginal(): void
    {
        $owner = $this->owner;

        if (!isset($owner->duplicationOriginal)) {
            return;
        }

        $original = $owner->duplicationOriginal;

        if (!$original instanceof Page) {
            return;
        }

        unset($owner->duplicationOriginal);
        $this->writeDuplication($original);
    }

    /**
     * @param Page|SiteTreeExtension $original
     */
    protected function writeDuplication(Page $original): void
    {
        $key = $original->getDuplicationKey();
        $currentKey = $this->getDuplicatedPageKey();

        if ($key !== $currentKey) {
            // should never happen but it indicates that the nesting hierarchy was incorrect
            return;
        }

        if (array_key_exists($key, $this->duplicatedObjects)) {
            $objects = $this->duplicatedObjects[$key];

            /** @var DataObject|DataExtension $object */
            foreach ($objects as $object) {
                // attach current page ID to the object
                $object->setTopPage($this->owner);
            }
        }

        // mark page as processed
        array_shift($this->duplicatedPages);
    }

    /**
     * Elemental area is created before related page is written so we have to set top page explicitly
     * after page is written and the relations are available
     */
    protected function setTopPageForElementalArea(): void
    {
        /** @var Page|ElementalPageExtension $owner */
        $owner = $this->owner;

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

        if (!$owner->ElementalAreaID) {
            return;
        }

        /** @var ElementalArea|DataExtension $area */
        $area = $owner->ElementalArea();

        if (!$area->exists()) {
        if (!$area->/** @scrutinizer ignore-call */ exists()) {
            return;
        }

        if (!$area->hasExtension(DataExtension::class)) {
        if (!$area->/** @scrutinizer ignore-call */ hasExtension(DataExtension::class)) {
            return;
        }

        $area->setTopPage($owner);
               setTopPage($owner);
    }
}

dnadesign / silverstripe-elemental

Pull Request — master (#774)

SiteTreeExtension::addDuplicatedObject() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
