SilverStripe\ORM\Hierarchy\Hierarchy

Complexity

Total Complexity

148

Size/Duplication

Total Lines	973
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

40 Methods

Rating	Name	Duplication	Size	Complexity
A	get_extra_config()	0	6	1
C	validate()	0	37	7
D	getChildrenAsUL()	0	98	20
C	markPartialTree()	0	28	7
A	setMarkingFilter()	0	7	1
A	setMarkingFilterFunction()	0	6	1
C	markingFilterMatches()	0	23	9
C	markChildren()	0	35	7
B	markingFinished()	0	11	5
A	markingClasses()	0	17	4
A	markById()	0	12	3
A	markToExpose()	0	9	3
A	markedNodeIDs()	0	4	1
A	parentStack()	0	11	3
A	markExpanded()	0	5	1
A	markUnexpanded()	0	5	1
A	markOpened()	0	5	1
A	markClosed()	0	6	2
A	isMarked()	0	6	2
A	isExpanded()	0	6	2
A	isTreeOpened()	0	6	2
A	getDescendantIDList()	0	6	1
A	loadDescendantIDListInto()	0	16	4
B	Children()	0	14	5
A	AllChildren()	0	4	1
A	AllChildrenIncludingDeleted()	0	4	1
B	doAllChildrenIncludingDeleted()	0	32	5
A	AllHistoricalChildren()	0	14	2
A	numHistoricalChildren()	0	8	2
A	numChildren()	0	12	3
A	showingCMSTree()	0	9	3
B	stageChildren()	0	20	6
C	liveChildren()	0	28	8
A	getParent()	0	12	2
A	getAncestors()	0	11	2
A	getBreadcrumbs()	0	10	2
A	naturalPrev()	0	4	1
C	naturalNext()	0	44	15
A	flushCache()	0	8	1
A	reset()	0	6	1

<?php

namespace SilverStripe\ORM\Hierarchy;

use SilverStripe\Admin\LeftAndMain;
use SilverStripe\CMS\Model\SiteTree;
use SilverStripe\Core\Config\Config;
use SilverStripe\Control\Controller;
use SilverStripe\Core\Resettable;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\ValidationResult;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\DataExtension;
use SilverStripe\ORM\Versioning\Versioned;
use Exception;

/**
 * DataObjects that use the Hierarchy extension can be be organised as a hierarchy, with children and parents. The most
 * obvious example of this is SiteTree.
 *
 * @property int $ParentID
 * @property DataObject $owner
 * @method DataObject Parent()
 */
class Hierarchy extends DataExtension implements Resettable
{

    protected $markedNodes;

    protected $markingFilter;

    /** @var int */
    protected $_cache_numChildren;

    /**
     * The lower bounds for the amount of nodes to mark. If set, the logic will expand nodes until it reaches at least
     * this number, and then stops. Root nodes will always show regardless of this settting. Further nodes can be
     * lazy-loaded via ajax. This isn't a hard limit. Example: On a value of 10, with 20 root nodes, each having 30
     * children, the actual node count will be 50 (all root nodes plus first expanded child).
     *
     * @config
     * @var int
     */
    private static $node_threshold_total = 50;

    /**
     * Limit on the maximum children a specific node can display. Serves as a hard limit to avoid exceeding available
     * server resources in generating the tree, and browser resources in rendering it. Nodes with children exceeding
     * this value typically won't display any children, although this is configurable through the $nodeCountCallback
     * parameter in {@link getChildrenAsUL()}. "Root" nodes will always show all children, regardless of this setting.
     *
     * @config
     * @var int
     */
    private static $node_threshold_leaf = 250;

    /**
     * A list of classnames to exclude from display in both the CMS and front end
     * displays. ->Children() and ->AllChildren affected.
     * Especially useful for big sets of pages like listings
     * If you use this, and still need the classes to be editable
     * then add a model admin for the class
     * Note: Does not filter subclasses (non-inheriting)
     *
     * @var array
     * @config
     */
    private static $hide_from_hierarchy = array();

    /**
     * A list of classnames to exclude from display in the page tree views of the CMS,
     * unlike $hide_from_hierarchy above which effects both CMS and front end.
     * Especially useful for big sets of pages like listings
     * If you use this, and still need the classes to be editable
     * then add a model admin for the class
     * Note: Does not filter subclasses (non-inheriting)
     *
     * @var array
     * @config
     */
    private static $hide_from_cms_tree = array();

