No OneTemporary
Actions

Size

40 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/editor/comment/DifferentialCommentEditor.php b/src/applications/differential/editor/comment/DifferentialCommentEditor.php
	index d2690e019f..be49a064a0 100644
	--- a/src/applications/differential/editor/comment/DifferentialCommentEditor.php
	+++ b/src/applications/differential/editor/comment/DifferentialCommentEditor.php
	@@ -1,386 +1,420 @@
	<?php

	/*
	* Copyright 2011 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	class DifferentialCommentEditor {

	protected $revision;
	protected $actorPHID;
	protected $action;

	protected $attachInlineComments;
	protected $message;
	protected $addCC;
	protected $changedByCommit;
	protected $addedReviewers = array();
	private $addedCCs = array();

	private $parentMessageID;

	public function __construct(
	DifferentialRevision $revision,
	$actor_phid,
	$action) {

	$this->revision = $revision;
	$this->actorPHID = $actor_phid;
	$this->action = $action;
	}

	public function setParentMessageID($parent_message_id) {
	$this->parentMessageID = $parent_message_id;
	return $this;
	}

	public function setMessage($message) {
	$this->message = $message;
	return $this;
	}

	public function setAttachInlineComments($attach) {
	$this->attachInlineComments = $attach;
	return $this;
	}

	public function setAddCC($add) {
	$this->addCC = $add;
	return $this;
	}

	public function setChangedByCommit($changed_by_commit) {
	$this->changedByCommit = $changed_by_commit;
	return $this;
	}

	public function getChangedByCommit() {
	return $this->changedByCommit;
	}

	public function setAddedReviewers($added_reviewers) {
	$this->addedReviewers = $added_reviewers;
	return $this;
	}

	public function getAddedReviewers() {
	return $this->addedReviewers;
	}

	public function setAddedCCs($added_ccs) {
	$this->addedCCs = $added_ccs;
	return $this;
	}

	public function getAddedCCs() {
	return $this->addedCCs;
	}

	public function save() {
	$revision = $this->revision;
	$action = $this->action;
	$actor_phid = $this->actorPHID;
	$actor_is_author = ($actor_phid == $revision->getAuthorPHID());
	$revision_status = $revision->getStatus();

	$revision->loadRelationships();
	$reviewer_phids = $revision->getReviewers();
	if ($reviewer_phids) {
	$reviewer_phids = array_combine($reviewer_phids, $reviewer_phids);
	}

	$metadata = array();

	switch ($action) {
	case DifferentialAction::ACTION_COMMENT:
	break;

	case DifferentialAction::ACTION_RESIGN:
	if ($actor_is_author) {
	throw new Exception('You can not resign from your own revision!');
	}
	if (isset($reviewer_phids[$actor_phid])) {
	DifferentialRevisionEditor::alterReviewers(
	$revision,
	$reviewer_phids,
	$rem = array($actor_phid),
	$add = array(),
	$actor_phid);
	}
	break;

	case DifferentialAction::ACTION_ABANDON:
	if (!$actor_is_author) {
	throw new Exception('You can only abandon your revisions.');
	}
	if ($revision_status == DifferentialRevisionStatus::COMMITTED) {
	throw new Exception('You can not abandon a committed revision.');
	}
	if ($revision_status == DifferentialRevisionStatus::ABANDONED) {
	$action = DifferentialAction::ACTION_COMMENT;
	break;
	}

	$revision
	->setStatus(DifferentialRevisionStatus::ABANDONED)
	->save();
	break;

	case DifferentialAction::ACTION_ACCEPT:
	if ($actor_is_author) {
	throw new Exception('You can not accept your own revision.');
	}
	if (($revision_status != DifferentialRevisionStatus::NEEDS_REVIEW) &&
	($revision_status != DifferentialRevisionStatus::NEEDS_REVISION)) {
	$action = DifferentialAction::ACTION_COMMENT;
	break;
	}

	$revision
	->setStatus(DifferentialRevisionStatus::ACCEPTED)
	->save();

	if (!isset($reviewer_phids[$actor_phid])) {
	DifferentialRevisionEditor::alterReviewers(
	$revision,
	$reviewer_phids,
	$rem = array(),
	$add = array($actor_phid),
	$actor_phid);
	}
	break;

	case DifferentialAction::ACTION_REQUEST:
	if (!$actor_is_author) {
	throw new Exception('You must own a revision to request review.');
	}
	if (($revision_status != DifferentialRevisionStatus::NEEDS_REVISION) &&
	($revision_status != DifferentialRevisionStatus::ACCEPTED)) {
	$action = DifferentialAction::ACTION_COMMENT;
	break;
	}

	$revision
	->setStatus(DifferentialRevisionStatus::NEEDS_REVIEW)
	->save();
	break;

	case DifferentialAction::ACTION_REJECT:
	if ($actor_is_author) {
	throw new Exception(
	'You can not request changes to your own revision.');
	}
	if (($revision_status != DifferentialRevisionStatus::NEEDS_REVIEW) &&
	($revision_status != DifferentialRevisionStatus::ACCEPTED)) {
	$action = DifferentialAction::ACTION_COMMENT;
	break;
	}

	if (!isset($reviewer_phids[$actor_phid])) {
	DifferentialRevisionEditor::alterReviewers(
	$revision,
	$reviewer_phids,
	$rem = array(),
	$add = array($actor_phid),
	$actor_phid);
	}

	$revision
	->setStatus(DifferentialRevisionStatus::NEEDS_REVISION)
	->save();
	break;

	case DifferentialAction::ACTION_RETHINK:
	if (!$actor_is_author) {
	throw new Exception(
	"You can not plan changes to somebody else's revision");
	}
	if (($revision_status != DifferentialRevisionStatus::NEEDS_REVIEW) &&
	($revision_status != DifferentialRevisionStatus::ACCEPTED)) {
	$action = DifferentialAction::ACTION_COMMENT;
	break;
	}

	$revision
	->setStatus(DifferentialRevisionStatus::NEEDS_REVISION)
	->save();
	break;

	case DifferentialAction::ACTION_RECLAIM:
	if (!$actor_is_author) {
	throw new Exception('You can not reclaim a revision you do not own.');
	}
	if ($revision_status != DifferentialRevisionStatus::ABANDONED) {
	$action = DifferentialAction::ACTION_COMMENT;
	break;
	}
	$revision
	->setStatus(DifferentialRevisionStatus::NEEDS_REVIEW)
	->save();
	break;

	case DifferentialAction::ACTION_COMMIT:
	if (!$actor_is_author) {
	throw new Exception('You can not commit a revision you do not own.');
	}
	$revision
	->setStatus(DifferentialRevisionStatus::COMMITTED)
	->save();
	break;

	case DifferentialAction::ACTION_ADDREVIEWERS:
	$added_reviewers = $this->getAddedReviewers();
	foreach ($added_reviewers as $k => $user_phid) {
	if ($user_phid == $revision->getAuthorPHID()) {
	unset($added_reviewers[$k]);
	}
	if (!empty($reviewer_phids[$user_phid])) {
	unset($added_reviewers[$k]);
	}
	}

	$added_reviewers = array_unique($added_reviewers);

	if ($added_reviewers) {
	DifferentialRevisionEditor::alterReviewers(
	$revision,
	$reviewer_phids,
	$rem = array(),
	$add = $added_reviewers,
	$actor_phid);

	$key = DifferentialComment::METADATA_ADDED_REVIEWERS;
	$metadata[$key] = $added_reviewers;

	} else {
	$action = DifferentialAction::ACTION_COMMENT;
	}
	break;
	case DifferentialAction::ACTION_ADDCCS:
	$added_ccs = $this->getAddedCCs();

	$current_ccs = $revision->getCCPHIDs();
	if ($current_ccs) {
	- $current_ccs = array_combine($current_ccs, $current_ccs);
	+ $current_ccs = array_fill_keys($current_ccs, true);
	foreach ($added_ccs as $k => $cc) {
	if (isset($current_ccs[$cc])) {
	unset($added_ccs[$k]);
	}
	}
	}

	if ($added_ccs) {
	foreach ($added_ccs as $cc) {
	DifferentialRevisionEditor::addCC(
	$revision,
	$cc,
	$this->actorPHID);
	}

	$key = DifferentialComment::METADATA_ADDED_CCS;
	$metadata[$key] = $added_ccs;

	} else {
	$action = DifferentialAction::ACTION_COMMENT;
	}
	break;
	default:
	throw new Exception('Unsupported action.');
	}

	if ($this->addCC) {
	DifferentialRevisionEditor::addCC(
	$revision,
	$this->actorPHID,
	$this->actorPHID);
	}

	- // Reload relationships to pick up any reviewer/CC changes.
	- $revision->loadRelationships();
	-
	$inline_comments = array();
	if ($this->attachInlineComments) {
	$inline_comments = id(new DifferentialInlineComment())->loadAllWhere(
	'authorPHID = %s AND revisionID = %d AND commentID IS NULL',
	$this->actorPHID,
	$revision->getID());
	}

	$comment = id(new DifferentialComment())
	->setAuthorPHID($this->actorPHID)
	->setRevisionID($revision->getID())
	->setAction($action)
	->setContent((string)$this->message)
	->setMetadata($metadata)
	->save();

	$changesets = array();
	if ($inline_comments) {
	$load_ids = mpull($inline_comments, 'getChangesetID');
	if ($load_ids) {
	$load_ids = array_unique($load_ids);
	$changesets = id(new DifferentialChangeset())->loadAllWhere(
	'id in (%Ld)',
	$load_ids);
	}
	foreach ($inline_comments as $inline) {
	$inline->setCommentID($comment->getID());
	$inline->save();
	}
	}

	+ // Find any "@mentions" in the comment blocks.
	+ $content_blocks = array($comment->getContent());
	+ foreach ($inline_comments as $inline) {
	+ $content_blocks[] = $inline->getContent();
	+ }
	+ $mention_ccs = DifferentialMarkupEngineFactory::extractPHIDsFromMentions(
	+ $content_blocks);
	+ if ($mention_ccs) {
	+ $current_ccs = $revision->getCCPHIDs();
	+ if ($current_ccs) {
	+ $current_ccs = array_fill_keys($current_ccs, true);
	+ foreach ($mention_ccs as $key => $mention_cc) {
	+ if (isset($current_ccs[$mention_cc])) {
	+ unset($mention_ccs);
	+ }
	+ }
	+ }
	+ if ($mention_ccs) {
	+ $metadata = $comment->getMetadata();
	+ $metacc = idx(
	+ $metadata,
	+ DifferentialComment::METADATA_ADDED_CCS,
	+ array());
	+ foreach ($mention_ccs as $cc_phid) {
	+ DifferentialRevisionEditor::addCC(
	+ $revision,
	+ $cc_phid,
	+ $this->actorPHID);
	+ $metacc[] = $cc_phid;
	+ }
	+ $metadata[DifferentialComment::METADATA_ADDED_CCS] = $metacc;
	+
	+ $comment->setMetadata($metadata);
	+ $comment->save();
	+ }
	+ }
	+
	$phids = array($this->actorPHID);
	$handles = id(new PhabricatorObjectHandleData($phids))
	->loadHandles();
	$actor_handle = $handles[$this->actorPHID];

	$xherald_header = HeraldTranscript::loadXHeraldRulesHeader(
	$revision->getPHID());

	id(new DifferentialCommentMail(
	$revision,
	$actor_handle,
	$comment,
	$changesets,
	$inline_comments))
	->setToPHIDs(
	array_merge(
	$revision->getReviewers(),
	array($revision->getAuthorPHID())))
	->setCCPHIDs($revision->getCCPHIDs())
	->setChangedByCommit($this->getChangedByCommit())
	->setXHeraldRulesHeader($xherald_header)
	->setParentMessageID($this->parentMessageID)
	->send();

	$event_data = array(
	'revision_id' => $revision->getID(),
	'revision_phid' => $revision->getPHID(),
	'revision_name' => $revision->getTitle(),
	'revision_author_phid' => $revision->getAuthorPHID(),
	'action' => $comment->getAction(),
	'feedback_content' => $comment->getContent(),
	'actor_phid' => $this->actorPHID,
	);
	id(new PhabricatorTimelineEvent('difx', $event_data))
	->recordEvent();

	// TODO: Move to a daemon?
	PhabricatorSearchDifferentialIndexer::indexRevision($revision);

	return $comment;
	}

	}
	diff --git a/src/applications/differential/editor/comment/__init__.php b/src/applications/differential/editor/comment/__init__.php
	index a11be0084c..74deebcb49 100644
	--- a/src/applications/differential/editor/comment/__init__.php
	+++ b/src/applications/differential/editor/comment/__init__.php
	@@ -1,24 +1,25 @@
	<?php
	/**
	* This file is automatically generated. Lint this module to rebuild it.
	* @generated
	*/



	phutil_require_module('phabricator', 'applications/differential/constants/action');
	phutil_require_module('phabricator', 'applications/differential/constants/revisionstatus');
	phutil_require_module('phabricator', 'applications/differential/editor/revision');
	phutil_require_module('phabricator', 'applications/differential/mail/comment');
	+phutil_require_module('phabricator', 'applications/differential/parser/markup');
	phutil_require_module('phabricator', 'applications/differential/storage/changeset');
	phutil_require_module('phabricator', 'applications/differential/storage/comment');
	phutil_require_module('phabricator', 'applications/differential/storage/inlinecomment');
	phutil_require_module('phabricator', 'applications/herald/storage/transcript/base');
	phutil_require_module('phabricator', 'applications/phid/handle/data');
	phutil_require_module('phabricator', 'applications/search/index/indexer/differential');
	phutil_require_module('phabricator', 'infrastructure/daemon/timeline/storage/event');

	phutil_require_module('phutil', 'utils');


	phutil_require_source('DifferentialCommentEditor.php');
	diff --git a/src/applications/differential/editor/revision/DifferentialRevisionEditor.php b/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
	index 01ff614cc4..9b9e5b554c 100644
	--- a/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
	+++ b/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
	@@ -1,634 +1,636 @@
	<?php

	/*
	* Copyright 2011 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* Handle major edit operations to DifferentialRevision -- adding and removing
	* reviewers, diffs, and CCs. Unlike simple edits, these changes trigger
	* complicated email workflows.
	*/
	class DifferentialRevisionEditor {

	protected $revision;
	protected $actorPHID;

	protected $cc = null;
	protected $reviewers = null;
	protected $diff;
	protected $comments;
	protected $silentUpdate;
	protected $tasks = null;

	public function __construct(DifferentialRevision $revision, $actor_phid) {
	$this->revision = $revision;
	$this->actorPHID = $actor_phid;
	}

	public static function newRevisionFromConduitWithDiff(
	array $fields,
	DifferentialDiff $diff,
	$user_phid) {

	$revision = new DifferentialRevision();
	$revision->setPHID($revision->generatePHID());

	$revision->setAuthorPHID($user_phid);
	$revision->setStatus(DifferentialRevisionStatus::NEEDS_REVIEW);

	$editor = new DifferentialRevisionEditor($revision, $user_phid);

	$editor->copyFieldsFromConduit($fields);

	$editor->addDiff($diff, null);
	$editor->save();

	// Tasks can only be updated after revision has been saved to the
	// database. Currently tasks are updated only when a revision is created.
	// UI must be used to modify tasks after creating one.
	$editor->updateTasks();

	return $revision;
	}

	public function copyFieldsFromConduit(array $fields) {

	$revision = $this->revision;

	$revision->setTitle((string)$fields['title']);
	$revision->setSummary((string)$fields['summary']);
	$revision->setTestPlan((string)$fields['testPlan']);
	$revision->setBlameRevision((string)$fields['blameRevision']);
	$revision->setRevertPlan((string)$fields['revertPlan']);

	$this->setReviewers($fields['reviewerPHIDs']);
	$this->setCCPHIDs($fields['ccPHIDs']);
	$this->setTasks($fields['tasks']);
	}

	public function getRevision() {
	return $this->revision;
	}

	public function setReviewers(array $reviewers) {
	$this->reviewers = $reviewers;
	return $this;
	}

	public function setCCPHIDs(array $cc) {
	$this->cc = $cc;
	return $this;
	}

	public function setTasks(array $tasks) {
	$this->tasks = $tasks;
	}

	public function addDiff(DifferentialDiff $diff, $comments) {
	if ($diff->getRevisionID() &&
	$diff->getRevisionID() != $this->getRevision()->getID()) {
	$diff_id = (int)$diff->getID();
	$targ_id = (int)$this->getRevision()->getID();
	$real_id = (int)$diff->getRevisionID();
	throw new Exception(
	"Can not attach diff #{$diff_id} to Revision D{$targ_id}, it is ".
	"already attached to D{$real_id}.");
	}
	$this->diff = $diff;
	$this->comments = $comments;
	return $this;
	}

	protected function getDiff() {
	return $this->diff;
	}

	protected function getComments() {
	return $this->comments;
	}

	protected function getActorPHID() {
	return $this->actorPHID;
	}

	public function isNewRevision() {
	return !$this->getRevision()->getID();
	}

	/**
	* A silent update does not trigger Herald rules or send emails. This is used
	* for auto-amends at commit time.
	*/
	public function setSilentUpdate($silent) {
	$this->silentUpdate = $silent;
	return $this;
	}

	public function save() {
	$revision = $this->getRevision();

	// TODO
	// $revision->openTransaction();

	$is_new = $this->isNewRevision();
	if ($is_new) {
	// These fields aren't nullable; set them to sensible defaults if they
	// haven't been configured. We're just doing this so we can generate an
	// ID for the revision if we don't have one already.
	$revision->setLineCount(0);
	if ($revision->getStatus() === null) {
	$revision->setStatus(DifferentialRevisionStatus::NEEDS_REVIEW);
	}
	if ($revision->getTitle() === null) {
	$revision->setTitle('Untitled Revision');
	}
	if ($revision->getAuthorPHID() === null) {
	$revision->setAuthorPHID($this->getActorPHID());
	}

	$revision->save();
	}

	$revision->loadRelationships();

	if ($this->reviewers === null) {
	$this->reviewers = $revision->getReviewers();
	}

	if ($this->cc === null) {
	$this->cc = $revision->getCCPHIDs();
	}

	// We're going to build up three dictionaries: $add, $rem, and $stable. The
	// $add dictionary has added reviewers/CCs. The $rem dictionary has
	// reviewers/CCs who have been removed, and the $stable array is
	// reviewers/CCs who haven't changed. We're going to send new reviewers/CCs
	// a different ("welcome") email than we send stable reviewers/CCs.

	$old = array(
	'rev' => array_fill_keys($revision->getReviewers(), true),
	'ccs' => array_fill_keys($revision->getCCPHIDs(), true),
	);

	$diff = $this->getDiff();

	$xscript_header = null;
	$xscript_uri = null;

	$new = array(
	'rev' => array_fill_keys($this->reviewers, true),
	'ccs' => array_fill_keys($this->cc, true),
	);


	$rem_ccs = array();
	if ($diff) {
	$diff->setRevisionID($revision->getID());
	$revision->setLineCount($diff->getLineCount());

	$adapter = new HeraldDifferentialRevisionAdapter(
	$revision,
	$diff);
	$adapter->setExplicitCCs($new['ccs']);
	$adapter->setExplicitReviewers($new['rev']);
	$adapter->setForbiddenCCs($revision->getUnsubscribedPHIDs());

	$xscript = HeraldEngine::loadAndApplyRules($adapter);
	$xscript_uri = PhabricatorEnv::getProductionURI(
	'/herald/transcript/'.$xscript->getID().'/');
	$xscript_phid = $xscript->getPHID();
	$xscript_header = $xscript->getXHeraldRulesHeader();

	HeraldTranscript::saveXHeraldRulesHeader(
	$revision->getPHID(),
	$xscript_header);

	$sub = array(
	'rev' => array(),
	'ccs' => $adapter->getCCsAddedByHerald(),
	);
	$rem_ccs = $adapter->getCCsRemovedByHerald();
	} else {
	$sub = array(
	'rev' => array(),
	'ccs' => array(),
	);
	}

	// Remove any CCs which are prevented by Herald rules.
	$sub['ccs'] = array_diff_key($sub['ccs'], $rem_ccs);
	$new['ccs'] = array_diff_key($new['ccs'], $rem_ccs);

	$add = array();
	$rem = array();
	$stable = array();
	foreach (array('rev', 'ccs') as $key) {
	$add[$key] = array();
	if ($new[$key] !== null) {
	$add[$key] += array_diff_key($new[$key], $old[$key]);
	}
	$add[$key] += array_diff_key($sub[$key], $old[$key]);

	$combined = $sub[$key];
	if ($new[$key] !== null) {
	$combined += $new[$key];
	}
	$rem[$key] = array_diff_key($old[$key], $combined);

	$stable[$key] = array_diff_key($old[$key], $add[$key] + $rem[$key]);
	}

	self::alterReviewers(
	$revision,
	$this->reviewers,
	array_keys($rem['rev']),
	array_keys($add['rev']),
	$this->actorPHID);

	/*

	// TODO: When Herald is brought over, run through this stuff to figure
	// out which adds are Herald's fault.

	// TODO: Still need to do this.

	if ($add['ccs'] \|\| $rem['ccs']) {
	foreach (array_keys($add['ccs']) as $id) {
	if (empty($new['ccs'][$id])) {
	$reason_phid = 'TODO';//$xscript_phid;
	} else {
	$reason_phid = $this->getActorPHID();
	}
	}
	foreach (array_keys($rem['ccs']) as $id) {
	if (empty($new['ccs'][$id])) {
	$reason_phid = $this->getActorPHID();
	} else {
	$reason_phid = 'TODO';//$xscript_phid;
	}
	}
	}
	*/
	self::alterCCs(
	$revision,
	$this->cc,
	array_keys($rem['ccs']),
	array_keys($add['ccs']),
	$this->actorPHID);

	// Add the author and users included from Herald rules to the relevant set
	// of users so they get a copy of the email.
	if (!$this->silentUpdate) {
	if ($is_new) {
	$add['rev'][$this->getActorPHID()] = true;
	if ($diff) {
	$add['rev'] += $adapter->getEmailPHIDsAddedByHerald();
	}
	} else {
	$stable['rev'][$this->getActorPHID()] = true;
	if ($diff) {
	$stable['rev'] += $adapter->getEmailPHIDsAddedByHerald();
	}
	}
	}

	$mail = array();

	$phids = array($this->getActorPHID());

	$handles = id(new PhabricatorObjectHandleData($phids))
	->loadHandles();
	$actor_handle = $handles[$this->getActorPHID()];

	$changesets = null;
	$comment = null;
	if ($diff) {
	$changesets = $diff->loadChangesets();
	// TODO: This should probably be in DifferentialFeedbackEditor?
	if (!$is_new) {
	$comment = $this->createComment();
	}
	if ($comment) {
	$mail[] = id(new DifferentialNewDiffMail(
	$revision,
	$actor_handle,
	$changesets))
	->setIsFirstMailAboutRevision($is_new)
	->setIsFirstMailToRecipients($is_new)
	->setComments($this->getComments())
	->setToPHIDs(array_keys($stable['rev']))
	->setCCPHIDs(array_keys($stable['ccs']));
	}

	// Save the changes we made above.

	$diff->setDescription(substr($this->getComments(), 0, 80));
	$diff->save();

	// An updated diff should require review, as long as it's not committed
	// or accepted. The "accepted" status is "sticky" to encourage courtesy
	// re-diffs after someone accepts with minor changes/suggestions.

	$status = $revision->getStatus();
	if ($status != DifferentialRevisionStatus::COMMITTED &&
	$status != DifferentialRevisionStatus::ACCEPTED) {
	$revision->setStatus(DifferentialRevisionStatus::NEEDS_REVIEW);
	}

	} else {
	$diff = $revision->loadActiveDiff();
	if ($diff) {
	$changesets = $diff->loadChangesets();
	} else {
	$changesets = array();
	}
	}

	$revision->save();

	$event_data = array(
	'revision_id' => $revision->getID(),
	'revision_phid' => $revision->getPHID(),
	'revision_name' => $revision->getTitle(),
	'revision_author_phid' => $revision->getAuthorPHID(),
	'action' => $is_new
	? DifferentialAction::ACTION_CREATE
	: DifferentialAction::ACTION_UPDATE,
	'feedback_content' => $is_new
	? ''
	: $this->getComments(),
	'actor_phid' => $revision->getAuthorPHID(),
	);
	id(new PhabricatorTimelineEvent('difx', $event_data))
	->recordEvent();

	// TODO
	// $revision->saveTransaction();

	// TODO: Move this into a worker task thing.
	PhabricatorSearchDifferentialIndexer::indexRevision($revision);

	if ($this->silentUpdate) {
	return;
	}

	$revision->loadRelationships();

	if ($add['rev']) {
	$message = id(new DifferentialNewDiffMail(
	$revision,
	$actor_handle,
	$changesets))
	->setIsFirstMailAboutRevision($is_new)
	->setIsFirstMailToRecipients(true)
	->setToPHIDs(array_keys($add['rev']));

	if ($is_new) {
	// The first time we send an email about a revision, put the CCs in
	// the "CC:" field of the same "Review Requested" email that reviewers
	// get, so you don't get two initial emails if you're on a list that
	// is CC'd.
	$message->setCCPHIDs(array_keys($add['ccs']));
	}

	$mail[] = $message;
	}

	// If you were added as a reviewer and a CC, just give you the reviewer
	// email. We could go to greater lengths to prevent this, but there's
	// bunch of stuff with list subscriptions anyway. You can still get two
	// emails, but only if a revision is updated and you are added as a reviewer
	// at the same time a list you are on is added as a CC, which is rare and
	// reasonable.
	$add['ccs'] = array_diff_key($add['ccs'], $add['rev']);

	if (!$is_new && $add['ccs']) {
	$mail[] = id(new DifferentialCCWelcomeMail(
	$revision,
	$actor_handle,
	$changesets))
	->setIsFirstMailToRecipients(true)
	->setToPHIDs(array_keys($add['ccs']));
	}

	foreach ($mail as $message) {
	$message->setHeraldTranscriptURI($xscript_uri);
	$message->setXHeraldRulesHeader($xscript_header);
	$message->send();
	}
	}

	public static function addCCAndUpdateRevision(
	$revision,
	$phid,
	$reason) {

	self::addCC($revision, $phid, $reason);

	$unsubscribed = $revision->getUnsubscribed();
	if (isset($unsubscribed[$phid])) {
	unset($unsubscribed[$phid]);
	$revision->setUnsubscribed($unsubscribed);
	$revision->save();
	}
	}

	public static function removeCCAndUpdateRevision(
	$revision,
	$phid,
	$reason) {

	self::removeCC($revision, $phid, $reason);

	$unsubscribed = $revision->getUnsubscribed();
	if (empty($unsubscribed[$phid])) {
	$unsubscribed[$phid] = true;
	$revision->setUnsubscribed($unsubscribed);
	$revision->save();
	}
	}

	public static function addCC(
	DifferentialRevision $revision,
	$phid,
	$reason) {
	return self::alterCCs(
	$revision,
	$revision->getCCPHIDs(),
	$rem = array(),
	$add = array($phid),
	$reason);
	}

	public static function removeCC(
	DifferentialRevision $revision,
	$phid,
	$reason) {
	return self::alterCCs(
	$revision,
	$revision->getCCPHIDs(),
	$rem = array($phid),
	$add = array(),
	$reason);
	}

	protected static function alterCCs(
	DifferentialRevision $revision,
	array $stable_phids,
	array $rem_phids,
	array $add_phids,
	$reason_phid) {

	return self::alterRelationships(
	$revision,
	$stable_phids,
	$rem_phids,
	$add_phids,
	$reason_phid,
	DifferentialRevision::RELATION_SUBSCRIBED);
	}


	public static function alterReviewers(
	DifferentialRevision $revision,
	array $stable_phids,
	array $rem_phids,
	array $add_phids,
	$reason_phid) {

	return self::alterRelationships(
	$revision,
	$stable_phids,
	$rem_phids,
	$add_phids,
	$reason_phid,
	DifferentialRevision::RELATION_REVIEWER);
	}

	private static function alterRelationships(
	DifferentialRevision $revision,
	array $stable_phids,
	array $rem_phids,
	array $add_phids,
	$reason_phid,
	$relation_type) {

	$rem_map = array_fill_keys($rem_phids, true);
	$add_map = array_fill_keys($add_phids, true);

	$seq_map = array_values($stable_phids);
	$seq_map = array_flip($seq_map);
	foreach ($rem_map as $phid => $ignored) {
	if (!isset($seq_map[$phid])) {
	$seq_map[$phid] = count($seq_map);
	}
	}
	foreach ($add_map as $phid => $ignored) {
	if (!isset($seq_map[$phid])) {
	$seq_map[$phid] = count($seq_map);
	}
	}

	$raw = $revision->getRawRelations($relation_type);
	$raw = ipull($raw, null, 'objectPHID');

	$sequence = count($seq_map);
	foreach ($raw as $phid => $ignored) {
	if (isset($seq_map[$phid])) {
	$raw[$phid]['sequence'] = $seq_map[$phid];
	} else {
	$raw[$phid]['sequence'] = $sequence++;
	}
	}
	$raw = isort($raw, 'sequence');

	foreach ($raw as $phid => $ignored) {
	if (isset($rem_map[$phid])) {
	unset($raw[$phid]);
	}
	}

	foreach ($add_phids as $add) {
	$raw[$add] = array(
	'objectPHID' => $add,
	'sequence' => idx($seq_map, $add, $sequence++),
	'reasonPHID' => $reason_phid,
	);
	}

	$conn_w = $revision->establishConnection('w');

	$sql = array();
	foreach ($raw as $relation) {
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %s, %s, %d, %s)',
	$revision->getID(),
	$relation_type,
	$relation['objectPHID'],
	$relation['sequence'],
	$relation['reasonPHID']);
	}

	$conn_w->openTransaction();
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d AND relation = %s',
	DifferentialRevision::RELATIONSHIP_TABLE,
	$revision->getID(),
	$relation_type);
	if ($sql) {
	queryfx(
	$conn_w,
	'INSERT INTO %T
	(revisionID, relation, objectPHID, sequence, reasonPHID)
	VALUES %Q',
	DifferentialRevision::RELATIONSHIP_TABLE,
	implode(', ', $sql));
	}
	$conn_w->saveTransaction();
	+
	+ $revision->loadRelationships();
	}


	private function createComment() {
	$revision_id = $this->revision->getID();
	$comment = id(new DifferentialComment())
	->setAuthorPHID($this->getActorPHID())
	->setRevisionID($revision_id)
	->setContent($this->getComments())
	->setAction('update');
	$comment->save();

	return $comment;
	}

	private function updateTasks() {
	if ($this->tasks) {
	$task_class = PhabricatorEnv::getEnvConfig(
	'differential.attach-task-class');
	if ($task_class) {
	PhutilSymbolLoader::loadClass($task_class);
	$task_attacher = newv($task_class, array());
	$ret = $task_attacher->attachTasksToRevision(
	$this->actorPHID,
	$this->revision,
	$this->tasks);
	}
	}
	}

	}

	diff --git a/src/applications/differential/parser/markup/DifferentialMarkupEngineFactory.php b/src/applications/differential/parser/markup/DifferentialMarkupEngineFactory.php
	index 959c18fbb8..7116f6050d 100644
	--- a/src/applications/differential/parser/markup/DifferentialMarkupEngineFactory.php
	+++ b/src/applications/differential/parser/markup/DifferentialMarkupEngineFactory.php
	@@ -1,89 +1,106 @@
	<?php

	/*
	* Copyright 2011 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	class DifferentialMarkupEngineFactory {

	+ public static function extractPHIDsFromMentions(array $content_blocks) {
	+ $mentions = array();
	+
	+ $factory = new DifferentialMarkupEngineFactory();
	+ $engine = $factory->newDifferentialCommentMarkupEngine();
	+
	+ foreach ($content_blocks as $content_block) {
	+ $engine->markupText($content_block);
	+ $phids = $engine->getTextMetadata(
	+ 'phabricator.mentioned-user-phids',
	+ array());
	+ $mentions += $phids;
	+ }
	+
	+ return $mentions;
	+ }
	+
	public function newDifferentialCommentMarkupEngine() {
	$engine = new PhutilRemarkupEngine();

	$engine->setConfig('preserve-linebreaks', true);
	$engine->setConfig(
	'pygments.enabled',
	PhabricatorEnv::getEnvConfig('pygments.enabled'));

	$rules = array();
	$rules[] = new PhutilRemarkupRuleEscapeRemarkup();
	if (PhabricatorEnv::getEnvConfig('files.enable-proxy')) {
	$rules[] = new PhabricatorRemarkupRuleProxyImage();
	}

	if (PhabricatorEnv::getEnvConfig('remarkup.enable-embedded-youtube')) {
	$rules[] = new PhabricatorRemarkupRuleYoutube();
	}

	$rules[] = new PhutilRemarkupRuleHyperlink();

	$rules[] = new PhabricatorRemarkupRuleDifferential();
	$rules[] = new PhabricatorRemarkupRuleDiffusion();
	$rules[] = new PhabricatorRemarkupRuleManiphest();
	$rules[] = new PhabricatorRemarkupRuleImageMacro();
	$rules[] = new PhabricatorRemarkupRuleMention();

	$custom_rule_classes =
	PhabricatorEnv::getEnvConfig('differential.custom-remarkup-rules');
	if ($custom_rule_classes) {
	foreach ($custom_rule_classes as $custom_rule_class) {
	PhutilSymbolLoader::loadClass($custom_rule_class);
	$rules[] = newv($custom_rule_class, array());
	}
	}

	$rules[] = new PhutilRemarkupRuleEscapeHTML();
	$rules[] = new PhutilRemarkupRuleMonospace();
	$rules[] = new PhutilRemarkupRuleBold();
	$rules[] = new PhutilRemarkupRuleItalic();


	$blocks = array();
	$blocks[] = new PhutilRemarkupEngineRemarkupQuotesBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupHeaderBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupListBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupCodeBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupDefaultBlockRule();

	$custom_block_rule_classes =
	PhabricatorEnv::getEnvConfig('differential.custom-remarkup-block-rules');
	if ($custom_block_rule_classes) {
	foreach ($custom_block_rule_classes as $custom_block_rule_class) {
	PhutilSymbolLoader::loadClass($custom_block_rule_class);
	$blocks[] = newv($custom_block_rule_class, array());
	}
	}

	foreach ($blocks as $block) {
	if (!($block instanceof PhutilRemarkupEngineRemarkupCodeBlockRule)) {
	$block->setMarkupRules($rules);
	}
	}

	$engine->setBlockRules($blocks);

	return $engine;
	}

	}
	diff --git a/src/infrastructure/markup/remarkup/markuprule/mention/PhabricatorRemarkupRuleMention.php b/src/infrastructure/markup/remarkup/markuprule/mention/PhabricatorRemarkupRuleMention.php
	index 0849570767..ccacba0f82 100644
	--- a/src/infrastructure/markup/remarkup/markuprule/mention/PhabricatorRemarkupRuleMention.php
	+++ b/src/infrastructure/markup/remarkup/markuprule/mention/PhabricatorRemarkupRuleMention.php
	@@ -1,93 +1,100 @@
	<?php

	/*
	* Copyright 2011 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @group markup
	*/
	class PhabricatorRemarkupRuleMention
	extends PhutilRemarkupRule {

	private $actualUsers;

	public function apply($text) {

	// NOTE: Negative lookahead for period prevents us from picking up email
	// addresses, while allowing constructs like "@tomo, lol".
	$regexp = '/@([a-zA-Z0-9]+)\b(?![.])/';

	$matches = null;
	$ok = preg_match_all($regexp, $text, $matches);
	if (!$ok) {
	// No mentions in this text.
	return $text;
	}

	$usernames = $matches[1];

	// TODO: This is a little sketchy perf-wise. Once APC comes up, it is an
	// ideal candidate to back with an APC cache.
	$user_table = new PhabricatorUser();
	$real_user_names = queryfx_all(
	$user_table->establishConnection('r'),
	'SELECT username, phid, realName FROM %T WHERE username IN (%Ls)',
	$user_table->getTableName(),
	$usernames);

	+ $engine = $this->getEngine();
	+ $metadata_key = 'phabricator.mentioned-user-phids';
	+ $mentioned = $engine->getTextMetadata($metadata_key, array());
	+
	foreach ($real_user_names as $row) {
	$this->actualUsers[strtolower($row['username'])] = $row;
	+ $mentioned[$row['phid']] = $row['phid'];
	}

	+ $engine->setTextMetadata($metadata_key, $mentioned);
	+
	return preg_replace_callback(
	$regexp,
	array($this, 'markupMention'),
	$text);
	}

	public function markupMention($matches) {
	$username = strtolower($matches[1]);
	$exists = isset($this->actualUsers[$username]);

	$real = $this->actualUsers[$username]['realName'];

	$class = $exists
	? 'phabricator-remarkup-mention-exists'
	: 'phabricator-remarkup-mention-unknown';

	if ($exists) {
	$tag = phutil_render_tag(
	'a',
	array(
	'class' => $class,
	'href' => '/p/'.$username.'/',
	'target' => '_blank',
	'title' => $real,
	),
	phutil_escape_html('@'.$username));
	} else {
	$tag = phutil_render_tag(
	'span',
	array(
	'class' => $class,
	),
	phutil_escape_html('@'.$username));
	}

	return $this->getEngine()->storeText($tag);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 20:24 (1 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1128427
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions