ChangeSetItem - Code Metrics - Inspection of "FIX: Require php7 support." - sminnee/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — php7-fix ( 538bb9...015411 )

by Sam

created 2016-10-26 02:38 UTC

ChangeSetItem C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	404
Duplicated Lines	10.15 %

Coupling/Cohesion

Components	2
Dependencies	10

Importance

Changes

Metric	Value
dl	41
loc	404
rs	6.433
c	0
b	0
f	0
wmc	57
lcom	2
cbo	10

21 Methods

Rating	Name	Duplication	Size	Complexity
A	onBeforeWrite()	0	5	1
A	getTitle()	0	8	2
A	ThumbnailURL()	0	7	2
C	getChangeType()	0	29	7
A	getObjectInStage()	7	7	2
A	getObjectLatestVersion()	7	7	2
A	findReferenced()	0	20	4
D	publish()	0	42	9
A	unlinkDisownedObjects()	0	6	2
A	revert()	0	3	1
A	canView()	0	3	1
A	canEdit()	0	3	1
A	canCreate()	0	3	1
A	canDelete()	0	3	1
A	canRevert()	0	20	3
B	canPublish()	0	23	4
A	can()	15	15	3
A	get_for_object()	0	6	1
A	get_for_object_by_id()	0	6	1
C	getPreviewLinks()	12	23	7
A	CMSEditLink()	0	8	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like ChangeSetItem often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use ChangeSetItem, and based on these observations, apply Extract Interface, too.

<?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) {
			// 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: {
				break;
			}
			case static::CHANGE_DELETED: {
				// Non-recursive delete
				$object = $this->getObjectInStage(Versioned::LIVE);
				$object->deleteFromStage(Versioned::LIVE);
				break;
			}
			case static::CHANGE_MODIFIED:
			case static::CHANGE_CREATED: {
				// 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: {
				// Revert creation by deleting from stage
				return $object->canDelete($member);
			}
			default: {
				// 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: {
				/** @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: {
				/** @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 false;
	}

	/**
	 * 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([
			'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([
			'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 — php7-fix ( 538bb9...015411 )

ChangeSetItem C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

21 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

sminnee / silverstripe-framework

Push — php7-fix ( 538bb9...015411 )

ChangeSetItem C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

21 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like