    public static function get_extra_config($class, $extension, $args)

The parameter $extension is not used and could be removed.

The parameter $args is not used and could be removed.

    {
        return array(
            'has_one' => array('Parent' => $class)
        );
    }

    /**
     * Validate the owner object - check for existence of infinite loops.
     *
     * @param ValidationResult $validationResult
     */
    public function validate(ValidationResult $validationResult)
    {
        // The object is new, won't be looping.
        if (!$this->owner->ID) {
            return;
        }
        // The object has no parent, won't be looping.
        if (!$this->owner->ParentID) {
            return;
        }
        // The parent has not changed, skip the check for performance reasons.
        if (!$this->owner->isChanged('ParentID')) {
            return;
        }

        // Walk the hierarchy upwards until we reach the top, or until we reach the originating node again.
        $node = $this->owner;
        while ($node) {
            if ($node->ParentID==$this->owner->ID) {
                // Hierarchy is looping.
                $validationResult->addError(
                    _t(
                        'Hierarchy.InfiniteLoopNotAllowed',
                        'Infinite loop found within the "{type}" hierarchy. Please change the parent to resolve this',
                        'First argument is the class that makes up the hierarchy.',
                        array('type' => $this->owner->class)
                    ),
                    'bad',
                    'INFINITE_LOOP'
                );
                break;
            }
            $node = $node->ParentID ? $node->Parent() : null;
        }

        // At this point the $validationResult contains the response.
    }

    /**
     * Returns the children of this DataObject as an XHTML UL. This will be called recursively on each child, so if they
     * have children they will be displayed as a UL inside a LI.
     *
     * @param string $attributes Attributes to add to the UL
     * @param string|callable $titleEval PHP code to evaluate to start each child - this should include '<li>'
     * @param string $extraArg Extra arguments that will be passed on to children, for if they overload this function
     * @param bool $limitToMarked Display only marked children
     * @param string $childrenMethod The name of the method used to get children from each object
     * @param string $numChildrenMethod
     * @param bool $rootCall Set to true for this first call, and then to false for calls inside the recursion.
     * You should not change this.
     * @param int $nodeCountThreshold See {@link self::$node_threshold_total}
     * @param callable $nodeCountCallback Called with the node count, which gives the callback an opportunity to
     * intercept the query. Useful e.g. to avoid excessive children listings (Arguments: $parent, $numChildren)
     * @return string
     */
    public function getChildrenAsUL(
        $attributes = "",
        $titleEval = '"<li>" . $child->Title',
        $extraArg = null,
        $limitToMarked = false,
        $childrenMethod = "AllChildrenIncludingDeleted",
        $numChildrenMethod = "numChildren",
        $rootCall = true,
        $nodeCountThreshold = null,
        $nodeCountCallback = null
    ) {
        if (!is_numeric($nodeCountThreshold)) {
            $nodeCountThreshold = Config::inst()->get(__CLASS__, 'node_threshold_total');
        }

        if ($limitToMarked && $rootCall) {
            $this->markingFinished($numChildrenMethod);
        }


        if ($nodeCountCallback) {
            $nodeCountWarning = $nodeCountCallback($this->owner, $this->owner->$numChildrenMethod());
            if ($nodeCountWarning) {
                return $nodeCountWarning;
            }
        }


        if ($this->owner->hasMethod($childrenMethod)) {
            $children = $this->owner->$childrenMethod($extraArg);
        } else {
            $children = null;
            user_error(sprintf(
                "Can't find the method '%s' on class '%s' for getting tree children",
                $childrenMethod,
                get_class($this->owner)
            ), E_USER_ERROR);
        }

        $output = null;
        if ($children) {
            if ($attributes) {
                $attributes = " $attributes";
            }

            $output = "<ul$attributes>\n";

            foreach ($children as $child) {
                if (!$limitToMarked || $child->isMarked()) {
                    $foundAChild = true;
                    if (is_callable($titleEval)) {
                        $output .= $titleEval($child, $numChildrenMethod);
                    } else {
                        $output .= eval("return $titleEval;");

It is generally not recommended to use eval unless absolutely required.

                    }
                    $output .= "\n";

                    $numChildren = $child->$numChildrenMethod();

                    if (// Always traverse into opened nodes (they might be exposed as parents of search results)
                        $child->isExpanded()
                        // Only traverse into children if we haven't reached the maximum node count already.
                        // Otherwise, the remaining nodes are lazy loaded via ajax.
                        && $child->isMarked()
                    ) {
                        // Additionally check if node count requirements are met
                        $nodeCountWarning = $nodeCountCallback ? $nodeCountCallback($child, $numChildren) : null;
                        if ($nodeCountWarning) {
                            $output .= $nodeCountWarning;
                            $child->markClosed();
                        } else {
                            $output .= $child->getChildrenAsUL(
                                "",
                                $titleEval,
                                $extraArg,
                                $limitToMarked,
                                $childrenMethod,
                                $numChildrenMethod,
                                false,
                                $nodeCountThreshold
                            );
                        }
                    } elseif ($child->isTreeOpened()) {
                        // Since we're not loading children, don't mark it as open either
                        $child->markClosed();
                    }
                    $output .= "</li>\n";
                }
            }

            $output .= "</ul>\n";
        }

        if (isset($foundAChild) && $foundAChild) {
            return $output;
        }
        return null;
    }

