ChangeSetItem::hasChange() - Code Metrics - Inspection of "Merge pull request #6420 from open-sausages/pulls/..." - silverstripe/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( b0e0e9...f4bf0c )

by Will
created 2016-12-21 20:24 UTC
ChangeSetItem::hasChange() A

↳ Parent: ChangeSetItem
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0
<?php

namespace SilverStripe\ORM\Versioning;

use SilverStripe\Admin\CMSPreviewable;
use SilverStripe\Assets\Thumbnail;
use SilverStripe\Control\Controller;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\ManyManyList;
use SilverStripe\ORM\SS_List;
use SilverStripe\ORM\UnexpectedDataException;
use SilverStripe\Security\Member;
use SilverStripe\Security\Permission;
use BadMethodCallException;
use Exception;

/**
 * A single line in a changeset
 *
 * @property string $Added
 * @property string $ObjectClass The _base_ data class for the referenced DataObject
 * @property int $ObjectID The numeric ID for the referenced object
 * @method ManyManyList ReferencedBy() List of explicit items that require this change
 * @method ManyManyList References() List of implicit items required by this change
 * @method ChangeSet ChangeSet()
 */
class ChangeSetItem extends DataObject implements Thumbnail
{

    const EXPLICITLY = 'explicitly';

    const IMPLICITLY = 'implicitly';

    /** Represents an object deleted */
    const CHANGE_DELETED = 'deleted';

    /** Represents an object which was modified */
    const CHANGE_MODIFIED = 'modified';

    /** Represents an object added */
    const CHANGE_CREATED = 'created';

    /** Represents an object which hasn't been changed directly, but owns a modified many_many relationship. */
    //const CHANGE_MANYMANY = 'manymany';


    private static $table_name = 'ChangeSetItem';

    /**
     * Represents that an object has not yet been changed, but
     * should be included in this changeset as soon as any changes exist
     */
    const CHANGE_NONE = 'none';

    private static $db = array(
        'VersionBefore' => 'Int',
        'VersionAfter'  => 'Int',
        'Added'         => "Enum('explicitly, implicitly', 'implicitly')"
    );

    private static $has_one = array(
        'ChangeSet' => 'SilverStripe\ORM\Versioning\ChangeSet',
        'Object'    => 'SilverStripe\ORM\DataObject',
    );

    private static $many_many = array(
        'ReferencedBy' => 'SilverStripe\ORM\Versioning\ChangeSetItem'
    );

    private static $belongs_many_many = array(
        'References' => 'ChangeSetItem.ReferencedBy'
    );

    private static $indexes = array(
        'ObjectUniquePerChangeSet' => array(
            'type' => 'unique',
            'value' => '"ObjectID", "ObjectClass", "ChangeSetID"'
        )
    );

    public function onBeforeWrite()
    {
        // Make sure ObjectClass refers to the base data class in the case of old or wrong code
        $this->ObjectClass = $this->getSchema()->baseDataClass($this->ObjectClass);
        parent::onBeforeWrite();
    }

    public function getTitle()
    {
        // Get title of modified object
        $object = $this->getObjectLatestVersion();
        if ($object) {
            return $object->getTitle();
        }
        return $this->i18n_singular_name() . ' #' . $this->ID;
    }

    /**
     * Get a thumbnail for this object
     *
     * @param int $width Preferred width of the thumbnail
     * @param int $height Preferred height of the thumbnail
     * @return string URL to the thumbnail, if available
     */
    public function ThumbnailURL($width, $height)
    {
        $object = $this->getObjectLatestVersion();
        if ($object instanceof Thumbnail) {
            return $object->ThumbnailURL($width, $height);
        }
        return null;
    }

    /**
     * Get the type of change: none, created, deleted, modified, manymany
     * @return string
     * @throws UnexpectedDataException
     */
    public function getChangeType()
    {
        if (!class_exists($this->ObjectClass)) {
            throw new UnexpectedDataException("Invalid Class '{$this->ObjectClass}' in ChangeSetItem #{$this->ID}");
        }

        // Get change versions
        if ($this->VersionBefore || $this->VersionAfter) {
            $draftVersion = $this->VersionAfter; // After publishing draft was written to stage
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            $liveVersion = $this->VersionBefore; // The live version before the publish
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        } else {
            $draftVersion = Versioned::get_versionnumber_by_stage(
                $this->ObjectClass,
                Versioned::DRAFT,
                $this->ObjectID,
                false
            );
            $liveVersion = Versioned::get_versionnumber_by_stage(
                $this->ObjectClass,
                Versioned::LIVE,
                $this->ObjectID,
                false
            );
        }

        // Version comparisons
        if ($draftVersion == $liveVersion) {
            return self::CHANGE_NONE;
        } elseif (!$liveVersion) {
            return self::CHANGE_CREATED;
        } elseif (!$draftVersion) {
            return self::CHANGE_DELETED;
        } else {
            return self::CHANGE_MODIFIED;
        }
    }

