SilverStripe\Core\Extension

Complexity

Total Complexity

12

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	add_to_class()	0	4	1
B	setOwner()	0	14	5
A	clearOwner()	0	12	3
A	getOwner()	0	4	1
A	get_classname_without_arguments()	0	5	1

<?php

namespace SilverStripe\Core;

use BadMethodCallException;
use SilverStripe\ORM\DataObject;

/**
 * Add extension that can be added to an object with {@link Object::add_extension()}.
 * For {@link DataObject} extensions, use {@link DataExtension}.
 * Each extension instance has an "owner" instance, accessible through
 * {@link getOwner()}.
 * Every object instance gets its own set of extension instances,
 * meaning you can set parameters specific to the "owner instance"
 * in new Extension instances.
 */
abstract class Extension
{
    /**
     * This is used by extensions designed to be applied to controllers.
     * It works the same way as {@link Controller::$allowed_actions}.
     */
    private static $allowed_actions = [];

    /**
     * The object this extension is applied to.
     *
     * @var Object
     */
    protected $owner;

    /**
     * The base class that this extension was applied to; $this->owner must be one of these
     *
     * @var DataObject
     */
    protected $ownerBaseClass;

    /**
     * Ownership stack for recursive methods.
     * Last item is current owner.
     *
     * @var array
     */
    private $ownerStack = [];

    public function __construct()
    {
    }

    /**
     * Called when this extension is added to a particular class
     *
     * @param string $class
     * @param string $extensionClass
     * @param mixed $args
     */
    public static function add_to_class($class, $extensionClass, $args = null)

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

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

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

    {
        // NOP
    }

    /**
     * Set the owner of this extension.
     *
     * @param object $owner The owner object,
     * @param string $ownerBaseClass The base class that the extension is applied to; this may be
     * the class of owner, or it may be a parent.  For example, if Versioned was applied to SiteTree,
     * and then a Page object was instantiated, $owner would be a Page object, but $ownerBaseClass
     * would be 'SiteTree'.
     */
    public function setOwner($owner, $ownerBaseClass = null)
    {
        if ($owner) {
            $this->ownerStack[] = $owner;
        }
        $this->owner = $owner;

        // Set ownerBaseClass
        if ($ownerBaseClass) {

The expression $ownerBaseClass 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.

            $this->ownerBaseClass = $ownerBaseClass;

It seems like $ownerBaseClass of type string is incompatible with the declared type object<SilverStripe\ORM\DataObject> of property $ownerBaseClass.

        } elseif (!$this->ownerBaseClass && $owner) {
            $this->ownerBaseClass = get_class($owner);

It seems like get_class($owner) of type string is incompatible with the declared type object<SilverStripe\ORM\DataObject> of property $ownerBaseClass.

        }
    }

    /**
     * Clear the current owner, and restore extension to the state prior to the last setOwner()
     */
    public function clearOwner()
    {
        if (empty($this->ownerStack)) {
            throw new BadMethodCallException("clearOwner() called more than setOwner()");
        }
        array_pop($this->ownerStack);
        if ($this->ownerStack) {

The expression $this->ownerStack 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.

            $this->owner = end($this->ownerStack);
        } else {
            $this->owner = null;
        }
    }

    /**
     * Returns the owner of this extension.
     *
     * @return Object
     */
    public function getOwner()
    {
        return $this->owner;
    }

    /**
     * Helper method to strip eval'ed arguments from a string
     * that's passed to {@link DataObject::$extensions} or
     * {@link Object::add_extension()}.
     *
     * @param string $extensionStr E.g. "Versioned('Stage','Live')"
     * @return string Extension classname, e.g. "Versioned"
     */
    public static function get_classname_without_arguments($extensionStr)
    {
        $parts = explode('(', $extensionStr);
        return $parts[0];
    }
}