Differential D21186 Diff 50453 src/applications/differential/storage/DifferentialInlineComment.php

Changeset View

Standalone View

src/applications/differential/storage/DifferentialInlineComment.php

	<?php			<?php

	final class DifferentialInlineComment			final class DifferentialInlineComment
	extends Phobject			extends PhabricatorInlineComment {
	implements PhabricatorInlineCommentInterface {

	private $proxy;			protected function newStorageObject() {
	private $syntheticAuthor;			return new DifferentialTransactionComment();
	private $isGhost;

	public function __construct() {
	$this->proxy = new DifferentialTransactionComment();
	}			}

	public function __clone() {			public function getControllerURI() {
	$this->proxy = clone $this->proxy;			return urisprintf(
				'/differential/comment/inline/edit/%s/',
				$this->getRevisionID());
	}			}

	public function getTransactionCommentForSave() {			public function getTransactionCommentForSave() {
	$content_source = PhabricatorContentSource::newForSource(			$content_source = PhabricatorContentSource::newForSource(
	PhabricatorOldWorldContentSource::SOURCECONST);			PhabricatorOldWorldContentSource::SOURCECONST);

	$this->proxy			$this->getStorageObject()
	->setViewPolicy('public')			->setViewPolicy('public')
	->setEditPolicy($this->getAuthorPHID())			->setEditPolicy($this->getAuthorPHID())
	->setContentSource($content_source)			->setContentSource($content_source)
	->attachIsHidden(false)			->attachIsHidden(false)
	->setCommentVersion(1);			->setCommentVersion(1);

	return $this->proxy;			return $this->getStorageObject();
	}

	public function openTransaction() {
	$this->proxy->openTransaction();
	}

	public function saveTransaction() {
	$this->proxy->saveTransaction();
	}

	public function save() {
	$this->getTransactionCommentForSave()->save();

	return $this;
	}

	public function delete() {
	$this->proxy->delete();

	return $this;
	}			}

	public function supportsHiding() {			public function supportsHiding() {
	if ($this->getSyntheticAuthor()) {			if ($this->getSyntheticAuthor()) {
	return false;			return false;
	}			}
	return true;			return true;
	}			}

	public function isHidden() {			public function isHidden() {
	if (!$this->supportsHiding()) {			if (!$this->supportsHiding()) {
	return false;			return false;
	}			}
	return $this->proxy->getIsHidden();			return $this->getStorageObject()->getIsHidden();
	}

	public function getID() {
	return $this->proxy->getID();
	}

	public function getPHID() {
	return $this->proxy->getPHID();
	}			}

	public static function newFromModernComment(			public static function newFromModernComment(
	DifferentialTransactionComment $comment) {			DifferentialTransactionComment $comment) {

	$obj = new DifferentialInlineComment();			$obj = new DifferentialInlineComment();
	$obj->proxy = $comment;			$obj->setStorageObject($comment);

	return $obj;			return $obj;
	}			}

	public function setSyntheticAuthor($synthetic_author) {
	$this->syntheticAuthor = $synthetic_author;
	return $this;
	}

	public function getSyntheticAuthor() {
	return $this->syntheticAuthor;
	}

	public function isCompatible(PhabricatorInlineCommentInterface $comment) {
	return
	($this->getAuthorPHID() === $comment->getAuthorPHID()) &&
	($this->getSyntheticAuthor() === $comment->getSyntheticAuthor()) &&
	($this->getContent() === $comment->getContent());
	}

	public function setContent($content) {
	$this->proxy->setContent($content);
	return $this;
	}

	public function getContent() {
	return $this->proxy->getContent();
	}

	public function isDraft() {
	return !$this->proxy->getTransactionPHID();
	}

	public function setChangesetID($id) {			public function setChangesetID($id) {
	$this->proxy->setChangesetID($id);			$this->getStorageObject()->setChangesetID($id);
	return $this;			return $this;
	}			}

	public function getChangesetID() {			public function getChangesetID() {
	return $this->proxy->getChangesetID();			return $this->getStorageObject()->getChangesetID();
	}

	public function setIsNewFile($is_new) {
	$this->proxy->setIsNewFile($is_new);
	return $this;
	}

	public function getIsNewFile() {
	return $this->proxy->getIsNewFile();
	}

	public function setLineNumber($number) {
	$this->proxy->setLineNumber($number);
	return $this;
	}

	public function getLineNumber() {
	return $this->proxy->getLineNumber();
	}

	public function setLineLength($length) {
	$this->proxy->setLineLength($length);
	return $this;
	}

	public function getLineLength() {
	return $this->proxy->getLineLength();
	}

	public function setCache($cache) {
	return $this;
	}

	public function getCache() {
	return null;
	}

	public function setAuthorPHID($phid) {
	$this->proxy->setAuthorPHID($phid);
	return $this;
	}

	public function getAuthorPHID() {
	return $this->proxy->getAuthorPHID();
	}			}

	public function setRevision(DifferentialRevision $revision) {			public function setRevision(DifferentialRevision $revision) {
	$this->proxy->setRevisionPHID($revision->getPHID());			$this->getStorageObject()->setRevisionPHID($revision->getPHID());
	return $this;			return $this;
	}			}

	public function getRevisionPHID() {			public function getRevisionPHID() {
	return $this->proxy->getRevisionPHID();			return $this->getStorageObject()->getRevisionPHID();
	}			}

	// Although these are purely transitional, they're also extra dumb.			// Although these are purely transitional, they're also extra dumb.

	public function setRevisionID($revision_id) {			public function setRevisionID($revision_id) {
	$revision = id(new DifferentialRevision())->load($revision_id);			$revision = id(new DifferentialRevision())->load($revision_id);
	return $this->setRevision($revision);			return $this->setRevision($revision);
	}			}

	public function getRevisionID() {			public function getRevisionID() {
	$phid = $this->proxy->getRevisionPHID();			$phid = $this->getStorageObject()->getRevisionPHID();
	if (!$phid) {			if (!$phid) {
	return null;			return null;
	}			}

	$revision = id(new DifferentialRevision())->loadOneWhere(			$revision = id(new DifferentialRevision())->loadOneWhere(
	'phid = %s',			'phid = %s',
	$phid);			$phid);
	if (!$revision) {			if (!$revision) {
	return null;			return null;
	}			}
	return $revision->getID();			return $revision->getID();
	}			}

	// When setting a comment ID, we also generate a phantom transaction PHID for
	// the future transaction.

	public function setCommentID($id) {
	$this->proxy->setTransactionPHID(
	PhabricatorPHID::generateNewPHID(
	PhabricatorApplicationTransactionTransactionPHIDType::TYPECONST,
	DifferentialRevisionPHIDType::TYPECONST));
	return $this;
	}

	public function setReplyToCommentPHID($phid) {
	$this->proxy->setReplyToCommentPHID($phid);
	return $this;
	}

	public function getReplyToCommentPHID() {
	return $this->proxy->getReplyToCommentPHID();
	}

	public function setHasReplies($has_replies) {
	$this->proxy->setHasReplies($has_replies);
	return $this;
	}

	public function getHasReplies() {
	return $this->proxy->getHasReplies();
	}

	public function setIsDeleted($is_deleted) {
	$this->proxy->setIsDeleted($is_deleted);
	return $this;
	}

	public function getIsDeleted() {
	return $this->proxy->getIsDeleted();
	}

	public function setFixedState($state) {
	$this->proxy->setFixedState($state);
	return $this;
	}

	public function getFixedState() {
	return $this->proxy->getFixedState();
	}

	public function setIsGhost($is_ghost) {
	$this->isGhost = $is_ghost;
	return $this;
	}

	public function getIsGhost() {
	return $this->isGhost;
	}

	public function makeEphemeral() {
	$this->proxy->makeEphemeral();
	return $this;
	}

	public function getDateModified() {
	return $this->proxy->getDateModified();
	}

	public function getDateCreated() {
	return $this->proxy->getDateCreated();
	}

	/* -( PhabricatorMarkupInterface Implementation )-------------------------- */


	public function getMarkupFieldKey($field) {
	$content = $this->getMarkupText($field);
	return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newDifferentialMarkupEngine();
	}

	public function getMarkupText($field) {
	return $this->getContent();
	}

	public function didMarkupText($field, $output, PhutilMarkupEngine $engine) {
	return $output;
	}

	public function shouldUseMarkupCache($field) {
	// Only cache submitted comments.
	return ($this->getID() && !$this->isDraft());
	}

	}			}