    /**
     * Mark a segment of the tree, by calling mark().
     *
     * The method performs a breadth-first traversal until the number of nodes is more than minCount. This is used to
     * get a limited number of tree nodes to show in the CMS initially.
     *
     * This method returns the number of nodes marked.  After this method is called other methods can check
     * {@link isExpanded()} and {@link isMarked()} on individual nodes.
     *
     * @param int $nodeCountThreshold See {@link getChildrenAsUL()}
     * @param mixed $context
     * @param string $childrenMethod
     * @param string $numChildrenMethod
     * @return int The actual number of nodes marked.
     */
    public function markPartialTree(
        $nodeCountThreshold = 30,
        $context = null,
        $childrenMethod = "AllChildrenIncludingDeleted",
        $numChildrenMethod = "numChildren"
    ) {
        if (!is_numeric($nodeCountThreshold)) {
            $nodeCountThreshold = 30;
        }

        $this->markedNodes = array($this->owner->ID => $this->owner);
        $this->owner->markUnexpanded();

        // foreach can't handle an ever-growing $nodes list
        while (list($id, $node) = each($this->markedNodes)) {

The assignment to $id is unused. Consider omitting it like so list($first,,$third).

            $children = $this->markChildren($node, $context, $childrenMethod, $numChildrenMethod);
            if ($nodeCountThreshold && sizeof($this->markedNodes) > $nodeCountThreshold) {
                // Undo marking children as opened since they're lazy loaded
                if ($children) {
                    foreach ($children as $child) {
                        $child->markClosed();
                    }
                }
                break;
            }
        }
        return sizeof($this->markedNodes);
    }

    /**
     * Filter the marking to only those object with $node->$parameterName == $parameterValue
     *
     * @param string $parameterName  The parameter on each node to check when marking.
     * @param mixed  $parameterValue The value the parameter must be to be marked.
     */
    public function setMarkingFilter($parameterName, $parameterValue)
    {
        $this->markingFilter = array(
            "parameter" => $parameterName,
            "value" => $parameterValue
        );
    }

    /**
     * Filter the marking to only those where the function returns true. The node in question will be passed to the
     * function.
     *
     * @param string $funcName The name of the function to call
     */
    public function setMarkingFilterFunction($funcName)
    {
        $this->markingFilter = array(
            "func" => $funcName,
        );
    }