    /**
     * Find version of this object in the given stage
     *
     * @param string $stage
     * @return DataObject|Versioned
     * @throws UnexpectedDataException
     */
    protected function getObjectInStage($stage)
    {
        if (!class_exists($this->ObjectClass)) {
            throw new UnexpectedDataException("Invalid Class '{$this->ObjectClass}' in ChangeSetItem #{$this->ID}");
        }

        return Versioned::get_by_stage($this->ObjectClass, $stage)->byID($this->ObjectID);
    }

    /**
     * Find latest version of this object
     * @return DataObject|Versioned
     * @throws UnexpectedDataException
     */
    protected function getObjectLatestVersion()
    {
        if (!class_exists($this->ObjectClass)) {
            throw new UnexpectedDataException("Invalid Class '{$this->ObjectClass}' in ChangeSetItem #{$this->ID}");
        }

        return Versioned::get_latest_version($this->ObjectClass, $this->ObjectID);
    }

    /**
     * Get all implicit objects for this change
     *
     * @return SS_List
     */
    public function findReferenced()
    {
        if ($this->getChangeType() === ChangeSetItem::CHANGE_DELETED) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            // If deleted from stage, need to look at live record
            $record = $this->getObjectInStage(Versioned::LIVE);
            if ($record) {
                return $record->findOwners(false);
            }
        } else {
            // If changed on stage, look at owned objects there
            $record = $this->getObjectInStage(Versioned::DRAFT);
            if ($record) {
                return $record->findOwned()->filterByCallback(function ($owned) {
                    /** @var Versioned|DataObject $owned */
                    return $owned->stagesDiffer(Versioned::DRAFT, Versioned::LIVE);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                });
            }
        }
        // Empty set
        return new ArrayList();
    }

    /**
     * Publish this item, then close it.
     *
     * Note: Unlike Versioned::doPublish() and Versioned::doUnpublish, this action is not recursive.
     */
    public function publish()
    {
        if (!class_exists($this->ObjectClass)) {
            throw new UnexpectedDataException("Invalid Class '{$this->ObjectClass}' in ChangeSetItem #{$this->ID}");
        }

        // Logical checks prior to publish
        if (!$this->canPublish()) {
            throw new Exception("The current member does not have permission to publish this ChangeSetItem.");
        }
        if ($this->VersionBefore || $this->VersionAfter) {
            throw new BadMethodCallException("This ChangeSetItem has already been published");
        }

        // Record state changed
        $this->VersionAfter = Versioned::get_versionnumber_by_stage(
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            $this->ObjectClass,
            Versioned::DRAFT,
            $this->ObjectID,
            false
        );
        $this->VersionBefore = Versioned::get_versionnumber_by_stage(
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            $this->ObjectClass,
            Versioned::LIVE,
            $this->ObjectID,
            false
        );

        switch ($this->getChangeType()) {
            case static::CHANGE_NONE: {
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                break;
            }
            case static::CHANGE_DELETED: {
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                // Non-recursive delete
                $object = $this->getObjectInStage(Versioned::LIVE);
                $object->deleteFromStage(Versioned::LIVE);
                break;
            }
            case static::CHANGE_MODIFIED:
            case static::CHANGE_CREATED: {
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                // Non-recursive publish
                $object = $this->getObjectInStage(Versioned::DRAFT);
                $object->publishSingle();
                break;
            }
        }

        $this->write();
    }

    /**
     * Once this item (and all owned objects) are published, unlink
     * all disowned objects
     */
    public function unlinkDisownedObjects()
    {
        $object = $this->getObjectInStage(Versioned::DRAFT);
        if ($object) {
            $object->unlinkDisownedObjects(Versioned::DRAFT, Versioned::LIVE);
        }
    }

    /** Reverts this item, then close it. **/
    public function revert()
    {
        user_error('Not implemented', E_USER_ERROR);
    }

    public function canView($member = null)
    {
        return $this->can(__FUNCTION__, $member);
    }

    public function canEdit($member = null)
    {
        return $this->can(__FUNCTION__, $member);
    }

    public function canCreate($member = null, $context = array())
    {
        return $this->can(__FUNCTION__, $member, $context);
    }

    public function canDelete($member = null)
    {
        return $this->can(__FUNCTION__, $member);
    }

    /**
     * Check if the BeforeVersion of this changeset can be restored to draft
     *
     * @param Member $member
     * @return bool
     */
    public function canRevert($member)
    {
        // Just get the best version as this object may not even exist on either stage anymore.
        /** @var Versioned|DataObject $object */
        $object = $this->getObjectLatestVersion();
        if (!$object) {
            return false;
        }

        // Check change type
        switch ($this->getChangeType()) {
            case static::CHANGE_CREATED: {
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                // Revert creation by deleting from stage
                return $object->canDelete($member);
            }
            default: {
switch ($expr) {
    default: { //wrong
        doSomething();
        break;
    }
}

switch ($expr) {
    default: //right
        doSomething();
        break;
}
                // All other actions are typically editing draft stage
                return $object->canEdit($member);
            }
        }
    }

    /**
     * Check if this ChangeSetItem can be published
     *
     * @param Member $member
     * @return bool
     */
    public function canPublish($member = null)
    {
        // Check canMethod to invoke on object
        switch ($this->getChangeType()) {
            case static::CHANGE_DELETED: {
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                /** @var Versioned|DataObject $object */
                $object = Versioned::get_by_stage($this->ObjectClass, Versioned::LIVE)->byID($this->ObjectID);
                if ($object) {
                    return $object->canUnpublish($member);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                }
                break;
            }
            default: {
switch ($expr) {
    default: { //wrong
        doSomething();
        break;
    }
}

switch ($expr) {
    default: //right
        doSomething();
        break;
}
                /** @var Versioned|DataObject $object */
                $object = Versioned::get_by_stage($this->ObjectClass, Versioned::DRAFT)->byID($this->ObjectID);
                if ($object) {
                    return $object->canPublish($member);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                }
                break;
            }
        }

        return true;
    }

    /**
     * Determine if this item has changes
     *
     * @return bool
     */
    public function hasChange()
    {
        return $this->getChangeType() !== ChangeSetItem::CHANGE_NONE;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
    }

    /**
     * Default permissions for this ChangeSetItem
     *
     * @param string $perm
     * @param Member $member
     * @param array $context
     * @return bool
     */
    public function can($perm, $member = null, $context = array())
    {
        if (!$member) {
            $member = Member::currentUser();
        }

        // Allow extensions to bypass default permissions, but only if
        // each change can be individually published.
        $extended = $this->extendedCan($perm, $member, $context);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        if ($extended !== null) {
            return $extended;
        }

        // Default permissions
        return (bool)Permission::checkMember($member, ChangeSet::config()->required_permission);
    }

    /**
     * Get the ChangeSetItems that reference a passed DataObject
     *
     * @param DataObject $object
     * @return DataList
     */
    public static function get_for_object($object)
    {
        return ChangeSetItem::get()->filter([
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            'ObjectID' => $object->ID,
            'ObjectClass' => $object->baseClass(),
        ]);
    }

    /**
     * Get the ChangeSetItems that reference a passed DataObject
     *
     * @param int $objectID The ID of the object
     * @param string $objectClass The class of the object (or any parent class)
     * @return DataList
     */
    public static function get_for_object_by_id($objectID, $objectClass)
    {
        return ChangeSetItem::get()->filter([
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            'ObjectID' => $objectID,
            'ObjectClass' => static::getSchema()->baseDataClass($objectClass)
        ]);
    }

    /**
     * Gets the list of modes this record can be previewed in.
     *
     * {@link https://tools.ietf.org/html/draft-kelly-json-hal-07#section-5}
     *
     * @return array Map of links in acceptable HAL format
     */
    public function getPreviewLinks()
    {
        $links = [];

        // Preview draft
        $stage = $this->getObjectInStage(Versioned::DRAFT);
        if ($stage instanceof CMSPreviewable && $stage->canView() && ($link = $stage->PreviewLink())) {
            $links[Versioned::DRAFT] = [
                'href' => Controller::join_links($link, '?stage=' . Versioned::DRAFT),
                'type' => $stage->getMimeType(),
            ];
        }

        // Preview live
        $live = $this->getObjectInStage(Versioned::LIVE);
        if ($live instanceof CMSPreviewable && $live->canView() && ($link = $live->PreviewLink())) {
            $links[Versioned::LIVE] = [
                'href' => Controller::join_links($link, '?stage=' . Versioned::LIVE),
                'type' => $live->getMimeType(),
            ];
        }

        return $links;
    }

    /**
     * Get edit link for this item
     *
     * @return string
     */
    public function CMSEditLink()
    {
        $link = $this->getObjectInStage(Versioned::DRAFT);
        if ($link instanceof CMSPreviewable) {
            return $link->CMSEditLink();
        }
        return null;
    }
}

Push — master ( b0e0e9...f4bf0c )

ChangeSetItem::hasChange() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

silverstripe / silverstripe-framework

Push — master ( b0e0e9...f4bf0c )

ChangeSetItem::hasChange() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