    /**
     * Returns true if the marking filter matches on the given node.
     *
     * @param DataObject $node Node to check
     * @return bool
     */
    public function markingFilterMatches($node)
    {
        if (!$this->markingFilter) {

The expression $this->markingFilter of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return true;
        }

        if (isset($this->markingFilter['parameter']) && $parameterName = $this->markingFilter['parameter']) {
            if (is_array($this->markingFilter['value'])) {
                $ret = false;
                foreach ($this->markingFilter['value'] as $value) {
                    $ret = $ret||$node->$parameterName==$value;
                    if ($ret == true) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

                        break;
                    }
                }
                return $ret;
            } else {
                return ($node->$parameterName == $this->markingFilter['value']);
            }
        } elseif ($func = $this->markingFilter['func']) {
            return call_user_func($func, $node);
        }
    }

    /**
     * Mark all children of the given node that match the marking filter.
     *
     * @param DataObject $node              Parent node
     * @param mixed      $context
     * @param string     $childrenMethod    The name of the instance method to call to get the object's list of children
     * @param string     $numChildrenMethod The name of the instance method to call to count the object's children
     * @return DataList
     */
    public function markChildren(
        $node,
        $context = null,
        $childrenMethod = "AllChildrenIncludingDeleted",
        $numChildrenMethod = "numChildren"
    ) {
        if ($node->hasMethod($childrenMethod)) {
            $children = $node->$childrenMethod($context);
        } else {
            $children = null;
            user_error(sprintf(
                "Can't find the method '%s' on class '%s' for getting tree children",
                $childrenMethod,
                get_class($node)
            ), E_USER_ERROR);
        }

        $node->markExpanded();
        if ($children) {
            foreach ($children as $child) {
                $markingMatches = $this->markingFilterMatches($child);
                if ($markingMatches) {
                    // Mark a child node as unexpanded if it has children and has not already been expanded
                    if ($child->$numChildrenMethod() && !$child->isExpanded()) {
                        $child->markUnexpanded();
                    } else {
                        $child->markExpanded();
                    }
                    $this->markedNodes[$child->ID] = $child;
                }
            }
        }

        return $children;
    }

    /**
     * Ensure marked nodes that have children are also marked expanded. Call this after marking but before iterating
     * over the tree.
     *
     * @param string $numChildrenMethod The name of the instance method to call to count the object's children
     */
    protected function markingFinished($numChildrenMethod = "numChildren")
    {
        // Mark childless nodes as expanded.
        if ($this->markedNodes) {

The expression $this->markedNodes of type SilverStripe\ORM\DataObject[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($this->markedNodes as $id => $node) {
                if (!$node->isExpanded() && !$node->$numChildrenMethod()) {
                    $node->markExpanded();
                }
            }
        }
    }

    /**
     * Return CSS classes of 'unexpanded', 'closed', both, or neither, as well as a 'jstree-*' state depending on the
     * marking of this DataObject.
     *
     * @param string $numChildrenMethod The name of the instance method to call to count the object's children
     * @return string
     */
    public function markingClasses($numChildrenMethod = "numChildren")
    {
        $classes = '';
        if (!$this->isExpanded()) {
            $classes .= " unexpanded";
        }

        // Set jstree open state, or mark it as a leaf (closed) if there are no children
        if (!$this->owner->$numChildrenMethod()) {
            $classes .= " jstree-leaf closed";
        } elseif ($this->isTreeOpened()) {
            $classes .= " jstree-open";
        } else {
            $classes .= " jstree-closed closed";
        }
        return $classes;
    }

    /**
     * Mark the children of the DataObject with the given ID.
     *
     * @param int  $id   ID of parent node
     * @param bool $open If this is true, mark the parent node as opened
     * @return bool
     */
    public function markById($id, $open = false)
    {
        if (isset($this->markedNodes[$id])) {
            $this->markChildren($this->markedNodes[$id]);
            if ($open) {
                $this->markedNodes[$id]->markOpened();
            }
            return true;
        } else {
            return false;
        }
    }

    /**
     * Expose the given object in the tree, by marking this page and all it ancestors.
     *
     * @param DataObject $childObj
     */
    public function markToExpose($childObj)
    {
        if (is_object($childObj)) {
            $stack = array_reverse($childObj->parentStack());
            foreach ($stack as $stackItem) {
                $this->markById($stackItem->ID, true);
            }
        }
    }

    /**
     * Return the IDs of all the marked nodes.
     *
     * @return array
     */
    public function markedNodeIDs()
    {
        return array_keys($this->markedNodes);
    }

    /**
     * Return an array of this page and its ancestors, ordered item -> root.
     *
     * @return SiteTree[]
     */
    public function parentStack()
    {
        $p = $this->owner;

        while ($p) {
            $stack[] = $p;

$stack was never initialized. Although not strictly required by PHP, it is generally a good practice to add $stack = array(); before regardless.

            $p = $p->ParentID ? $p->Parent() : null;
        }

        return $stack;

The variable $stack does not seem to be defined for all execution paths leading up to this point.

    }

    /**
     * Cache of DataObjects' marked statuses: [ClassName][ID] = bool
     * @var array
     */
    protected static $marked = array();

    /**
     * Cache of DataObjects' expanded statuses: [ClassName][ID] = bool
     * @var array
     */
    protected static $expanded = array();

    /**
     * Cache of DataObjects' opened statuses: [ClassName][ID] = bool
     * @var array
     */
    protected static $treeOpened = array();

    /**
     * Mark this DataObject as expanded.
     */
    public function markExpanded()
    {
        self::$marked[$this->owner->baseClass()][$this->owner->ID] = true;
        self::$expanded[$this->owner->baseClass()][$this->owner->ID] = true;
    }

    /**
     * Mark this DataObject as unexpanded.
     */
    public function markUnexpanded()
    {
        self::$marked[$this->owner->baseClass()][$this->owner->ID] = true;
        self::$expanded[$this->owner->baseClass()][$this->owner->ID] = false;
    }

    /**
     * Mark this DataObject's tree as opened.
     */
    public function markOpened()
    {
        self::$marked[$this->owner->baseClass()][$this->owner->ID] = true;
        self::$treeOpened[$this->owner->baseClass()][$this->owner->ID] = true;
    }

    /**
     * Mark this DataObject's tree as closed.
     */
    public function markClosed()
    {
        if (isset(self::$treeOpened[$this->owner->baseClass()][$this->owner->ID])) {
            unset(self::$treeOpened[$this->owner->baseClass()][$this->owner->ID]);
        }
    }

    /**
     * Check if this DataObject is marked.
     *
     * @return bool
     */
    public function isMarked()
    {
        $baseClass = $this->owner->baseClass();
        $id = $this->owner->ID;
        return isset(self::$marked[$baseClass][$id]) ? self::$marked[$baseClass][$id] : false;
    }

    /**
     * Check if this DataObject is expanded.
     *
     * @return bool
     */
    public function isExpanded()
    {
        $baseClass = $this->owner->baseClass();
        $id = $this->owner->ID;
        return isset(self::$expanded[$baseClass][$id]) ? self::$expanded[$baseClass][$id] : false;
    }

    /**
     * Check if this DataObject's tree is opened.
     *
     * @return bool
     */
    public function isTreeOpened()
    {
        $baseClass = $this->owner->baseClass();
        $id = $this->owner->ID;
        return isset(self::$treeOpened[$baseClass][$id]) ? self::$treeOpened[$baseClass][$id] : false;
    }

    /**
     * Get a list of this DataObject's and all it's descendants IDs.
     *
     * @return int[]
     */
    public function getDescendantIDList()
    {
        $idList = array();
        $this->loadDescendantIDListInto($idList);
        return $idList;
    }

    /**
     * Get a list of this DataObject's and all it's descendants ID, and put them in $idList.
     *
     * @param array $idList Array to put results in.
     */
    public function loadDescendantIDListInto(&$idList)
    {
        if ($children = $this->AllChildren()) {
            foreach ($children as $child) {
                if (in_array($child->ID, $idList)) {
                    continue;
                }
                $idList[] = $child->ID;
                /** @var Hierarchy $ext */
                $ext = $child->getExtensionInstance('SilverStripe\ORM\Hierarchy\Hierarchy');
                $ext->setOwner($child);
                $ext->loadDescendantIDListInto($idList);
                $ext->clearOwner();
            }
        }
    }

    /**
     * Get the children for this DataObject.
     *
     * @return DataList
     */
    public function Children()
    {
        if (!(isset($this->_cache_children) && $this->_cache_children)) {
            $result = $this->owner->stageChildren(false);
            $children = array();
            foreach ($result as $record) {
                if ($record->canView()) {
                    $children[] = $record;
                }
            }
            $this->_cache_children = new ArrayList($children);

The property _cache_children does not exist. Did you maybe forget to declare it?

        }
        return $this->_cache_children;
    }

    /**
     * Return all children, including those 'not in menus'.
     *
     * @return DataList
     */
    public function AllChildren()
    {
        return $this->owner->stageChildren(true);
    }

    /**
     * Return all children, including those that have been deleted but are still in live.
     * - Deleted children will be marked as "DeletedFromStage"
     * - Added children will be marked as "AddedToStage"
     * - Modified children will be marked as "ModifiedOnStage"
     * - Everything else has "SameOnStage" set, as an indicator that this information has been looked up.
     *
     * @param mixed $context
     * @return ArrayList
     */
    public function AllChildrenIncludingDeleted($context = null)
    {
        return $this->doAllChildrenIncludingDeleted($context);
    }

    /**
     * @see AllChildrenIncludingDeleted
     *
     * @param mixed $context
     * @return ArrayList
     */
    public function doAllChildrenIncludingDeleted($context = null)
    {
        if (!$this->owner) {
            user_error('Hierarchy::doAllChildrenIncludingDeleted() called without $this->owner');
        }

        $baseClass = $this->owner->baseClass();
        if ($baseClass) {
            $stageChildren = $this->owner->stageChildren(true);

            // Add live site content that doesn't exist on the stage site, if required.
            if ($this->owner->hasExtension('SilverStripe\ORM\Versioning\Versioned')) {
                // Next, go through the live children.  Only some of these will be listed
                $liveChildren = $this->owner->liveChildren(true, true);
                if ($liveChildren) {
                    $merged = new ArrayList();
                    $merged->merge($stageChildren);
                    $merged->merge($liveChildren);
                    $stageChildren = $merged;
                }
            }

            $this->owner->extend("augmentAllChildrenIncludingDeleted", $stageChildren, $context);
        } else {
            user_error(
                "Hierarchy::AllChildren() Couldn't determine base class for '{$this->owner->class}'",
                E_USER_ERROR
            );
        }

        return $stageChildren;

The variable $stageChildren does not seem to be defined for all execution paths leading up to this point.

    }

    /**
     * Return all the children that this page had, including pages that were deleted from both stage & live.
     *
     * @return DataList
     * @throws Exception
     */
    public function AllHistoricalChildren()
    {
        if (!$this->owner->hasExtension('SilverStripe\ORM\Versioning\Versioned')) {
            throw new Exception('Hierarchy->AllHistoricalChildren() only works with Versioned extension applied');
        }

        $baseTable = $this->owner->baseTable();
        $parentIDColumn = $this->owner->getSchema()->sqlColumnForField($this->owner, 'ParentID');
        return Versioned::get_including_deleted(
            $this->owner->baseClass(),
            [ $parentIDColumn => $this->owner->ID ],
            "\"{$baseTable}\".\"ID\" ASC"
        );
    }

    /**
     * Return the number of children that this page ever had, including pages that were deleted.
     *
     * @return int
     * @throws Exception
     */
    public function numHistoricalChildren()
    {
        if (!$this->owner->hasExtension('SilverStripe\ORM\Versioning\Versioned')) {
            throw new Exception('Hierarchy->AllHistoricalChildren() only works with Versioned extension applied');
        }

        return $this->AllHistoricalChildren()->count();
    }

    /**
     * Return the number of direct children. By default, values are cached after the first invocation. Can be
     * augumented by {@link augmentNumChildrenCountQuery()}.
     *
     * @param bool $cache Whether to retrieve values from cache
     * @return int
     */
    public function numChildren($cache = true)
    {
        // Build the cache for this class if it doesn't exist.
        if (!$cache || !is_numeric($this->_cache_numChildren)) {
            // Hey, this is efficient now!
            // We call stageChildren(), because Children() has canView() filtering
            $this->_cache_numChildren = (int)$this->owner->stageChildren(true)->Count();
        }

        // If theres no value in the cache, it just means that it doesn't have any children.
        return $this->_cache_numChildren;
    }

    /**
     * Checks if we're on a controller where we should filter. ie. Are we loading the SiteTree?
     *
     * @return bool
     */
    public function showingCMSTree()
    {
        if (!Controller::has_curr()) {
            return false;
        }
        $controller = Controller::curr();
        return $controller instanceof LeftAndMain
            && in_array($controller->getAction(), array("treeview", "listview", "getsubtree"));
    }

    /**
     * Return children in the stage site.
     *
     * @param bool $showAll Include all of the elements, even those not shown in the menus. Only applicable when
     *                      extension is applied to {@link SiteTree}.
     * @return DataList
     */
    public function stageChildren($showAll = false)
    {
        $baseClass = $this->owner->baseClass();
        $hide_from_hierarchy = $this->owner->config()->hide_from_hierarchy;

The property hide_from_hierarchy does not exist on object<SilverStripe\Core\Config\Config_ForClass>. Since you implemented __set, maybe consider adding a @property annotation.

        $hide_from_cms_tree = $this->owner->config()->hide_from_cms_tree;

The property hide_from_cms_tree does not exist on object<SilverStripe\Core\Config\Config_ForClass>. Since you implemented __set, maybe consider adding a @property annotation.

        $staged = $baseClass::get()
                ->filter('ParentID', (int)$this->owner->ID)
                ->exclude('ID', (int)$this->owner->ID);
        if ($hide_from_hierarchy) {
            $staged = $staged->exclude('ClassName', $hide_from_hierarchy);
        }
        if ($hide_from_cms_tree && $this->showingCMSTree()) {
            $staged = $staged->exclude('ClassName', $hide_from_cms_tree);
        }
        if (!$showAll && DataObject::getSchema()->fieldSpec($this->owner, 'ShowInMenus')) {

The expression \SilverStripe\ORM\DataObject::getSchema()->fieldSpec($this->owner, 'ShowInMenus') of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $staged = $staged->filter('ShowInMenus', 1);
        }
        $this->owner->extend("augmentStageChildren", $staged, $showAll);
        return $staged;
    }

    /**
     * Return children in the live site, if it exists.
     *
     * @param bool $showAll              Include all of the elements, even those not shown in the menus. Only
     *                                   applicable when extension is applied to {@link SiteTree}.
     * @param bool $onlyDeletedFromStage Only return items that have been deleted from stage
     * @return DataList
     * @throws Exception
     */
    public function liveChildren($showAll = false, $onlyDeletedFromStage = false)
    {
        if (!$this->owner->hasExtension(Versioned::class)) {
            throw new Exception('Hierarchy->liveChildren() only works with Versioned extension applied');
        }

        $baseClass = $this->owner->baseClass();
        $hide_from_hierarchy = $this->owner->config()->hide_from_hierarchy;

The property hide_from_hierarchy does not exist on object<SilverStripe\Core\Config\Config_ForClass>. Since you implemented __set, maybe consider adding a @property annotation.

        $hide_from_cms_tree = $this->owner->config()->hide_from_cms_tree;

The property hide_from_cms_tree does not exist on object<SilverStripe\Core\Config\Config_ForClass>. Since you implemented __set, maybe consider adding a @property annotation.

        $children = $baseClass::get()
            ->filter('ParentID', (int)$this->owner->ID)
            ->exclude('ID', (int)$this->owner->ID)
            ->setDataQueryParam(array(
                'Versioned.mode' => $onlyDeletedFromStage ? 'stage_unique' : 'stage',
                'Versioned.stage' => 'Live'
            ));
        if ($hide_from_hierarchy) {
            $children = $children->exclude('ClassName', $hide_from_hierarchy);
        }
        if ($hide_from_cms_tree && $this->showingCMSTree()) {
            $children = $children->exclude('ClassName', $hide_from_cms_tree);
        }
        if (!$showAll && DataObject::getSchema()->fieldSpec($this->owner, 'ShowInMenus')) {

The expression \SilverStripe\ORM\DataObject::getSchema()->fieldSpec($this->owner, 'ShowInMenus') of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $children = $children->filter('ShowInMenus', 1);
        }

        return $children;
    }

    /**
     * Get this object's parent, optionally filtered by an SQL clause. If the clause doesn't match the parent, nothing
     * is returned.
     *
     * @param string $filter
     * @return DataObject
     */
    public function getParent($filter = null)
    {
        $parentID = $this->owner->ParentID;

The property ParentID does not exist on object<SilverStripe\ORM\DataObject>. Since you implemented __set, maybe consider adding a @property annotation.

        if (empty($parentID)) {
            return null;
        }
        $idSQL = $this->owner->getSchema()->sqlColumnForField($this->owner, 'ID');
        return DataObject::get_one($this->owner->class, array(
            array($idSQL => $parentID),
            $filter
        ));
    }

    /**
     * Return all the parents of this class in a set ordered from the lowest to highest parent.
     *
     * @return ArrayList
     */
    public function getAncestors()
    {
        $ancestors = new ArrayList();
        $object    = $this->owner;

        while ($object = $object->getParent()) {
            $ancestors->push($object);
        }

        return $ancestors;
    }

    /**
     * Returns a human-readable, flattened representation of the path to the object, using its {@link Title} attribute.
     *
     * @param string $separator
     * @return string
     */
    public function getBreadcrumbs($separator = ' » ')
    {
        $crumbs = array();
        $ancestors = array_reverse($this->owner->getAncestors()->toArray());
        foreach ($ancestors as $ancestor) {
            $crumbs[] = $ancestor->Title;
        }
        $crumbs[] = $this->owner->Title;

The property Title does not exist on object<SilverStripe\ORM\DataObject>. Since you implemented __set, maybe consider adding a @property annotation.

        return implode($separator, $crumbs);
    }

    /**
     * Get the next node in the tree of the type. If there is no instance of the className descended from this node,
     * then search the parents.
     *
     * @todo Write!
     *
     * @param string     $className Class name of the node to find
     * @param DataObject $afterNode Used for recursive calls to this function
     * @return DataObject
     */
    public function naturalPrev($className, $afterNode = null)

The parameter $className is not used and could be removed.

The parameter $afterNode is not used and could be removed.

    {
        return null;
    }

    /**
     * Get the next node in the tree of the type. If there is no instance of the className descended from this node,
     * then search the parents.
     * @param string     $className Class name of the node to find.
     * @param string|int $root      ID/ClassName of the node to limit the search to
     * @param DataObject $afterNode Used for recursive calls to this function
     * @return DataObject
     */
    public function naturalNext($className = null, $root = 0, $afterNode = null)
    {
        // If this node is not the node we are searching from, then we can possibly return this node as a solution
        if ($afterNode && $afterNode->ID != $this->owner->ID) {
            if (!$className || ($className && $this->owner->class == $className)) {

The expression $className of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

                return $this->owner;
            }
        }

        $nextNode = null;
        $baseClass = $this->owner->baseClass();

        $children = $baseClass::get()
            ->filter('ParentID', (int)$this->owner->ID)
            ->sort('"Sort"', 'ASC');
        if ($afterNode) {
            $children = $children->filter('Sort:GreaterThan', $afterNode->Sort);
        }

        // Try all the siblings of this node after the given node
        /*if( $siblings = DataObject::get( $this->owner->baseClass(),

53% of this comment could be valid code. Did you maybe forget this after debugging?

		"\"ParentID\"={$this->owner->ParentID}" . ( $afterNode ) ? "\"Sort\"
		> {$afterNode->Sort}" : "" , '\"Sort\" ASC' ) ) $searchNodes->merge( $siblings );*/

        if ($children) {
            foreach ($children as $node) {
                if ($nextNode = $node->naturalNext($className, $node->ID, $this->owner)) {
                    break;
                }
            }

            if ($nextNode) {
                return $nextNode;
            }
        }

        // if this is not an instance of the root class or has the root id, search the parent
        if (!(is_numeric($root) && $root == $this->owner->ID || $root == $this->owner->class)
                && ($parent = $this->owner->Parent())) {

The method Parent() does not exist on SilverStripe\ORM\DataObject. Did you maybe mean parentClass()?

            return $parent->naturalNext($className, $root, $this->owner);
        }

        return null;
    }

    /**
     * Flush all Hierarchy caches:
     * - Children (instance)
     * - NumChildren (instance)
     * - Marked (global)
     * - Expanded (global)
     * - TreeOpened (global)
     */
    public function flushCache()
    {
        $this->_cache_children = null;
        $this->_cache_numChildren = null;
        self::$marked = array();
        self::$expanded = array();
        self::$treeOpened = array();
    }

    /**
     * Reset global Hierarchy caches:
     * - Marked
     * - Expanded
     * - TreeOpened
     */
    public static function reset()
    {
        self::$marked = array();
        self::$expanded = array();
        self::$treeOpened = array();
    }
}