No OneTemporary
Actions

Size

144 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/audit/editor/PhabricatorAuditCommentEditor.php b/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	index 6633e650a9..25ef287a2b 100644
	--- a/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	+++ b/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	@@ -1,567 +1,568 @@
	<?php

	final class PhabricatorAuditCommentEditor extends PhabricatorEditor {

	private $commit;

	private $attachInlineComments;
	private $auditors = array();
	private $ccs = array();

	private $noEmail;

	public function __construct(PhabricatorRepositoryCommit $commit) {
	$this->commit = $commit;
	return $this;
	}

	public function addAuditors(array $auditor_phids) {
	$this->auditors = array_merge($this->auditors, $auditor_phids);
	return $this;
	}

	public function addCCs(array $cc_phids) {
	$this->ccs = array_merge($this->ccs, $cc_phids);
	return $this;
	}

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

	public function setNoEmail($no_email) {
	$this->noEmail = $no_email;
	return $this;
	}

	public function addComment(PhabricatorAuditComment $comment) {

	$commit = $this->commit;
	$actor = $this->getActor();

	$other_comments = id(new PhabricatorAuditComment())->loadAllWhere(
	'targetPHID = %s',
	$commit->getPHID());

	$inline_comments = array();
	if ($this->attachInlineComments) {
	$inline_comments = id(new PhabricatorAuditInlineComment())->loadAllWhere(
	'authorPHID = %s AND commitPHID = %s
	AND auditCommentID IS NULL',
	$actor->getPHID(),
	$commit->getPHID());
	}

	$comment
	->setActorPHID($actor->getPHID())
	->setTargetPHID($commit->getPHID())
	->save();

	$content_blocks = array($comment->getContent());

	if ($inline_comments) {
	foreach ($inline_comments as $inline) {
	$inline->setAuditCommentID($comment->getID());
	$inline->save();
	$content_blocks[] = $inline->getContent();
	}
	}

	$ccs = $this->ccs;
	$auditors = $this->auditors;

	$metadata = $comment->getMetadata();
	$metacc = array();

	// Find any "@mentions" in the content blocks.
	$mention_ccs = PhabricatorMarkupEngine::extractPHIDsFromMentions(
	+ $this->getActor(),
	$content_blocks);
	if ($mention_ccs) {
	$metacc = idx(
	$metadata,
	PhabricatorAuditComment::METADATA_ADDED_CCS,
	array());
	foreach ($mention_ccs as $cc_phid) {
	$metacc[] = $cc_phid;
	}
	}

	if ($metacc) {
	$ccs = array_merge($ccs, $metacc);
	}

	// When an actor submits an audit comment, we update all the audit requests
	// they have authority over to reflect the most recent status. The general
	// idea here is that if audit has triggered for, e.g., several packages, but
	// a user owns all of them, they can clear the audit requirement in one go
	// without auditing the commit for each trigger.

	$audit_phids = self::loadAuditPHIDsForUser($actor);
	$audit_phids = array_fill_keys($audit_phids, true);

	$requests = id(new PhabricatorRepositoryAuditRequest())
	->loadAllWhere(
	'commitPHID = %s',
	$commit->getPHID());

	$action = $comment->getAction();


	// TODO: We should validate the action, currently we allow anyone to, e.g.,
	// close an audit if they muck with form parameters. I'll followup with this
	// and handle the no-effect cases (e.g., closing and already-closed audit).


	$actor_is_author = ($actor->getPHID() == $commit->getAuthorPHID());

	if ($action == PhabricatorAuditActionConstants::CLOSE) {
	if (!PhabricatorEnv::getEnvConfig('audit.can-author-close-audit')) {
	throw new Exception('Cannot Close Audit without enabling'.
	'audit.can-author-close-audit');
	}
	// "Close" means wipe out all the concerns.
	$concerned_status = PhabricatorAuditStatusConstants::CONCERNED;
	foreach ($requests as $request) {
	if ($request->getAuditStatus() == $concerned_status) {
	$request->setAuditStatus(PhabricatorAuditStatusConstants::CLOSED);
	$request->save();
	}
	}
	} else if ($action == PhabricatorAuditActionConstants::RESIGN) {
	// "Resign" has unusual rules for writing user rows, only affects the
	// user row (never package/project rows), and always affects the user
	// row (other actions don't, if they were able to affect a package/project
	// row).
	$actor_request = null;
	foreach ($requests as $request) {
	if ($request->getAuditorPHID() == $actor->getPHID()) {
	$actor_request = $request;
	break;
	}
	}
	if (!$actor_request) {
	$actor_request = id(new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($commit->getPHID())
	->setAuditorPHID($actor->getPHID())
	->setAuditReasons(array("Resigned"));
	}

	$actor_request
	->setAuditStatus(PhabricatorAuditStatusConstants::RESIGNED)
	->save();

	$requests[] = $actor_request;
	} else {
	$have_any_requests = false;
	foreach ($requests as $request) {
	if (empty($audit_phids[$request->getAuditorPHID()])) {
	continue;
	}

	$request_is_for_actor =
	($request->getAuditorPHID() == $actor->getPHID());

	$have_any_requests = true;
	$new_status = null;
	switch ($action) {
	case PhabricatorAuditActionConstants::COMMENT:
	case PhabricatorAuditActionConstants::ADD_CCS:
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	// Commenting or adding cc's/auditors doesn't change status.
	break;
	case PhabricatorAuditActionConstants::ACCEPT:
	if (!$actor_is_author \|\| $request_is_for_actor) {
	// When modifying your own commits, you act only on behalf of
	// yourself, not your packages/projects -- the idea being that
	// you can't accept your own commits.
	$new_status = PhabricatorAuditStatusConstants::ACCEPTED;
	}
	break;
	case PhabricatorAuditActionConstants::CONCERN:
	if (!$actor_is_author \|\| $request_is_for_actor) {
	// See above.
	$new_status = PhabricatorAuditStatusConstants::CONCERNED;
	}
	break;
	default:
	throw new Exception("Unknown action '{$action}'!");
	}
	if ($new_status !== null) {
	$request->setAuditStatus($new_status);
	$request->save();
	}
	}

	// If the actor has no current authority over any audit trigger, make a
	// new one to represent their audit state.
	if (!$have_any_requests) {
	$new_status = null;
	switch ($action) {
	case PhabricatorAuditActionConstants::COMMENT:
	case PhabricatorAuditActionConstants::ADD_CCS:
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	$new_status = PhabricatorAuditStatusConstants::AUDIT_NOT_REQUIRED;
	break;
	case PhabricatorAuditActionConstants::ACCEPT:
	$new_status = PhabricatorAuditStatusConstants::ACCEPTED;
	break;
	case PhabricatorAuditActionConstants::CONCERN:
	$new_status = PhabricatorAuditStatusConstants::CONCERNED;
	break;
	case PhabricatorAuditActionConstants::CLOSE:
	// Impossible to reach this block with 'close'.
	default:
	throw new Exception("Unknown or invalid action '{$action}'!");
	}

	$request = id(new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($commit->getPHID())
	->setAuditorPHID($actor->getPHID())
	->setAuditStatus($new_status)
	->setAuditReasons(array("Voluntary Participant"))
	->save();
	$requests[] = $request;
	}
	}

	$requests_by_auditor = mpull($requests, null, 'getAuditorPHID');
	$requests_phids = array_keys($requests_by_auditor);

	$ccs = array_diff($ccs, $requests_phids);
	$auditors = array_diff($auditors, $requests_phids);

	if ($action == PhabricatorAuditActionConstants::ADD_CCS) {
	if ($ccs) {
	$metadata[PhabricatorAuditComment::METADATA_ADDED_CCS] = $ccs;
	$comment->setMetaData($metadata);
	} else {
	$comment->setAction(PhabricatorAuditActionConstants::COMMENT);
	}
	}

	if ($action == PhabricatorAuditActionConstants::ADD_AUDITORS) {
	if ($auditors) {
	$metadata[PhabricatorAuditComment::METADATA_ADDED_AUDITORS]
	= $auditors;
	$comment->setMetaData($metadata);
	} else {
	$comment->setAction(PhabricatorAuditActionConstants::COMMENT);
	}
	}

	$comment->save();

	if ($auditors) {
	foreach ($auditors as $auditor_phid) {
	$audit_requested = PhabricatorAuditStatusConstants::AUDIT_REQUESTED;
	$requests[] = id (new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($commit->getPHID())
	->setAuditorPHID($auditor_phid)
	->setAuditStatus($audit_requested)
	->setAuditReasons(
	array('Added by ' . $actor->getUsername()))
	->save();
	}
	}

	if ($ccs) {
	foreach ($ccs as $cc_phid) {
	$audit_cc = PhabricatorAuditStatusConstants::CC;
	$requests[] = id (new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($commit->getPHID())
	->setAuditorPHID($cc_phid)
	->setAuditStatus($audit_cc)
	->setAuditReasons(
	array('Added by ' . $actor->getUsername()))
	->save();
	}
	}

	$commit->updateAuditStatus($requests);
	$commit->save();

	$feed_dont_publish_phids = array();
	foreach ($requests as $request) {
	$status = $request->getAuditStatus();
	switch ($status) {
	case PhabricatorAuditStatusConstants::RESIGNED:
	case PhabricatorAuditStatusConstants::NONE:
	case PhabricatorAuditStatusConstants::AUDIT_NOT_REQUIRED:
	case PhabricatorAuditStatusConstants::CC:
	$feed_dont_publish_phids[$request->getAuditorPHID()] = 1;
	break;
	default:
	unset($feed_dont_publish_phids[$request->getAuditorPHID()]);
	break;
	}
	}
	$feed_dont_publish_phids = array_keys($feed_dont_publish_phids);

	$feed_phids = array_diff($requests_phids, $feed_dont_publish_phids);
	$this->publishFeedStory($comment, $feed_phids);

	id(new PhabricatorSearchIndexer())
	->queueDocumentForIndexing($commit->getPHID());

	if (!$this->noEmail) {
	$this->sendMail($comment, $other_comments, $inline_comments, $requests);
	}
	}


	/**
	* Load the PHIDs for all objects the user has the authority to act as an
	* audit for. This includes themselves, and any packages they are an owner
	* of.
	*/
	public static function loadAuditPHIDsForUser(PhabricatorUser $user) {
	$phids = array();

	// TODO: This method doesn't really use the right viewer, but in practice we
	// never issue this query of this type on behalf of another user and are
	// unlikely to do so in the future. This entire method should be refactored
	// into a Query class, however, and then we should use a proper viewer.

	// The user can audit on their own behalf.
	$phids[$user->getPHID()] = true;

	$owned_packages = id(new PhabricatorOwnersPackageQuery())
	->setViewer($user)
	->withOwnerPHIDs(array($user->getPHID()))
	->execute();
	foreach ($owned_packages as $package) {
	$phids[$package->getPHID()] = true;
	}

	// The user can audit on behalf of all projects they are a member of.
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withMemberPHIDs(array($user->getPHID()))
	->execute();
	foreach ($projects as $project) {
	$phids[$project->getPHID()] = true;
	}

	return array_keys($phids);
	}

	private function publishFeedStory(
	PhabricatorAuditComment $comment,
	array $more_phids) {

	$commit = $this->commit;
	$actor = $this->getActor();

	$related_phids = array_merge(
	array(
	$actor->getPHID(),
	$commit->getPHID(),
	),
	$more_phids);

	id(new PhabricatorFeedStoryPublisher())
	->setRelatedPHIDs($related_phids)
	->setStoryAuthorPHID($actor->getPHID())
	->setStoryTime(time())
	->setStoryType(PhabricatorFeedStoryTypeConstants::STORY_AUDIT)
	->setStoryData(
	array(
	'commitPHID' => $commit->getPHID(),
	'action' => $comment->getAction(),
	'content' => $comment->getContent(),
	))
	->publish();
	}

	private function sendMail(
	PhabricatorAuditComment $comment,
	array $other_comments,
	array $inline_comments,
	array $requests) {

	assert_instances_of($other_comments, 'PhabricatorAuditComment');
	assert_instances_of($inline_comments, 'PhabricatorInlineCommentInterface');

	$commit = $this->commit;

	$data = $commit->loadCommitData();
	$summary = $data->getSummary();

	$commit_phid = $commit->getPHID();
	$phids = array($commit_phid);
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->getActor())
	->withPHIDs($phids)
	->execute();
	$handle = $handles[$commit_phid];

	$name = $handle->getName();

	$map = array(
	PhabricatorAuditActionConstants::CONCERN => 'Raised Concern',
	PhabricatorAuditActionConstants::ACCEPT => 'Accepted',
	PhabricatorAuditActionConstants::RESIGN => 'Resigned',
	PhabricatorAuditActionConstants::CLOSE => 'Closed',
	PhabricatorAuditActionConstants::ADD_CCS => 'Added CCs',
	PhabricatorAuditActionConstants::ADD_AUDITORS => 'Added Auditors',
	);
	$verb = idx($map, $comment->getAction(), 'Commented On');

	$reply_handler = self::newReplyHandlerForCommit($commit);

	$prefix = PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');

	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getActor())
	->withIDs(array($commit->getRepositoryID()))
	->executeOne();
	$threading = self::getMailThreading($repository, $commit);
	list($thread_id, $thread_topic) = $threading;

	$body = $this->renderMailBody(
	$comment,
	"{$name}: {$summary}",
	$handle,
	$reply_handler,
	$inline_comments);

	$email_to = array();
	$email_cc = array();

	$email_to[$comment->getActorPHID()] = true;

	$author_phid = $data->getCommitDetail('authorPHID');
	if ($author_phid) {
	$email_to[$author_phid] = true;
	}

	foreach ($other_comments as $other_comment) {
	$email_cc[$other_comment->getActorPHID()] = true;
	}

	foreach ($requests as $request) {
	switch ($request->getAuditStatus()) {
	case PhabricatorAuditStatusConstants::CC:
	case PhabricatorAuditStatusConstants::AUDIT_REQUIRED:
	$email_cc[$request->getAuditorPHID()] = true;
	break;
	case PhabricatorAuditStatusConstants::RESIGNED:
	unset($email_cc[$request->getAuditorPHID()]);
	break;
	case PhabricatorAuditStatusConstants::CONCERNED:
	case PhabricatorAuditStatusConstants::AUDIT_REQUESTED:
	$email_to[$request->getAuditorPHID()] = true;
	break;
	}
	}

	$email_to = array_keys($email_to);
	$email_cc = array_keys($email_cc);

	$phids = array_merge($email_to, $email_cc);
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->getActor())
	->withPHIDs($phids)
	->execute();

	// NOTE: Always set $is_new to false, because the "first" mail in the
	// thread is the Herald notification of the commit.
	$is_new = false;

	$template = id(new PhabricatorMetaMTAMail())
	->setSubject("{$name}: {$summary}")
	->setSubjectPrefix($prefix)
	->setVarySubjectPrefix("[{$verb}]")
	->setFrom($comment->getActorPHID())
	->setThreadID($thread_id, $is_new)
	->addHeader('Thread-Topic', $thread_topic)
	->setRelatedPHID($commit->getPHID())
	->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
	->setIsBulk(true)
	->setBody($body);

	$mails = $reply_handler->multiplexMail(
	$template,
	array_select_keys($handles, $email_to),
	array_select_keys($handles, $email_cc));

	foreach ($mails as $mail) {
	$mail->saveAndSend();
	}
	}

	public static function getMailThreading(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	return array(
	'diffusion-audit-'.$commit->getPHID(),
	'Commit r'.$repository->getCallsign().$commit->getCommitIdentifier(),
	);
	}

	public static function newReplyHandlerForCommit($commit) {
	$reply_handler = PhabricatorEnv::newObjectFromConfig(
	'metamta.diffusion.reply-handler');
	$reply_handler->setMailReceiver($commit);
	return $reply_handler;
	}

	private function renderMailBody(
	PhabricatorAuditComment $comment,
	$cname,
	PhabricatorObjectHandle $handle,
	PhabricatorMailReplyHandler $reply_handler,
	array $inline_comments) {
	assert_instances_of($inline_comments, 'PhabricatorInlineCommentInterface');

	$commit = $this->commit;
	$actor = $this->getActor();
	$name = $actor->getUsername();

	$verb = PhabricatorAuditActionConstants::getActionPastTenseVerb(
	$comment->getAction());

	$body = new PhabricatorMetaMTAMailBody();
	$body->addRawSection("{$name} {$verb} commit {$cname}.");
	$body->addRawSection($comment->getContent());

	if ($inline_comments) {
	$block = array();

	$path_map = id(new DiffusionPathQuery())
	->withPathIDs(mpull($inline_comments, 'getPathID'))
	->execute();
	$path_map = ipull($path_map, 'path', 'id');

	foreach ($inline_comments as $inline) {
	$path = idx($path_map, $inline->getPathID());
	if ($path === null) {
	continue;
	}

	$start = $inline->getLineNumber();
	$len = $inline->getLineLength();
	if ($len) {
	$range = $start.'-'.($start + $len);
	} else {
	$range = $start;
	}

	$content = $inline->getContent();
	$block[] = "{$path}:{$range} {$content}";
	}

	$body->addTextSection(pht('INLINE COMMENTS'), implode("\n", $block));
	}

	$body->addTextSection(
	pht('COMMIT'),
	PhabricatorEnv::getProductionURI($handle->getURI()));
	$body->addReplySection($reply_handler->getReplyHandlerInstructions());

	return $body->render();
	}

	}
	diff --git a/src/applications/conpherence/conduit/ConduitAPI_conpherence_updatethread_Method.php b/src/applications/conpherence/conduit/ConduitAPI_conpherence_updatethread_Method.php
	index 9d2022f270..229a50ce93 100644
	--- a/src/applications/conpherence/conduit/ConduitAPI_conpherence_updatethread_Method.php
	+++ b/src/applications/conpherence/conduit/ConduitAPI_conpherence_updatethread_Method.php
	@@ -1,104 +1,107 @@
	<?php

	/**
	* @group conduit
	*/
	final class ConduitAPI_conpherence_updatethread_Method
	extends ConduitAPI_conpherence_Method {

	public function getMethodDescription() {
	return pht('Update an existing conpherence thread.');
	}

	public function defineParamTypes() {
	return array(
	'id' => 'optional int',
	'phid' => 'optional phid',
	'title' => 'optional string',
	'message' => 'optional string',
	'addParticipantPHIDs' => 'optional list<phids>',
	'removeParticipantPHID' => 'optional phid'
	);
	}

	public function defineReturnType() {
	return 'bool';
	}

	public function defineErrorTypes() {
	return array(
	'ERR_USAGE_NO_THREAD_ID' => pht(
	'You must specify a thread id or thread phid to query transactions '.
	'from.'),
	'ERR_USAGE_THREAD_NOT_FOUND' => pht(
	'Thread does not exist or logged in user can not see it.'),
	'ERR_USAGE_ONLY_SELF_REMOVE' => pht(
	'Only a user can remove themselves from a thread.'),
	'ERR_USAGE_NO_UPDATES' => pht(
	'You must specify data that actually updates the conpherence.')
	);
	}

	protected function execute(ConduitAPIRequest $request) {
	$user = $request->getUser();
	$id = $request->getValue('id');
	$phid = $request->getValue('phid');
	$query = id(new ConpherenceThreadQuery())
	->setViewer($user)
	->needFilePHIDs(true);
	if ($id) {
	$query->withIDs(array($id));
	} else if ($phid) {
	$query->withPHIDs(array($phid));
	} else {
	throw new ConduitException('ERR_USAGE_NO_THREAD_ID');
	}
	$conpherence = $query->executeOne();
	if (!$conpherence) {
	throw new ConduitException('ERR_USAGE_THREAD_NOT_FOUND');
	}

	$source = PhabricatorContentSource::newFromConduitRequest($request);
	$editor = id(new ConpherenceEditor())
	->setContentSource($source)
	->setActor($user);
	$xactions = array();
	$add_participant_phids = $request->getValue('addParticipantPHIDs', array());
	$remove_participant_phid = $request->getValue('removeParticipantPHID');
	$message = $request->getValue('message');
	$title = $request->getValue('title');
	if ($add_participant_phids) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(
	ConpherenceTransactionType::TYPE_PARTICIPANTS)
	->setNewValue(array('+' => $add_participant_phids));
	}
	if ($remove_participant_phid) {
	if ($remove_participant_phid != $user->getPHID()) {
	throw new ConduitException('ERR_USAGE_ONLY_SELF_REMOVE');
	}
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(
	ConpherenceTransactionType::TYPE_PARTICIPANTS)
	->setNewValue(array('-' => array($remove_participant_phid)));
	}
	if ($title) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(ConpherenceTransactionType::TYPE_TITLE)
	->setNewValue($title);
	}
	if ($message) {
	$xactions = array_merge(
	$xactions,
	- $editor->generateTransactionsFromText($conpherence, $message));
	+ $editor->generateTransactionsFromText(
	+ $user,
	+ $conpherence,
	+ $message));
	}

	try {
	$xactions = $editor->applyTransactions($conpherence, $xactions);
	} catch (PhabricatorApplicationTransactionNoEffectException $ex) {
	throw new ConduitException('ERR_USAGE_NO_UPDATES');
	}

	return true;
	}
	}
	diff --git a/src/applications/conpherence/controller/ConpherenceUpdateController.php b/src/applications/conpherence/controller/ConpherenceUpdateController.php
	index 2b631c313e..9d87cfae15 100644
	--- a/src/applications/conpherence/controller/ConpherenceUpdateController.php
	+++ b/src/applications/conpherence/controller/ConpherenceUpdateController.php
	@@ -1,346 +1,347 @@
	<?php

	final class ConpherenceUpdateController
	extends ConpherenceController {

	private $conpherenceID;

	public function setConpherenceID($conpherence_id) {
	$this->conpherenceID = $conpherence_id;
	return $this;
	}
	public function getConpherenceID() {
	return $this->conpherenceID;
	}
	public function willProcessRequest(array $data) {
	$this->setConpherenceID(idx($data, 'id'));
	}

	public function processRequest() {
	$request = $this->getRequest();
	$user = $request->getUser();
	$conpherence_id = $this->getConpherenceID();
	if (!$conpherence_id) {
	return new Aphront404Response();
	}

	$conpherence = id(new ConpherenceThreadQuery())
	->setViewer($user)
	->withIDs(array($conpherence_id))
	->needFilePHIDs(true)
	->executeOne();

	$action = $request->getStr('action', ConpherenceUpdateActions::METADATA);
	$latest_transaction_id = null;
	$response_mode = 'ajax';
	$error_view = null;
	$e_file = array();
	$errors = array();
	$delete_draft = false;
	$xactions = array();
	if ($request->isFormPost()) {
	$editor = id(new ConpherenceEditor())
	->setContinueOnNoEffect($request->isContinueRequest())
	->setContentSourceFromRequest($request)
	->setActor($user);

	switch ($action) {
	case ConpherenceUpdateActions::DRAFT:
	$draft = PhabricatorDraft::newFromUserAndKey(
	$user,
	$conpherence->getPHID());
	$draft->setDraft($request->getStr('text'));
	$draft->replaceOrDelete();
	return new AphrontAjaxResponse();
	case ConpherenceUpdateActions::MESSAGE:
	$message = $request->getStr('text');
	$xactions = $editor->generateTransactionsFromText(
	+ $user,
	$conpherence,
	$message);
	$delete_draft = true;
	break;
	case ConpherenceUpdateActions::ADD_PERSON:
	$person_phids = $request->getArr('add_person');
	if (!empty($person_phids)) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(
	ConpherenceTransactionType::TYPE_PARTICIPANTS)
	->setNewValue(array('+' => $person_phids));
	}
	break;
	case ConpherenceUpdateActions::REMOVE_PERSON:
	if (!$request->isContinueRequest()) {
	// do nothing; we'll display a confirmation dialogue instead
	break;
	}
	$person_phid = $request->getStr('remove_person');
	if ($person_phid && $person_phid == $user->getPHID()) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(
	ConpherenceTransactionType::TYPE_PARTICIPANTS)
	->setNewValue(array('-' => array($person_phid)));
	$response_mode = 'go-home';
	}
	break;
	case ConpherenceUpdateActions::NOTIFICATIONS:
	$notifications = $request->getStr('notifications');
	$participant = $conpherence->getParticipant($user->getPHID());
	$participant->setSettings(array('notifications' => $notifications));
	$participant->save();
	$result = pht(
	'Updated notification settings to "%s".',
	ConpherenceSettings::getHumanString($notifications));
	return id(new AphrontAjaxResponse())
	->setContent($result);
	break;
	case ConpherenceUpdateActions::METADATA:
	$updated = false;
	// all metadata updates are continue requests
	if (!$request->isContinueRequest()) {
	break;
	}

	$title = $request->getStr('title');
	if ($title != $conpherence->getTitle()) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(ConpherenceTransactionType::TYPE_TITLE)
	->setNewValue($title);
	$updated = true;
	$response_mode = 'redirect';
	}
	if (!$updated) {
	$errors[] = pht(
	'That was a non-update. Try cancel.');
	}
	break;
	default:
	throw new Exception('Unknown action: '.$action);
	break;
	}
	if ($xactions) {
	try {
	$xactions = $editor->applyTransactions($conpherence, $xactions);
	if ($delete_draft) {
	$draft = PhabricatorDraft::newFromUserAndKey(
	$user,
	$conpherence->getPHID());
	$draft->delete();
	}
	} catch (PhabricatorApplicationTransactionNoEffectException $ex) {
	return id(new PhabricatorApplicationTransactionNoEffectResponse())
	->setCancelURI($this->getApplicationURI($conpherence_id.'/'))
	->setException($ex);
	}
	switch ($response_mode) {
	case 'ajax':
	$latest_transaction_id = $request->getInt('latest_transaction_id');
	$content = $this->loadAndRenderUpdates(
	$action,
	$conpherence_id,
	$latest_transaction_id);
	return id(new AphrontAjaxResponse())
	->setContent($content);
	break;
	case 'go-home':
	return id(new AphrontRedirectResponse())
	->setURI($this->getApplicationURI());
	break;
	case 'redirect':
	default:
	return id(new AphrontRedirectResponse())
	->setURI($this->getApplicationURI($conpherence->getID().'/'));
	break;
	}
	}
	}

	if ($errors) {
	$error_view = id(new AphrontErrorView())
	->setErrors($errors);
	}

	switch ($action) {
	case ConpherenceUpdateActions::ADD_PERSON:
	$dialogue = $this->renderAddPersonDialogue($conpherence);
	break;
	case ConpherenceUpdateActions::REMOVE_PERSON:
	$dialogue = $this->renderRemovePersonDialogue($conpherence);
	break;
	case ConpherenceUpdateActions::METADATA:
	default:
	$dialogue = $this->renderMetadataDialogue($conpherence, $error_view);
	break;
	}

	return id(new AphrontDialogResponse())
	->setDialog($dialogue
	->setUser($user)
	->setWidth(AphrontDialogView::WIDTH_FORM)
	->setSubmitURI($this->getApplicationURI('update/'.$conpherence_id.'/'))
	->addSubmitButton()
	->addCancelButton($this->getApplicationURI($conpherence->getID().'/')));

	}

	private function renderAddPersonDialogue(
	ConpherenceThread $conpherence) {

	$request = $this->getRequest();
	$user = $request->getUser();
	$add_person = $request->getStr('add_person');

	$form = id(new PHUIFormLayoutView())
	->setUser($user)
	->setFullWidth(true)
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setName('add_person')
	->setUser($user)
	->setDatasource('/typeahead/common/users/'));

	require_celerity_resource('conpherence-update-css');
	return id(new AphrontDialogView())
	->setTitle(pht('Add Participants'))
	->addHiddenInput('action', 'add_person')
	->appendChild($form);
	}

	private function renderRemovePersonDialogue(
	ConpherenceThread $conpherence) {

	$request = $this->getRequest();
	$user = $request->getUser();
	$remove_person = $request->getStr('remove_person');
	$participants = $conpherence->getParticipants();
	$message = pht(
	'Are you sure you want to remove yourself from this conpherence? ');
	if (count($participants) == 1) {
	$message .= pht(
	'The conpherence will be inaccessible forever and ever.');
	} else {
	$message .= pht(
	'Someone else in the conpherence can add you back later.');
	}
	$body = phutil_tag(
	'p',
	array(
	),
	$message);

	require_celerity_resource('conpherence-update-css');
	return id(new AphrontDialogView())
	->setTitle(pht('Remove Participants'))
	->addHiddenInput('action', 'remove_person')
	->addHiddenInput('__continue__', true)
	->addHiddenInput('remove_person', $remove_person)
	->appendChild($body);
	}

	private function renderMetadataDialogue(
	ConpherenceThread $conpherence,
	$error_view) {

	$form = id(new PHUIFormLayoutView())
	->appendChild($error_view)
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Title'))
	->setName('title')
	->setValue($conpherence->getTitle()));

	require_celerity_resource('conpherence-update-css');
	return id(new AphrontDialogView())
	->setTitle(pht('Update Conpherence'))
	->addHiddenInput('action', 'metadata')
	->addHiddenInput('__continue__', true)
	->appendChild($form);
	}

	private function loadAndRenderUpdates(
	$action,
	$conpherence_id,
	$latest_transaction_id) {

	$need_widget_data = false;
	$need_transactions = false;
	switch ($action) {
	case ConpherenceUpdateActions::METADATA:
	$need_transactions = true;
	break;
	case ConpherenceUpdateActions::MESSAGE:
	case ConpherenceUpdateActions::ADD_PERSON:
	$need_transactions = true;
	$need_widget_data = true;
	break;
	case ConpherenceUpdateActions::REMOVE_PERSON:
	case ConpherenceUpdateActions::NOTIFICATIONS:
	default:
	break;

	}
	$user = $this->getRequest()->getUser();
	$conpherence = id(new ConpherenceThreadQuery())
	->setViewer($user)
	->setAfterTransactionID($latest_transaction_id)
	->needWidgetData($need_widget_data)
	->needTransactions($need_transactions)
	->withIDs(array($conpherence_id))
	->executeOne();

	if ($need_transactions) {
	$data = $this->renderConpherenceTransactions($conpherence);
	} else {
	$data = array();
	}
	$rendered_transactions = idx($data, 'transactions');
	$new_latest_transaction_id = idx($data, 'latest_transaction_id');

	$widget_uri = $this->getApplicationURI('update/'.$conpherence->getID().'/');
	$nav_item = null;
	$header = null;
	$people_widget = null;
	$file_widget = null;
	switch ($action) {
	case ConpherenceUpdateActions::METADATA:
	$header = $this->buildHeaderPaneContent($conpherence);
	$nav_item = id(new ConpherenceThreadListView())
	->setUser($user)
	->setBaseURI($this->getApplicationURI())
	->renderSingleThread($conpherence);
	break;
	case ConpherenceUpdateActions::MESSAGE:
	$file_widget = id(new ConpherenceFileWidgetView())
	->setUser($this->getRequest()->getUser())
	->setConpherence($conpherence)
	->setUpdateURI($widget_uri);
	break;
	case ConpherenceUpdateActions::ADD_PERSON:
	$people_widget = id(new ConpherencePeopleWidgetView())
	->setUser($user)
	->setConpherence($conpherence)
	->setUpdateURI($widget_uri);
	break;
	case ConpherenceUpdateActions::REMOVE_PERSON:
	case ConpherenceUpdateActions::NOTIFICATIONS:
	default:
	break;
	}

	$people_html = null;
	if ($people_widget) {
	$people_html = hsprintf('%s', $people_widget->render());
	}
	$content = array(
	'transactions' => hsprintf('%s', $rendered_transactions),
	'latest_transaction_id' => $new_latest_transaction_id,
	'nav_item' => hsprintf('%s', $nav_item),
	'conpherence_phid' => $conpherence->getPHID(),
	'header' => hsprintf('%s', $header),
	'file_widget' => $file_widget ? $file_widget->render() : null,
	'people_widget' => $people_html,
	);

	return $content;
	}

	}
	diff --git a/src/applications/conpherence/editor/ConpherenceEditor.php b/src/applications/conpherence/editor/ConpherenceEditor.php
	index 249a87836e..813fda858d 100644
	--- a/src/applications/conpherence/editor/ConpherenceEditor.php
	+++ b/src/applications/conpherence/editor/ConpherenceEditor.php
	@@ -1,412 +1,413 @@
	<?php

	/**
	* @group conpherence
	*/
	final class ConpherenceEditor extends PhabricatorApplicationTransactionEditor {

	const ERROR_EMPTY_PARTICIPANTS = 'error-empty-participants';
	const ERROR_EMPTY_MESSAGE = 'error-empty-message';

	public static function createConpherence(
	PhabricatorUser $creator,
	array $participant_phids,
	$title,
	$message,
	PhabricatorContentSource $source) {

	$conpherence = id(new ConpherenceThread())
	->attachParticipants(array())
	->attachFilePHIDs(array())
	->setMessageCount(0);
	$files = array();
	$errors = array();
	if (empty($participant_phids)) {
	$errors[] = self::ERROR_EMPTY_PARTICIPANTS;
	} else {
	$participant_phids[] = $creator->getPHID();
	$participant_phids = array_unique($participant_phids);
	$conpherence->setRecentParticipantPHIDs(
	array_slice($participant_phids, 0, 10));
	}

	if (empty($message)) {
	$errors[] = self::ERROR_EMPTY_MESSAGE;
	}

	- $file_phids =
	- PhabricatorMarkupEngine::extractFilePHIDsFromEmbeddedFiles(
	- array($message));
	+ $file_phids = PhabricatorMarkupEngine::extractFilePHIDsFromEmbeddedFiles(
	+ $creator,
	+ array($message));
	if ($file_phids) {
	$files = id(new PhabricatorFileQuery())
	->setViewer($creator)
	->withPHIDs($file_phids)
	->execute();
	}

	if (!$errors) {
	$xactions = array();
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(ConpherenceTransactionType::TYPE_PARTICIPANTS)
	->setNewValue(array('+' => $participant_phids));
	if ($files) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(ConpherenceTransactionType::TYPE_FILES)
	->setNewValue(array('+' => mpull($files, 'getPHID')));
	}
	if ($title) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(ConpherenceTransactionType::TYPE_TITLE)
	->setNewValue($title);
	}
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(new ConpherenceTransactionComment())
	->setContent($message)
	->setConpherencePHID($conpherence->getPHID()));

	id(new ConpherenceEditor())
	->setContentSource($source)
	->setContinueOnNoEffect(true)
	->setActor($creator)
	->applyTransactions($conpherence, $xactions);

	}

	return array($errors, $conpherence);
	}

	public function generateTransactionsFromText(
	+ PhabricatorUser $viewer,
	ConpherenceThread $conpherence,
	$text) {

	$files = array();
	- $file_phids =
	- PhabricatorMarkupEngine::extractFilePHIDsFromEmbeddedFiles(
	- array($text));
	+ $file_phids = PhabricatorMarkupEngine::extractFilePHIDsFromEmbeddedFiles(
	+ $viewer,
	+ array($text));
	// Since these are extracted from text, we might be re-including the
	// same file -- e.g. a mock under discussion. Filter files we
	// already have.
	$existing_file_phids = $conpherence->getFilePHIDs();
	$file_phids = array_diff($file_phids, $existing_file_phids);
	if ($file_phids) {
	$files = id(new PhabricatorFileQuery())
	->setViewer($this->getActor())
	->withPHIDs($file_phids)
	->execute();
	}
	$xactions = array();
	if ($files) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(ConpherenceTransactionType::TYPE_FILES)
	->setNewValue(array('+' => mpull($files, 'getPHID')));
	}
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(new ConpherenceTransactionComment())
	->setContent($text)
	->setConpherencePHID($conpherence->getPHID()));
	return $xactions;
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();

	$types[] = PhabricatorTransactions::TYPE_COMMENT;

	$types[] = ConpherenceTransactionType::TYPE_TITLE;
	$types[] = ConpherenceTransactionType::TYPE_PARTICIPANTS;
	$types[] = ConpherenceTransactionType::TYPE_FILES;

	return $types;
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ConpherenceTransactionType::TYPE_TITLE:
	return $object->getTitle();
	case ConpherenceTransactionType::TYPE_PARTICIPANTS:
	return $object->getParticipantPHIDs();
	case ConpherenceTransactionType::TYPE_FILES:
	return $object->getFilePHIDs();
	}
	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ConpherenceTransactionType::TYPE_TITLE:
	return $xaction->getNewValue();
	case ConpherenceTransactionType::TYPE_PARTICIPANTS:
	case ConpherenceTransactionType::TYPE_FILES:
	return $this->getPHIDTransactionNewValue($xaction);
	}
	}

	/**
	* We really only need a read lock if we have a comment. In that case, we
	* must update the messagesCount field on the conpherence and
	* seenMessagesCount(s) for the participant(s).
	*/
	protected function shouldReadLock(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$lock = false;
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	$lock = true;
	break;
	}

	return $lock;
	}

	/**
	* We need to apply initial effects IFF the conpherence is new. We must
	* save the conpherence first thing to make sure we have an id and a phid.
	*/
	protected function shouldApplyInitialEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {

	return !$object->getID();
	}

	protected function applyInitialEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$object->save();
	}

	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	$object->setMessageCount((int)$object->getMessageCount() + 1);
	break;
	case ConpherenceTransactionType::TYPE_TITLE:
	$object->setTitle($xaction->getNewValue());
	break;
	}
	$this->updateRecentParticipantPHIDs($object, $xaction);
	}

	private function updateRecentParticipantPHIDs(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$participants = $object->getRecentParticipantPHIDs();
	array_unshift($participants, $xaction->getAuthorPHID());
	$participants = array_slice(array_unique($participants), 0, 10);

	$object->setRecentParticipantPHIDs($participants);
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ConpherenceTransactionType::TYPE_FILES:
	$editor = id(new PhabricatorEdgeEditor())
	->setActor($this->getActor());
	$edge_type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_FILE;
	$old = array_fill_keys($xaction->getOldValue(), true);
	$new = array_fill_keys($xaction->getNewValue(), true);
	$add_edges = array_keys(array_diff_key($new, $old));
	$remove_edges = array_keys(array_diff_key($old, $new));
	foreach ($add_edges as $file_phid) {
	$editor->addEdge(
	$object->getPHID(),
	$edge_type,
	$file_phid);
	}
	foreach ($remove_edges as $file_phid) {
	$editor->removeEdge(
	$object->getPHID(),
	$edge_type,
	$file_phid);
	}
	$editor->save();
	break;
	case ConpherenceTransactionType::TYPE_PARTICIPANTS:
	$participants = $object->getParticipants();

	$old_map = array_fuse($xaction->getOldValue());
	$new_map = array_fuse($xaction->getNewValue());

	$remove = array_keys(array_diff_key($old_map, $new_map));
	foreach ($remove as $phid) {
	$remove_participant = $participants[$phid];
	$remove_participant->delete();
	unset($participants[$phid]);
	}

	$add = array_keys(array_diff_key($new_map, $old_map));
	foreach ($add as $phid) {
	if ($phid == $this->getActor()->getPHID()) {
	$status = ConpherenceParticipationStatus::UP_TO_DATE;
	$message_count = $object->getMessageCount();
	} else {
	$status = ConpherenceParticipationStatus::BEHIND;
	$message_count = 0;
	}
	$participants[$phid] =
	id(new ConpherenceParticipant())
	->setConpherencePHID($object->getPHID())
	->setParticipantPHID($phid)
	->setParticipationStatus($status)
	->setDateTouched(time())
	->setBehindTransactionPHID($xaction->getPHID())
	->setSeenMessageCount($message_count)
	->save();
	}
	$object->attachParticipants($participants);
	break;
	}
	}

	protected function applyFinalEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {

	// update everyone's participation status on the last xaction -only-
	$xaction = end($xactions);
	$xaction_phid = $xaction->getPHID();
	$behind = ConpherenceParticipationStatus::BEHIND;
	$up_to_date = ConpherenceParticipationStatus::UP_TO_DATE;
	$participants = $object->getParticipants();
	$user = $this->getActor();
	$time = time();
	foreach ($participants as $phid => $participant) {
	if ($phid != $user->getPHID()) {
	if ($participant->getParticipationStatus() != $behind) {
	$participant->setBehindTransactionPHID($xaction_phid);
	// decrement one as this is the message putting them behind!
	$participant->setSeenMessageCount($object->getMessageCount() - 1);
	}
	$participant->setParticipationStatus($behind);
	$participant->setDateTouched($time);
	} else {
	$participant->setSeenMessageCount($object->getMessageCount());
	$participant->setParticipationStatus($up_to_date);
	$participant->setDateTouched($time);
	}
	$participant->save();
	}

	return $xactions;
	}

	protected function mergeTransactions(
	PhabricatorApplicationTransaction $u,
	PhabricatorApplicationTransaction $v) {

	$type = $u->getTransactionType();
	switch ($type) {
	case ConpherenceTransactionType::TYPE_TITLE:
	return $v;
	case ConpherenceTransactionType::TYPE_FILES:
	case ConpherenceTransactionType::TYPE_PARTICIPANTS:
	return $this->mergePHIDOrEdgeTransactions($u, $v);
	}

	return parent::mergeTransactions($u, $v);
	}

	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return true;
	}

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	return id(new ConpherenceReplyHandler())
	->setActor($this->getActor())
	->setMailReceiver($object);
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$title = $object->getTitle();
	if (!$title) {
	$title = pht(
	'%s sent you a message.',
	$this->getActor()->getUserName());
	}
	$phid = $object->getPHID();

	return id(new PhabricatorMetaMTAMail())
	->setSubject("E{$id}: {$title}")
	->addHeader('Thread-Topic', "E{$id}: {$phid}");
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$to_phids = array();
	$participants = $object->getParticipants();
	if (empty($participants)) {
	return $to_phids;
	}
	$preferences = id(new PhabricatorUserPreferences())
	->loadAllWhere('userPHID in (%Ls)', array_keys($participants));
	$preferences = mpull($preferences, null, 'getUserPHID');
	foreach ($participants as $phid => $participant) {
	$default = ConpherenceSettings::EMAIL_ALWAYS;
	$preference = idx($preferences, $phid);
	if ($preference) {
	$default = $preference->getPreference(
	PhabricatorUserPreferences::PREFERENCE_CONPH_NOTIFICATIONS,
	ConpherenceSettings::EMAIL_ALWAYS);
	}
	$settings = $participant->getSettings();
	$notifications = idx(
	$settings,
	'notifications',
	$default);
	if ($notifications == ConpherenceSettings::EMAIL_ALWAYS) {
	$to_phids[] = $phid;
	}
	}
	return $to_phids;
	}

	protected function getMailCC(PhabricatorLiskDAO $object) {
	return array();
	}

	protected function buildMailBody(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$body = parent::buildMailBody($object, $xactions);
	$body->addTextSection(
	pht('CONPHERENCE DETAIL'),
	PhabricatorEnv::getProductionURI('/conpherence/'.$object->getID().'/'));

	return $body;
	}

	protected function getMailSubjectPrefix() {
	return PhabricatorEnv::getEnvConfig('metamta.conpherence.subject-prefix');
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return false;
	}

	protected function supportsSearch() {
	return false;
	}
	}
	diff --git a/src/applications/conpherence/mail/ConpherenceReplyHandler.php b/src/applications/conpherence/mail/ConpherenceReplyHandler.php
	index 5641d9d38c..6c57db0700 100644
	--- a/src/applications/conpherence/mail/ConpherenceReplyHandler.php
	+++ b/src/applications/conpherence/mail/ConpherenceReplyHandler.php
	@@ -1,93 +1,94 @@
	<?php

	final class ConpherenceReplyHandler extends PhabricatorMailReplyHandler {

	private $mailAddedParticipantPHIDs;

	public function setMailAddedParticipantPHIDs(array $phids) {
	$this->mailAddedParticipantPHIDs = $phids;
	return $this;
	}
	public function getMailAddedParticipantPHIDs() {
	return $this->mailAddedParticipantPHIDs;
	}

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof ConpherenceThread)) {
	throw new Exception("Mail receiver is not a ConpherenceThread!");
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'E');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('E');
	}

	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	return pht('Reply to comment and attach files.');
	} else {
	return null;
	}
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	$conpherence = $this->getMailReceiver();
	$user = $this->getActor();
	if (!$conpherence->getPHID()) {
	$conpherence
	->attachParticipants(array())
	->attachFilePHIDs(array());
	} else {
	$edge_type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_FILE;
	$file_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$conpherence->getPHID(),
	$edge_type);
	$conpherence->attachFilePHIDs($file_phids);
	$participants = id(new ConpherenceParticipant())
	->loadAllWhere('conpherencePHID = %s', $conpherence->getPHID());
	$participants = mpull($participants, null, 'getParticipantPHID');
	$conpherence->attachParticipants($participants);
	}

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_EMAIL,
	array(
	'id' => $mail->getID(),
	));

	$editor = id(new ConpherenceEditor())
	->setActor($user)
	->setContentSource($content_source)
	->setParentMessageID($mail->getMessageID());

	$body = $mail->getCleanTextBody();
	$file_phids = $mail->getAttachments();
	$body = $this->enhanceBodyWithAttachments(
	$body,
	$file_phids,
	'{F%d}');

	$xactions = array();
	if ($this->getMailAddedParticipantPHIDs()) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(ConpherenceTransactionType::TYPE_PARTICIPANTS)
	->setNewValue(array('+' => $this->getMailAddedParticipantPHIDs()));
	}

	$xactions = array_merge(
	$xactions,
	$editor->generateTransactionsFromText(
	+ $user,
	$conpherence,
	$body));

	$editor->applyTransactions($conpherence, $xactions);

	return $conpherence;
	}

	}
	diff --git a/src/applications/maniphest/controller/ManiphestTransactionSaveController.php b/src/applications/maniphest/controller/ManiphestTransactionSaveController.php
	index 48686842e6..3a623612d4 100644
	--- a/src/applications/maniphest/controller/ManiphestTransactionSaveController.php
	+++ b/src/applications/maniphest/controller/ManiphestTransactionSaveController.php
	@@ -1,213 +1,214 @@
	<?php

	final class ManiphestTransactionSaveController extends ManiphestController {

	public function processRequest() {
	$request = $this->getRequest();
	$user = $request->getUser();

	$task = id(new ManiphestTaskQuery())
	->setViewer($user)
	->withIDs(array($request->getStr('taskID')))
	->executeOne();
	if (!$task) {
	return new Aphront404Response();
	}

	$task_uri = '/'.$task->getMonogram();

	$transactions = array();

	$action = $request->getStr('action');

	// Compute new CCs added by @mentions. Several things can cause CCs to
	// be added as side effects: mentions, explicit CCs, users who aren't
	// CC'd interacting with the task, and ownership changes. We build up a
	// list of all the CCs and then construct a transaction for them at the
	// end if necessary.
	$added_ccs = PhabricatorMarkupEngine::extractPHIDsFromMentions(
	+ $user,
	array(
	$request->getStr('comments'),
	));

	$cc_transaction = new ManiphestTransaction();
	$cc_transaction
	->setTransactionType(ManiphestTransaction::TYPE_CCS);

	$transaction = new ManiphestTransaction();
	$transaction
	->setTransactionType($action);

	switch ($action) {
	case ManiphestTransaction::TYPE_STATUS:
	$transaction->setNewValue($request->getStr('resolution'));
	break;
	case ManiphestTransaction::TYPE_OWNER:
	$assign_to = $request->getArr('assign_to');
	$assign_to = reset($assign_to);
	$transaction->setNewValue($assign_to);
	break;
	case ManiphestTransaction::TYPE_PROJECTS:
	$projects = $request->getArr('projects');
	$projects = array_merge($projects, $task->getProjectPHIDs());
	$projects = array_filter($projects);
	$projects = array_unique($projects);
	$transaction->setNewValue($projects);
	break;
	case ManiphestTransaction::TYPE_CCS:
	// Accumulate the new explicit CCs into the array that we'll add in
	// the CC transaction later.
	$added_ccs = array_merge($added_ccs, $request->getArr('ccs'));

	// Throw away the primary transaction.
	$transaction = null;
	break;
	case ManiphestTransaction::TYPE_PRIORITY:
	$transaction->setNewValue($request->getInt('priority'));
	break;
	case PhabricatorTransactions::TYPE_COMMENT:
	// Nuke this, we're going to create it below.
	$transaction = null;
	break;
	default:
	throw new Exception('unknown action');
	}

	if ($transaction) {
	$transactions[] = $transaction;
	}

	$resolution = $request->getStr('resolution');
	$did_scuttle = false;
	if ($action !== ManiphestTransaction::TYPE_STATUS) {
	if ($request->getStr('scuttle')) {
	$transactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_STATUS)
	->setNewValue(ManiphestTaskStatus::getDefaultClosedStatus());
	$did_scuttle = true;
	$resolution = ManiphestTaskStatus::getDefaultClosedStatus();
	}
	}

	// When you interact with a task, we add you to the CC list so you get
	// further updates, and possibly assign the task to you if you took an
	// ownership action (closing it) but it's currently unowned. We also move
	// previous owners to CC if ownership changes. Detect all these conditions
	// and create side-effect transactions for them.

	$implicitly_claimed = false;
	if ($action == ManiphestTransaction::TYPE_OWNER) {
	if ($task->getOwnerPHID() == $transaction->getNewValue()) {
	// If this is actually no-op, don't generate the side effect.
	} else {
	// Otherwise, when a task is reassigned, move the previous owner to CC.
	$added_ccs[] = $task->getOwnerPHID();
	}
	}

	if ($did_scuttle \|\| ($action == ManiphestTransaction::TYPE_STATUS)) {
	if (!$task->getOwnerPHID() &&
	ManiphestTaskStatus::isClosedStatus($resolution)) {
	// Closing an unassigned task. Assign the user as the owner of
	// this task.
	$assign = new ManiphestTransaction();
	$assign->setTransactionType(ManiphestTransaction::TYPE_OWNER);
	$assign->setNewValue($user->getPHID());
	$transactions[] = $assign;

	$implicitly_claimed = true;
	}
	}

	$user_owns_task = false;
	if ($implicitly_claimed) {
	$user_owns_task = true;
	} else {
	if ($action == ManiphestTransaction::TYPE_OWNER) {
	if ($transaction->getNewValue() == $user->getPHID()) {
	$user_owns_task = true;
	}
	} else if ($task->getOwnerPHID() == $user->getPHID()) {
	$user_owns_task = true;
	}
	}

	if (!$user_owns_task) {
	// If we aren't making the user the new task owner and they aren't the
	// existing task owner, add them to CC unless they're aleady CC'd.
	if (!in_array($user->getPHID(), $task->getCCPHIDs())) {
	$added_ccs[] = $user->getPHID();
	}
	}

	// Evade no-effect detection in the new editor stuff until we can switch
	// to subscriptions.
	$added_ccs = array_filter(array_diff($added_ccs, $task->getCCPHIDs()));

	if ($added_ccs) {
	// We've added CCs, so include a CC transaction.
	$all_ccs = array_merge($task->getCCPHIDs(), $added_ccs);
	$cc_transaction->setNewValue($all_ccs);
	$transactions[] = $cc_transaction;
	}

	$comments = $request->getStr('comments');
	if (strlen($comments) \|\| !$transactions) {
	$transactions[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(new ManiphestTransactionComment())
	->setContent($comments));
	}

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_MANIPHEST_WILLEDITTASK,
	array(
	'task' => $task,
	'new' => false,
	'transactions' => $transactions,
	));
	$event->setUser($user);
	$event->setAphrontRequest($request);
	PhutilEventEngine::dispatchEvent($event);

	$task = $event->getValue('task');
	$transactions = $event->getValue('transactions');

	$editor = id(new ManiphestTransactionEditor())
	->setActor($user)
	->setContentSourceFromRequest($request)
	->setContinueOnMissingFields(true)
	->setContinueOnNoEffect($request->isContinueRequest());

	try {
	$editor->applyTransactions($task, $transactions);
	} catch (PhabricatorApplicationTransactionNoEffectException $ex) {
	return id(new PhabricatorApplicationTransactionNoEffectResponse())
	->setCancelURI($task_uri)
	->setException($ex);
	}

	$draft = id(new PhabricatorDraft())->loadOneWhere(
	'authorPHID = %s AND draftKey = %s',
	$user->getPHID(),
	$task->getPHID());
	if ($draft) {
	$draft->delete();
	}

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_MANIPHEST_DIDEDITTASK,
	array(
	'task' => $task,
	'new' => false,
	'transactions' => $transactions,
	));
	$event->setUser($user);
	$event->setAphrontRequest($request);
	PhutilEventEngine::dispatchEvent($event);

	return id(new AphrontRedirectResponse())->setURI($task_uri);
	}

	}
	diff --git a/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php b/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
	index dc43764c7d..ff1399fd46 100644
	--- a/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
	+++ b/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
	@@ -1,2240 +1,2243 @@
	<?php

	/**
	* @task mail Sending Mail
	* @task feed Publishing Feed Stories
	* @task search Search Index
	* @task files Integration with Files
	*/
	abstract class PhabricatorApplicationTransactionEditor
	extends PhabricatorEditor {

	private $contentSource;
	private $object;
	private $xactions;

	private $isNewObject;
	private $mentionedPHIDs;
	private $continueOnNoEffect;
	private $continueOnMissingFields;
	private $parentMessageID;
	private $heraldAdapter;
	private $heraldTranscript;
	private $subscribers;

	private $isPreview;
	private $isHeraldEditor;
	private $actingAsPHID;
	private $disableEmail;

	public function setActingAsPHID($acting_as_phid) {
	$this->actingAsPHID = $acting_as_phid;
	return $this;
	}

	public function getActingAsPHID() {
	if ($this->actingAsPHID) {
	return $this->actingAsPHID;
	}
	return $this->getActor()->getPHID();
	}

	/**
	* When the editor tries to apply transactions that have no effect, should
	* it raise an exception (default) or drop them and continue?
	*
	* Generally, you will set this flag for edits coming from "Edit" interfaces,
	* and leave it cleared for edits coming from "Comment" interfaces, so the
	* user will get a useful error if they try to submit a comment that does
	* nothing (e.g., empty comment with a status change that has already been
	* performed by another user).
	*
	* @param bool True to drop transactions without effect and continue.
	* @return this
	*/
	public function setContinueOnNoEffect($continue) {
	$this->continueOnNoEffect = $continue;
	return $this;
	}

	public function getContinueOnNoEffect() {
	return $this->continueOnNoEffect;
	}


	/**
	* When the editor tries to apply transactions which don't populate all of
	* an object's required fields, should it raise an exception (default) or
	* drop them and continue?
	*
	* For example, if a user adds a new required custom field (like "Severity")
	* to a task, all existing tasks won't have it populated. When users
	* manually edit existing tasks, it's usually desirable to have them provide
	* a severity. However, other operations (like batch editing just the
	* owner of a task) will fail by default.
	*
	* By setting this flag for edit operations which apply to specific fields
	* (like the priority, batch, and merge editors in Maniphest), these
	* operations can continue to function even if an object is outdated.
	*
	* @param bool True to continue when transactions don't completely satisfy
	* all required fields.
	* @return this
	*/
	public function setContinueOnMissingFields($continue_on_missing_fields) {
	$this->continueOnMissingFields = $continue_on_missing_fields;
	return $this;
	}

	public function getContinueOnMissingFields() {
	return $this->continueOnMissingFields;
	}


	/**
	* Not strictly necessary, but reply handlers ideally set this value to
	* make email threading work better.
	*/
	public function setParentMessageID($parent_message_id) {
	$this->parentMessageID = $parent_message_id;
	return $this;
	}
	public function getParentMessageID() {
	return $this->parentMessageID;
	}

	public function getIsNewObject() {
	return $this->isNewObject;
	}

	protected function getMentionedPHIDs() {
	return $this->mentionedPHIDs;
	}

	public function setIsPreview($is_preview) {
	$this->isPreview = $is_preview;
	return $this;
	}

	public function getIsPreview() {
	return $this->isPreview;
	}

	public function setIsHeraldEditor($is_herald_editor) {
	$this->isHeraldEditor = $is_herald_editor;
	return $this;
	}

	public function getIsHeraldEditor() {
	return $this->isHeraldEditor;
	}

	/**
	* Prevent this editor from generating email when applying transactions.
	*
	* @param bool True to disable email.
	* @return this
	*/
	public function setDisableEmail($disable_email) {
	$this->disableEmail = $disable_email;
	return $this;
	}

	public function getDisableEmail() {
	return $this->disableEmail;
	}

	public function getTransactionTypes() {
	$types = array();

	if ($this->object instanceof PhabricatorSubscribableInterface) {
	$types[] = PhabricatorTransactions::TYPE_SUBSCRIBERS;
	}

	if ($this->object instanceof PhabricatorCustomFieldInterface) {
	$types[] = PhabricatorTransactions::TYPE_CUSTOMFIELD;
	}

	if ($this->object instanceof HarbormasterBuildableInterface) {
	$types[] = PhabricatorTransactions::TYPE_BUILDABLE;
	}

	if ($this->object instanceof PhabricatorTokenReceiverInterface) {
	$types[] = PhabricatorTransactions::TYPE_TOKEN;
	}

	return $types;
	}

	private function adjustTransactionValues(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	if ($xaction->shouldGenerateOldValue()) {
	$old = $this->getTransactionOldValue($object, $xaction);
	$xaction->setOldValue($old);
	}

	$new = $this->getTransactionNewValue($object, $xaction);
	$xaction->setNewValue($new);
	}

	private function getTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return array_values($this->subscribers);
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	return $object->getViewPolicy();
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return $object->getEditPolicy();
	case PhabricatorTransactions::TYPE_JOIN_POLICY:
	return $object->getJoinPolicy();
	case PhabricatorTransactions::TYPE_EDGE:
	$edge_type = $xaction->getMetadataValue('edge:type');
	if (!$edge_type) {
	throw new Exception("Edge transaction has no 'edge:type'!");
	}

	$old_edges = array();
	if ($object->getPHID()) {
	$edge_src = $object->getPHID();

	$old_edges = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(array($edge_src))
	->withEdgeTypes(array($edge_type))
	->needEdgeData(true)
	->execute();

	$old_edges = $old_edges[$edge_src][$edge_type];
	}
	return $old_edges;
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	// NOTE: Custom fields have their old value pre-populated when they are
	// built by PhabricatorCustomFieldList.
	return $xaction->getOldValue();
	case PhabricatorTransactions::TYPE_COMMENT:
	return null;
	default:
	return $this->getCustomTransactionOldValue($object, $xaction);
	}
	}

	private function getTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return $this->getPHIDTransactionNewValue($xaction);
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	case PhabricatorTransactions::TYPE_JOIN_POLICY:
	case PhabricatorTransactions::TYPE_BUILDABLE:
	case PhabricatorTransactions::TYPE_TOKEN:
	return $xaction->getNewValue();
	case PhabricatorTransactions::TYPE_EDGE:
	return $this->getEdgeTransactionNewValue($xaction);
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getCustomFieldForTransaction($object, $xaction);
	return $field->getNewValueFromApplicationTransactions($xaction);
	case PhabricatorTransactions::TYPE_COMMENT:
	return null;
	default:
	return $this->getCustomTransactionNewValue($object, $xaction);
	}
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	throw new Exception("Capability not supported!");
	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	throw new Exception("Capability not supported!");
	}

	protected function transactionHasEffect(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return $xaction->hasComment();
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getCustomFieldForTransaction($object, $xaction);
	return $field->getApplicationTransactionHasEffect($xaction);
	case PhabricatorTransactions::TYPE_EDGE:
	// A straight value comparison here doesn't always get the right
	// result, because newly added edges aren't fully populated. Instead,
	// compare the changes in a more granular way.
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	$old_dst = array_keys($old);
	$new_dst = array_keys($new);

	// NOTE: For now, we don't consider edge reordering to be a change.
	// We have very few order-dependent edges and effectively no order
	// oriented UI. This might change in the future.
	sort($old_dst);
	sort($new_dst);

	if ($old_dst !== $new_dst) {
	// We've added or removed edges, so this transaction definitely
	// has an effect.
	return true;
	}

	// We haven't added or removed edges, but we might have changed
	// edge data.
	foreach ($old as $key => $old_value) {
	$new_value = $new[$key];
	if ($old_value['data'] !== $new_value['data']) {
	return true;
	}
	}

	return false;
	}

	return ($xaction->getOldValue() !== $xaction->getNewValue());
	}

	protected function shouldApplyInitialEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return false;
	}

	protected function applyInitialEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {
	throw new Exception('Not implemented.');
	}

	private function applyInternalEffects(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_BUILDABLE:
	case PhabricatorTransactions::TYPE_TOKEN:
	return;
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	$object->setViewPolicy($xaction->getNewValue());
	break;
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	$object->setEditPolicy($xaction->getNewValue());
	break;
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getCustomFieldForTransaction($object, $xaction);
	return $field->applyApplicationTransactionInternalEffects($xaction);
	}

	return $this->applyCustomInternalTransaction($object, $xaction);
	}

	private function applyExternalEffects(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_BUILDABLE:
	case PhabricatorTransactions::TYPE_TOKEN:
	return;
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	$subeditor = id(new PhabricatorSubscriptionsEditor())
	->setObject($object)
	->setActor($this->requireActor());

	$old_map = array_fuse($xaction->getOldValue());
	$new_map = array_fuse($xaction->getNewValue());

	$subeditor->unsubscribe(
	array_keys(
	array_diff_key($old_map, $new_map)));

	$subeditor->subscribeExplicit(
	array_keys(
	array_diff_key($new_map, $old_map)));

	$subeditor->save();

	// for the rest of these edits, subscribers should include those just
	// added as well as those just removed.
	$subscribers = array_unique(array_merge(
	$this->subscribers,
	$xaction->getOldValue(),
	$xaction->getNewValue()));
	$this->subscribers = $subscribers;

	break;
	case PhabricatorTransactions::TYPE_EDGE:
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();
	$src = $object->getPHID();
	$type = $xaction->getMetadataValue('edge:type');

	foreach ($new as $dst_phid => $edge) {
	$new[$dst_phid]['src'] = $src;
	}

	$editor = id(new PhabricatorEdgeEditor())
	->setActor($this->getActor());

	foreach ($old as $dst_phid => $edge) {
	if (!empty($new[$dst_phid])) {
	if ($old[$dst_phid]['data'] === $new[$dst_phid]['data']) {
	continue;
	}
	}
	$editor->removeEdge($src, $type, $dst_phid);
	}

	foreach ($new as $dst_phid => $edge) {
	if (!empty($old[$dst_phid])) {
	if ($old[$dst_phid]['data'] === $new[$dst_phid]['data']) {
	continue;
	}
	}

	$data = array(
	'data' => $edge['data'],
	);

	$editor->addEdge($src, $type, $dst_phid, $data);
	}

	$editor->save();
	break;
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getCustomFieldForTransaction($object, $xaction);
	return $field->applyApplicationTransactionExternalEffects($xaction);
	}

	return $this->applyCustomExternalTransaction($object, $xaction);
	}

	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	$type = $xaction->getTransactionType();
	throw new Exception(
	"Transaction type '{$type}' is missing an internal apply ".
	"implementation!");
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	$type = $xaction->getTransactionType();
	throw new Exception(
	"Transaction type '{$type}' is missing an external apply ".
	"implementation!");
	}

	/**
	* Fill in a transaction's common values, like author and content source.
	*/
	protected function populateTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$actor = $this->getActor();

	// TODO: This needs to be more sophisticated once we have meta-policies.
	$xaction->setViewPolicy(PhabricatorPolicies::POLICY_PUBLIC);

	if ($actor->isOmnipotent()) {
	$xaction->setEditPolicy(PhabricatorPolicies::POLICY_NOONE);
	} else {
	$xaction->setEditPolicy($actor->getPHID());
	}

	$xaction->setAuthorPHID($this->getActingAsPHID());
	$xaction->setContentSource($this->getContentSource());
	$xaction->attachViewer($actor);
	$xaction->attachObject($object);

	if ($object->getPHID()) {
	$xaction->setObjectPHID($object->getPHID());
	}

	return $xaction;
	}


	protected function applyFinalEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $xactions;
	}

	public function setContentSource(PhabricatorContentSource $content_source) {
	$this->contentSource = $content_source;
	return $this;
	}

	public function setContentSourceFromRequest(AphrontRequest $request) {
	return $this->setContentSource(
	PhabricatorContentSource::newFromRequest($request));
	}

	public function setContentSourceFromConduitRequest(
	ConduitAPIRequest $request) {

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_CONDUIT,
	array());

	return $this->setContentSource($content_source);
	}

	public function getContentSource() {
	return $this->contentSource;
	}

	final public function applyTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$this->object = $object;
	$this->xactions = $xactions;
	$this->isNewObject = ($object->getPHID() === null);

	$this->validateEditParameters($object, $xactions);

	$actor = $this->requireActor();

	// NOTE: Some transaction expansion requires that the edited object be
	// attached.
	foreach ($xactions as $xaction) {
	$xaction->attachObject($object);
	$xaction->attachViewer($actor);
	}

	$xactions = $this->expandTransactions($object, $xactions);
	$xactions = $this->expandSupportTransactions($object, $xactions);
	$xactions = $this->combineTransactions($xactions);

	foreach ($xactions as $xaction) {
	$xaction = $this->populateTransaction($object, $xaction);
	}

	$is_preview = $this->getIsPreview();
	$read_locking = false;
	$transaction_open = false;

	if (!$is_preview) {
	$errors = array();
	$type_map = mgroup($xactions, 'getTransactionType');
	foreach ($this->getTransactionTypes() as $type) {
	$type_xactions = idx($type_map, $type, array());
	$errors[] = $this->validateTransaction($object, $type, $type_xactions);
	}

	$errors = array_mergev($errors);

	$continue_on_missing = $this->getContinueOnMissingFields();
	foreach ($errors as $key => $error) {
	if ($continue_on_missing && $error->getIsMissingFieldError()) {
	unset($errors[$key]);
	}
	}

	if ($errors) {
	throw new PhabricatorApplicationTransactionValidationException($errors);
	}

	$file_phids = $this->extractFilePHIDs($object, $xactions);

	if ($object->getID()) {
	foreach ($xactions as $xaction) {

	// If any of the transactions require a read lock, hold one and
	// reload the object. We need to do this fairly early so that the
	// call to `adjustTransactionValues()` (which populates old values)
	// is based on the synchronized state of the object, which may differ
	// from the state when it was originally loaded.

	if ($this->shouldReadLock($object, $xaction)) {
	$object->openTransaction();
	$object->beginReadLocking();
	$transaction_open = true;
	$read_locking = true;
	$object->reload();
	break;
	}
	}
	}

	if ($this->shouldApplyInitialEffects($object, $xactions)) {
	if (!$transaction_open) {
	$object->openTransaction();
	$transaction_open = true;
	}
	}
	}

	if ($this->shouldApplyInitialEffects($object, $xactions)) {
	$this->applyInitialEffects($object, $xactions);
	}

	foreach ($xactions as $xaction) {
	$this->adjustTransactionValues($object, $xaction);
	}

	$xactions = $this->filterTransactions($object, $xactions);

	if (!$xactions) {
	if ($read_locking) {
	$object->endReadLocking();
	$read_locking = false;
	}
	if ($transaction_open) {
	$object->killTransaction();
	$transaction_open = false;
	}
	return array();
	}

	// Now that we've merged, filtered, and combined transactions, check for
	// required capabilities.
	foreach ($xactions as $xaction) {
	$this->requireCapabilities($object, $xaction);
	}

	$xactions = $this->sortTransactions($xactions);

	if ($is_preview) {
	$this->loadHandles($xactions);
	return $xactions;
	}

	$comment_editor = id(new PhabricatorApplicationTransactionCommentEditor())
	->setActor($actor)
	->setContentSource($this->getContentSource());

	if (!$transaction_open) {
	$object->openTransaction();
	}

	foreach ($xactions as $xaction) {
	$this->applyInternalEffects($object, $xaction);
	}

	$object->save();

	foreach ($xactions as $xaction) {
	$xaction->setObjectPHID($object->getPHID());
	if ($xaction->getComment()) {
	$xaction->setPHID($xaction->generatePHID());
	$comment_editor->applyEdit($xaction, $xaction->getComment());
	} else {
	$xaction->save();
	}
	}

	if ($file_phids) {
	$this->attachFiles($object, $file_phids);
	}

	foreach ($xactions as $xaction) {
	$this->applyExternalEffects($object, $xaction);
	}

	$xactions = $this->applyFinalEffects($object, $xactions);

	if ($read_locking) {
	$object->endReadLocking();
	$read_locking = false;
	}

	$object->saveTransaction();

	// Now that we've completely applied the core transaction set, try to apply
	// Herald rules. Herald rules are allowed to either take direct actions on
	// the database (like writing flags), or take indirect actions (like saving
	// some targets for CC when we generate mail a little later), or return
	// transactions which we'll apply normally using another Editor.

	// First, check if this is a sub-editor which is itself applying Herald
	// rules: if it is, stop working and return so we don't descend into
	// madness.

	// Otherwise, we're not a Herald editor, so process Herald rules (possibly
	// using a Herald editor to apply resulting transactions) and then send out
	// mail, notifications, and feed updates about everything.

	if ($this->getIsHeraldEditor()) {
	// We are the Herald editor, so stop work here and return the updated
	// transactions.
	return $xactions;
	} else if ($this->shouldApplyHeraldRules($object, $xactions)) {
	// We are not the Herald editor, so try to apply Herald rules.
	$herald_xactions = $this->applyHeraldRules($object, $xactions);

	if ($herald_xactions) {
	$xscript_id = $this->getHeraldTranscript()->getID();
	foreach ($herald_xactions as $herald_xaction) {
	$herald_xaction->setMetadataValue('herald:transcriptID', $xscript_id);
	}

	// NOTE: We're acting as the omnipotent user because rules deal with
	// their own policy issues. We use a synthetic author PHID (the
	// Herald application) as the author of record, so that transactions
	// will render in a reasonable way ("Herald assigned this task ...").
	$herald_actor = PhabricatorUser::getOmnipotentUser();
	$herald_phid = id(new PhabricatorApplicationHerald())->getPHID();

	// TODO: It would be nice to give transactions a more specific source
	// which points at the rule which generated them. You can figure this
	// out from transcripts, but it would be cleaner if you didn't have to.

	$herald_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_HERALD,
	array());

	$herald_editor = newv(get_class($this), array())
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->setParentMessageID($this->getParentMessageID())
	->setIsHeraldEditor(true)
	->setActor($herald_actor)
	->setActingAsPHID($herald_phid)
	->setContentSource($herald_source);

	$herald_xactions = $herald_editor->applyTransactions(
	$object,
	$herald_xactions);

	// Merge the new transactions into the transaction list: we want to
	// send email and publish feed stories about them, too.
	$xactions = array_merge($xactions, $herald_xactions);
	}
	}

	// Before sending mail or publishing feed stories, reload the object
	// subscribers to pick up changes caused by Herald (or by other side effects
	// in various transaction phases).
	$this->loadSubscribers($object);

	$this->loadHandles($xactions);

	$mail = null;
	if (!$this->getDisableEmail()) {
	if ($this->shouldSendMail($object, $xactions)) {
	$mail = $this->sendMail($object, $xactions);
	}
	}

	if ($this->supportsSearch()) {
	id(new PhabricatorSearchIndexer())
	->queueDocumentForIndexing($object->getPHID());
	}

	if ($this->shouldPublishFeedStory($object, $xactions)) {
	$mailed = array();
	if ($mail) {
	$mailed = $mail->buildRecipientList();
	}
	$this->publishFeedStory(
	$object,
	$xactions,
	$mailed);
	}

	$this->didApplyTransactions($xactions);

	if ($object instanceof PhabricatorCustomFieldInterface) {
	// Maybe this makes more sense to move into the search index itself? For
	// now I'm putting it here since I think we might end up with things that
	// need it to be up to date once the next page loads, but if we don't go
	// there we we could move it into search once search moves to the daemons.

	// It now happens in the search indexer as well, but the search indexer is
	// always daemonized, so the logic above still potentially holds. We could
	// possibly get rid of this. The major motivation for putting it in the
	// indexer was to enable reindexing to work.

	$fields = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	$fields->readFieldsFromStorage($object);
	$fields->rebuildIndexes($object);
	}

	return $xactions;
	}

	protected function didApplyTransactions(array $xactions) {
	// Hook for subclasses.
	return;
	}


	/**
	* Determine if the editor should hold a read lock on the object while
	* applying a transaction.
	*
	* If the editor does not hold a lock, two editors may read an object at the
	* same time, then apply their changes without any synchronization. For most
	* transactions, this does not matter much. However, it is important for some
	* transactions. For example, if an object has a transaction count on it, both
	* editors may read the object with `count = 23`, then independently update it
	* and save the object with `count = 24` twice. This will produce the wrong
	* state: the object really has 25 transactions, but the count is only 24.
	*
	* Generally, transactions fall into one of four buckets:
	*
	* - Append operations: Actions like adding a comment to an object purely
	* add information to its state, and do not depend on the current object
	* state in any way. These transactions never need to hold locks.
	* - Overwrite operations: Actions like changing the title or description
	* of an object replace the current value with a new value, so the end
	* state is consistent without a lock. We currently do not lock these
	* transactions, although we may in the future.
	* - Edge operations: Edge and subscription operations have internal
	* synchronization which limits the damage race conditions can cause.
	* We do not currently lock these transactions, although we may in the
	* future.
	* - Update operations: Actions like incrementing a count on an object.
	* These operations generally should use locks, unless it is not
	* important that the state remain consistent in the presence of races.
	*
	* @param PhabricatorLiskDAO Object being updated.
	* @param PhabricatorApplicationTransaction Transaction being applied.
	* @return bool True to synchronize the edit with a lock.
	*/
	protected function shouldReadLock(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	return false;
	}

	private function loadHandles(array $xactions) {
	$phids = array();
	foreach ($xactions as $key => $xaction) {
	$phids[$key] = $xaction->getRequiredHandlePHIDs();
	}
	$handles = array();
	$merged = array_mergev($phids);
	if ($merged) {
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireActor())
	->withPHIDs($merged)
	->execute();
	}
	foreach ($xactions as $key => $xaction) {
	$xaction->setHandles(array_select_keys($handles, $phids[$key]));
	}
	}

	private function loadSubscribers(PhabricatorLiskDAO $object) {
	if ($object->getPHID() &&
	($object instanceof PhabricatorSubscribableInterface)) {
	$subs = PhabricatorSubscribersQuery::loadSubscribersForPHID(
	$object->getPHID());
	$this->subscribers = array_fuse($subs);
	} else {
	$this->subscribers = array();
	}
	}

	private function validateEditParameters(
	PhabricatorLiskDAO $object,
	array $xactions) {

	if (!$this->getContentSource()) {
	throw new Exception(
	"Call setContentSource() before applyTransactions()!");
	}

	// Do a bunch of sanity checks that the incoming transactions are fresh.
	// They should be unsaved and have only "transactionType" and "newValue"
	// set.

	$types = array_fill_keys($this->getTransactionTypes(), true);

	assert_instances_of($xactions, 'PhabricatorApplicationTransaction');
	foreach ($xactions as $xaction) {
	if ($xaction->getPHID() \|\| $xaction->getID()) {
	throw new PhabricatorApplicationTransactionStructureException(
	$xaction,
	pht(
	"You can not apply transactions which already have IDs/PHIDs!"));
	}
	if ($xaction->getObjectPHID()) {
	throw new PhabricatorApplicationTransactionStructureException(
	$xaction,
	pht(
	"You can not apply transactions which already have objectPHIDs!"));
	}
	if ($xaction->getAuthorPHID()) {
	throw new PhabricatorApplicationTransactionStructureException(
	$xaction,
	pht(
	'You can not apply transactions which already have authorPHIDs!'));
	}
	if ($xaction->getCommentPHID()) {
	throw new PhabricatorApplicationTransactionStructureException(
	$xaction,
	pht(
	'You can not apply transactions which already have '.
	'commentPHIDs!'));
	}
	if ($xaction->getCommentVersion() !== 0) {
	throw new PhabricatorApplicationTransactionStructureException(
	$xaction,
	pht(
	'You can not apply transactions which already have '.
	'commentVersions!'));
	}

	$expect_value = !$xaction->shouldGenerateOldValue();
	$has_value = $xaction->hasOldValue();

	if ($expect_value && !$has_value) {
	throw new PhabricatorApplicationTransactionStructureException(
	$xaction,
	pht(
	'This transaction is supposed to have an oldValue set, but '.
	'it does not!'));
	}

	if ($has_value && !$expect_value) {
	throw new PhabricatorApplicationTransactionStructureException(
	$xaction,
	pht(
	'This transaction should generate its oldValue automatically, '.
	'but has already had one set!'));
	}

	$type = $xaction->getTransactionType();
	if (empty($types[$type])) {
	throw new PhabricatorApplicationTransactionStructureException(
	$xaction,
	pht(
	'Transaction has type "%s", but that transaction type is not '.
	'supported by this editor (%s).',
	$type,
	get_class($this)));
	}
	}
	}

	protected function requireCapabilities(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

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

	$actor = $this->requireActor();
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	PhabricatorPolicyFilter::requireCapability(
	$actor,
	$object,
	PhabricatorPolicyCapability::CAN_VIEW);
	break;
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	PhabricatorPolicyFilter::requireCapability(
	$actor,
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	break;
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	PhabricatorPolicyFilter::requireCapability(
	$actor,
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	break;
	case PhabricatorTransactions::TYPE_JOIN_POLICY:
	PhabricatorPolicyFilter::requireCapability(
	$actor,
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	break;
	}
	}

	private function buildMentionTransaction(
	PhabricatorLiskDAO $object,
	array $xactions,
	array $blocks) {

	if (!($object instanceof PhabricatorSubscribableInterface)) {
	return null;
	}

	$texts = array_mergev($blocks);
	- $phids = PhabricatorMarkupEngine::extractPHIDsFromMentions($texts);
	+ $phids = PhabricatorMarkupEngine::extractPHIDsFromMentions(
	+ $this->getActor(),
	+ $texts);

	$this->mentionedPHIDs = $phids;

	if ($object->getPHID()) {
	// Don't try to subscribe already-subscribed mentions: we want to generate
	// a dialog about an action having no effect if the user explicitly adds
	// existing CCs, but not if they merely mention existing subscribers.
	$phids = array_diff($phids, $this->subscribers);
	}

	foreach ($phids as $key => $phid) {
	if ($object->isAutomaticallySubscribed($phid)) {
	unset($phids[$key]);
	}
	}
	$phids = array_values($phids);

	if (!$phids) {
	return null;
	}

	$xaction = newv(get_class(head($xactions)), array());
	$xaction->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
	$xaction->setNewValue(array('+' => $phids));

	return $xaction;
	}

	protected function getRemarkupBlocksFromTransaction(
	PhabricatorApplicationTransaction $transaction) {
	return $transaction->getRemarkupBlocks();
	}

	protected function mergeTransactions(
	PhabricatorApplicationTransaction $u,
	PhabricatorApplicationTransaction $v) {

	$type = $u->getTransactionType();

	switch ($type) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return $this->mergePHIDOrEdgeTransactions($u, $v);
	case PhabricatorTransactions::TYPE_EDGE:
	$u_type = $u->getMetadataValue('edge:type');
	$v_type = $v->getMetadataValue('edge:type');
	if ($u_type == $v_type) {
	return $this->mergePHIDOrEdgeTransactions($u, $v);
	}
	return null;
	}

	// By default, do not merge the transactions.
	return null;
	}

	/**
	* Optionally expand transactions which imply other effects. For example,
	* resigning from a revision in Differential implies removing yourself as
	* a reviewer.
	*/
	private function expandTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$results = array();
	foreach ($xactions as $xaction) {
	foreach ($this->expandTransaction($object, $xaction) as $expanded) {
	$results[] = $expanded;
	}
	}

	return $results;
	}

	protected function expandTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	return array($xaction);
	}


	private function expandSupportTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {
	$this->loadSubscribers($object);

	$xactions = $this->applyImplicitCC($object, $xactions);

	$blocks = array();
	foreach ($xactions as $key => $xaction) {
	$blocks[$key] = $this->getRemarkupBlocksFromTransaction($xaction);
	}

	$mention_xaction = $this->buildMentionTransaction(
	$object,
	$xactions,
	$blocks);
	if ($mention_xaction) {
	$xactions[] = $mention_xaction;
	}

	// TODO: For now, this is just a placeholder.
	$engine = PhabricatorMarkupEngine::getEngine('extract');

	$block_xactions = $this->expandRemarkupBlockTransactions(
	$object,
	$xactions,
	$blocks,
	$engine);

	foreach ($block_xactions as $xaction) {
	$xactions[] = $xaction;
	}

	return $xactions;
	}

	private function expandRemarkupBlockTransactions(
	PhabricatorLiskDAO $object,
	array $xactions,
	$blocks,
	PhutilMarkupEngine $engine) {
	return $this->expandCustomRemarkupBlockTransactions(
	$object,
	$xactions,
	$blocks,
	$engine);
	}

	protected function expandCustomRemarkupBlockTransactions(
	PhabricatorLiskDAO $object,
	array $xactions,
	$blocks,
	PhutilMarkupEngine $engine) {
	return array();
	}


	/**
	* Attempt to combine similar transactions into a smaller number of total
	* transactions. For example, two transactions which edit the title of an
	* object can be merged into a single edit.
	*/
	private function combineTransactions(array $xactions) {
	$stray_comments = array();

	$result = array();
	$types = array();
	foreach ($xactions as $key => $xaction) {
	$type = $xaction->getTransactionType();
	if (isset($types[$type])) {
	foreach ($types[$type] as $other_key) {
	$merged = $this->mergeTransactions($result[$other_key], $xaction);
	if ($merged) {
	$result[$other_key] = $merged;

	if ($xaction->getComment() &&
	($xaction->getComment() !== $merged->getComment())) {
	$stray_comments[] = $xaction->getComment();
	}

	if ($result[$other_key]->getComment() &&
	($result[$other_key]->getComment() !== $merged->getComment())) {
	$stray_comments[] = $result[$other_key]->getComment();
	}

	// Move on to the next transaction.
	continue 2;
	}
	}
	}
	$result[$key] = $xaction;
	$types[$type][] = $key;
	}

	// If we merged any comments away, restore them.
	foreach ($stray_comments as $comment) {
	$xaction = newv(get_class(head($result)), array());
	$xaction->setTransactionType(PhabricatorTransactions::TYPE_COMMENT);
	$xaction->setComment($comment);
	$result[] = $xaction;
	}

	return array_values($result);
	}

	protected function mergePHIDOrEdgeTransactions(
	PhabricatorApplicationTransaction $u,
	PhabricatorApplicationTransaction $v) {

	$result = $u->getNewValue();
	foreach ($v->getNewValue() as $key => $value) {
	if ($u->getTransactionType() == PhabricatorTransactions::TYPE_EDGE) {
	if (empty($result[$key])) {
	$result[$key] = $value;
	} else {
	// We're merging two lists of edge adds, sets, or removes. Merge
	// them by merging individual PHIDs within them.
	$merged = $result[$key];

	foreach ($value as $dst => $v_spec) {
	if (empty($merged[$dst])) {
	$merged[$dst] = $v_spec;
	} else {
	// Two transactions are trying to perform the same operation on
	// the same edge. Normalize the edge data and then merge it. This
	// allows transactions to specify how data merges execute in a
	// precise way.

	$u_spec = $merged[$dst];

	if (!is_array($u_spec)) {
	$u_spec = array('dst' => $u_spec);
	}
	if (!is_array($v_spec)) {
	$v_spec = array('dst' => $v_spec);
	}

	$ux_data = idx($u_spec, 'data', array());
	$vx_data = idx($v_spec, 'data', array());

	$merged_data = $this->mergeEdgeData(
	$u->getMetadataValue('edge:type'),
	$ux_data,
	$vx_data);

	$u_spec['data'] = $merged_data;
	$merged[$dst] = $u_spec;
	}
	}

	$result[$key] = $merged;
	}
	} else {
	$result[$key] = array_merge($value, idx($result, $key, array()));
	}
	}
	$u->setNewValue($result);

	// When combining an "ignore" transaction with a normal transaction, make
	// sure we don't propagate the "ignore" flag.
	if (!$v->getIgnoreOnNoEffect()) {
	$u->setIgnoreOnNoEffect(false);
	}

	return $u;
	}

	protected function mergeEdgeData($type, array $u, array $v) {
	return $v + $u;
	}

	protected function getPHIDTransactionNewValue(
	PhabricatorApplicationTransaction $xaction) {

	$old = array_fuse($xaction->getOldValue());

	$new = $xaction->getNewValue();
	$new_add = idx($new, '+', array());
	unset($new['+']);
	$new_rem = idx($new, '-', array());
	unset($new['-']);
	$new_set = idx($new, '=', null);
	if ($new_set !== null) {
	$new_set = array_fuse($new_set);
	}
	unset($new['=']);

	if ($new) {
	throw new Exception(
	"Invalid 'new' value for PHID transaction. Value should contain only ".
	"keys '+' (add PHIDs), '-' (remove PHIDs) and '=' (set PHIDS).");
	}

	$result = array();

	foreach ($old as $phid) {
	if ($new_set !== null && empty($new_set[$phid])) {
	continue;
	}
	$result[$phid] = $phid;
	}

	if ($new_set !== null) {
	foreach ($new_set as $phid) {
	$result[$phid] = $phid;
	}
	}

	foreach ($new_add as $phid) {
	$result[$phid] = $phid;
	}

	foreach ($new_rem as $phid) {
	unset($result[$phid]);
	}

	return array_values($result);
	}

	protected function getEdgeTransactionNewValue(
	PhabricatorApplicationTransaction $xaction) {

	$new = $xaction->getNewValue();
	$new_add = idx($new, '+', array());
	unset($new['+']);
	$new_rem = idx($new, '-', array());
	unset($new['-']);
	$new_set = idx($new, '=', null);
	unset($new['=']);

	if ($new) {
	throw new Exception(
	"Invalid 'new' value for Edge transaction. Value should contain only ".
	"keys '+' (add edges), '-' (remove edges) and '=' (set edges).");
	}

	$old = $xaction->getOldValue();

	$lists = array($new_set, $new_add, $new_rem);
	foreach ($lists as $list) {
	$this->checkEdgeList($list);
	}

	$result = array();
	foreach ($old as $dst_phid => $edge) {
	if ($new_set !== null && empty($new_set[$dst_phid])) {
	continue;
	}
	$result[$dst_phid] = $this->normalizeEdgeTransactionValue(
	$xaction,
	$edge,
	$dst_phid);
	}

	if ($new_set !== null) {
	foreach ($new_set as $dst_phid => $edge) {
	$result[$dst_phid] = $this->normalizeEdgeTransactionValue(
	$xaction,
	$edge,
	$dst_phid);
	}
	}

	foreach ($new_add as $dst_phid => $edge) {
	$result[$dst_phid] = $this->normalizeEdgeTransactionValue(
	$xaction,
	$edge,
	$dst_phid);
	}

	foreach ($new_rem as $dst_phid => $edge) {
	unset($result[$dst_phid]);
	}

	return $result;
	}

	private function checkEdgeList($list) {
	if (!$list) {
	return;
	}
	foreach ($list as $key => $item) {
	if (phid_get_type($key) === PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
	throw new Exception(
	"Edge transactions must have destination PHIDs as in edge ".
	"lists (found key '{$key}').");
	}
	if (!is_array($item) && $item !== $key) {
	throw new Exception(
	"Edge transactions must have PHIDs or edge specs as values ".
	"(found value '{$item}').");
	}
	}
	}

	private function normalizeEdgeTransactionValue(
	PhabricatorApplicationTransaction $xaction,
	$edge,
	$dst_phid) {

	if (!is_array($edge)) {
	if ($edge != $dst_phid) {
	throw new Exception(
	pht(
	'Transaction edge data must either be the edge PHID or an edge '.
	'specification dictionary.'));
	}
	$edge = array();
	} else {
	foreach ($edge as $key => $value) {
	switch ($key) {
	case 'src':
	case 'dst':
	case 'type':
	case 'data':
	case 'dateCreated':
	case 'dateModified':
	case 'seq':
	case 'dataID':
	break;
	default:
	throw new Exception(
	pht(
	'Transaction edge specification contains unexpected key '.
	'"%s".',
	$key));
	}
	}
	}

	$edge['dst'] = $dst_phid;

	$edge_type = $xaction->getMetadataValue('edge:type');
	if (empty($edge['type'])) {
	$edge['type'] = $edge_type;
	} else {
	if ($edge['type'] != $edge_type) {
	$this_type = $edge['type'];
	throw new Exception(
	"Edge transaction includes edge of type '{$this_type}', but ".
	"transaction is of type '{$edge_type}'. Each edge transaction must ".
	"alter edges of only one type.");
	}
	}

	if (!isset($edge['data'])) {
	$edge['data'] = array();
	}

	return $edge;
	}

	protected function sortTransactions(array $xactions) {
	$head = array();
	$tail = array();

	// Move bare comments to the end, so the actions precede them.
	foreach ($xactions as $xaction) {
	$type = $xaction->getTransactionType();
	if ($type == PhabricatorTransactions::TYPE_COMMENT) {
	$tail[] = $xaction;
	} else {
	$head[] = $xaction;
	}
	}

	return array_values(array_merge($head, $tail));
	}


	protected function filterTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$type_comment = PhabricatorTransactions::TYPE_COMMENT;

	$no_effect = array();
	$has_comment = false;
	$any_effect = false;
	foreach ($xactions as $key => $xaction) {
	if ($this->transactionHasEffect($object, $xaction)) {
	if ($xaction->getTransactionType() != $type_comment) {
	$any_effect = true;
	}
	} else if ($xaction->getIgnoreOnNoEffect()) {
	unset($xactions[$key]);
	} else {
	$no_effect[$key] = $xaction;
	}
	if ($xaction->hasComment()) {
	$has_comment = true;
	}
	}

	if (!$no_effect) {
	return $xactions;
	}

	if (!$this->getContinueOnNoEffect() && !$this->getIsPreview()) {
	throw new PhabricatorApplicationTransactionNoEffectException(
	$no_effect,
	$any_effect,
	$has_comment);
	}

	if (!$any_effect && !$has_comment) {
	// If we only have empty comment transactions, just drop them all.
	return array();
	}

	foreach ($no_effect as $key => $xaction) {
	if ($xaction->getComment()) {
	$xaction->setTransactionType($type_comment);
	$xaction->setOldValue(null);
	$xaction->setNewValue(null);
	} else {
	unset($xactions[$key]);
	}
	}

	return $xactions;
	}


	/**
	* Hook for validating transactions. This callback will be invoked for each
	* available transaction type, even if an edit does not apply any transactions
	* of that type. This allows you to raise exceptions when required fields are
	* missing, by detecting that the object has no field value and there is no
	* transaction which sets one.
	*
	* @param PhabricatorLiskDAO Object being edited.
	* @param string Transaction type to validate.
	* @param list<PhabricatorApplicationTransaction> Transactions of given type,
	* which may be empty if the edit does not apply any transactions of the
	* given type.
	* @return list<PhabricatorApplicationTransactionValidationError> List of
	* validation errors.
	*/
	protected function validateTransaction(
	PhabricatorLiskDAO $object,
	$type,
	array $xactions) {

	$errors = array();
	switch ($type) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	$errors[] = $this->validatePolicyTransaction(
	$object,
	$xactions,
	$type,
	PhabricatorPolicyCapability::CAN_VIEW);
	break;
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	$errors[] = $this->validatePolicyTransaction(
	$object,
	$xactions,
	$type,
	PhabricatorPolicyCapability::CAN_EDIT);
	break;
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$groups = array();
	foreach ($xactions as $xaction) {
	$groups[$xaction->getMetadataValue('customfield:key')][] = $xaction;
	}

	$field_list = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_EDIT);
	$field_list->setViewer($this->getActor());

	$role_xactions = PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS;
	foreach ($field_list->getFields() as $field) {
	if (!$field->shouldEnableForRole($role_xactions)) {
	continue;
	}
	$errors[] = $field->validateApplicationTransactions(
	$this,
	$type,
	idx($groups, $field->getFieldKey(), array()));
	}
	break;
	}

	return array_mergev($errors);
	}

	private function validatePolicyTransaction(
	PhabricatorLiskDAO $object,
	array $xactions,
	$transaction_type,
	$capability) {

	$actor = $this->requireActor();
	$errors = array();
	// Note $this->xactions is necessary; $xactions is $this->xactions of
	// $transaction_type
	$policy_object = $this->adjustObjectForPolicyChecks(
	$object,
	$this->xactions);

	// Make sure the user isn't editing away their ability to $capability this
	// object.
	foreach ($xactions as $xaction) {
	try {
	PhabricatorPolicyFilter::requireCapabilityWithForcedPolicy(
	$actor,
	$policy_object,
	$capability,
	$xaction->getNewValue());
	} catch (PhabricatorPolicyException $ex) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$transaction_type,
	pht('Invalid'),
	pht(
	'You can not select this %s policy, because you would no longer '.
	'be able to %s the object.',
	$capability,
	$capability),
	$xaction);
	}
	}

	if ($this->getIsNewObject()) {
	if (!$xactions) {
	$has_capability = PhabricatorPolicyFilter::hasCapability(
	$actor,
	$policy_object,
	$capability);
	if (!$has_capability) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$transaction_type,
	pht('Invalid'),
	pht('The selected %s policy excludes you. Choose a %s policy '.
	'which allows you to %s the object.',
	$capability,
	$capability,
	$capability));
	}
	}
	}

	return $errors;
	}

	protected function adjustObjectForPolicyChecks(
	PhabricatorLiskDAO $object,
	array $xactions) {

	return clone $object;
	}

	/**
	* Check for a missing text field.
	*
	* A text field is missing if the object has no value and there are no
	* transactions which set a value, or if the transactions remove the value.
	* This method is intended to make implementing @{method:validateTransaction}
	* more convenient:
	*
	* $missing = $this->validateIsEmptyTextField(
	* $object->getName(),
	* $xactions);
	*
	* This will return `true` if the net effect of the object and transactions
	* is an empty field.
	*
	* @param wild Current field value.
	* @param list<PhabricatorApplicationTransaction> Transactions editing the
	* field.
	* @return bool True if the field will be an empty text field after edits.
	*/
	protected function validateIsEmptyTextField($field_value, array $xactions) {
	if (strlen($field_value) && empty($xactions)) {
	return false;
	}

	if ($xactions && strlen(last($xactions)->getNewValue())) {
	return false;
	}

	return true;
	}


	/* -( Implicit CCs )------------------------------------------------------- */


	/**
	* When a user interacts with an object, we might want to add them to CC.
	*/
	final public function applyImplicitCC(
	PhabricatorLiskDAO $object,
	array $xactions) {

	if (!($object instanceof PhabricatorSubscribableInterface)) {
	// If the object isn't subscribable, we can't CC them.
	return $xactions;
	}

	$actor_phid = $this->requireActor()->getPHID();
	if ($object->isAutomaticallySubscribed($actor_phid)) {
	// If they're auto-subscribed, don't CC them.
	return $xactions;
	}

	$should_cc = false;
	foreach ($xactions as $xaction) {
	if ($this->shouldImplyCC($object, $xaction)) {
	$should_cc = true;
	break;
	}
	}

	if (!$should_cc) {
	// Only some types of actions imply a CC (like adding a comment).
	return $xactions;
	}

	if ($object->getPHID()) {
	if (isset($this->subscribers[$actor_phid])) {
	// If the user is already subscribed, don't implicitly CC them.
	return $xactions;
	}

	$unsub = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$object->getPHID(),
	PhabricatorEdgeConfig::TYPE_OBJECT_HAS_UNSUBSCRIBER);
	$unsub = array_fuse($unsub);
	if (isset($unsub[$actor_phid])) {
	// If the user has previously unsubscribed from this object explicitly,
	// don't implicitly CC them.
	return $xactions;
	}
	}

	$xaction = newv(get_class(head($xactions)), array());
	$xaction->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
	$xaction->setNewValue(array('+' => array($actor_phid)));

	array_unshift($xactions, $xaction);

	return $xactions;
	}

	protected function shouldImplyCC(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	return $xaction->isCommentTransaction();
	}


	/* -( Sending Mail )------------------------------------------------------- */


	/**
	* @task mail
	*/
	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return false;
	}


	/**
	* @task mail
	*/
	protected function sendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {

	// Check if any of the transactions are visible. If we don't have any
	// visible transactions, don't send the mail.

	$any_visible = false;
	foreach ($xactions as $xaction) {
	if (!$xaction->shouldHideForMail($xactions)) {
	$any_visible = true;
	break;
	}
	}

	if (!$any_visible) {
	return;
	}

	$email_to = array_filter(array_unique($this->getMailTo($object)));
	$email_cc = array_filter(array_unique($this->getMailCC($object)));

	$phids = array_merge($email_to, $email_cc);
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireActor())
	->withPHIDs($phids)
	->execute();

	$template = $this->buildMailTemplate($object);
	$body = $this->buildMailBody($object, $xactions);

	$mail_tags = $this->getMailTags($object, $xactions);
	$action = $this->getMailAction($object, $xactions);

	$reply_handler = $this->buildReplyHandler($object);
	$reply_section = $reply_handler->getReplyHandlerInstructions();
	if ($reply_section !== null) {
	$body->addReplySection($reply_section);
	}

	$template
	->setFrom($this->requireActor()->getPHID())
	->setSubjectPrefix($this->getMailSubjectPrefix())
	->setVarySubjectPrefix('['.$action.']')
	->setThreadID($this->getMailThreadID($object), $this->getIsNewObject())
	->setRelatedPHID($object->getPHID())
	->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
	->setMailTags($mail_tags)
	->setIsBulk(true)
	->setBody($body->render());

	foreach ($body->getAttachments() as $attachment) {
	$template->addAttachment($attachment);
	}

	$herald_xscript = $this->getHeraldTranscript();
	if ($herald_xscript) {
	$herald_header = $herald_xscript->getXHeraldRulesHeader();
	$herald_header = HeraldTranscript::saveXHeraldRulesHeader(
	$object->getPHID(),
	$herald_header);
	} else {
	$herald_header = HeraldTranscript::loadXHeraldRulesHeader(
	$object->getPHID());
	}

	if ($herald_header) {
	$template->addHeader('X-Herald-Rules', $herald_header);
	}

	if ($this->getParentMessageID()) {
	$template->setParentMessageID($this->getParentMessageID());
	}

	$mails = $reply_handler->multiplexMail(
	$template,
	array_select_keys($handles, $email_to),
	array_select_keys($handles, $email_cc));

	foreach ($mails as $mail) {
	$mail->saveAndSend();
	}

	$template->addTos($email_to);
	$template->addCCs($email_cc);

	return $template;
	}

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	return $object->getPHID();
	}


	/**
	* @task mail
	*/
	protected function getStrongestAction(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return last(msort($xactions, 'getActionStrength'));
	}


	/**
	* @task mail
	*/
	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailSubjectPrefix() {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailTags(
	PhabricatorLiskDAO $object,
	array $xactions) {
	$tags = array();

	foreach ($xactions as $xaction) {
	$tags[] = $xaction->getMailTags();
	}

	return array_mergev($tags);
	}

	/**
	* @task mail
	*/
	protected function getMailAction(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->getStrongestAction($object, $xactions)->getActionName();
	}


	/**
	* @task mail
	*/
	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailTo(PhabricatorLiskDAO $object) {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailCC(PhabricatorLiskDAO $object) {
	if ($object instanceof PhabricatorSubscribableInterface) {
	return $this->subscribers;
	}
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function buildMailBody(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$headers = array();
	$comments = array();

	foreach ($xactions as $xaction) {
	if ($xaction->shouldHideForMail($xactions)) {
	continue;
	}

	$header = $xaction->getTitleForMail();
	if ($header !== null) {
	$headers[] = $header;
	}

	$comment = $xaction->getBodyForMail();
	if ($comment !== null) {
	$comments[] = $comment;
	}
	}

	$body = new PhabricatorMetaMTAMailBody();
	$body->addRawSection(implode("\n", $headers));

	foreach ($comments as $comment) {
	$body->addRawSection($comment);
	}

	if ($object instanceof PhabricatorCustomFieldInterface) {
	$field_list = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_TRANSACTIONMAIL);
	$field_list->setViewer($this->getActor());
	$field_list->readFieldsFromStorage($object);

	foreach ($field_list->getFields() as $field) {
	$field->updateTransactionMailBody(
	$body,
	$this,
	$xactions);
	}
	}

	return $body;
	}


	/* -( Publishing Feed Stories )-------------------------------------------- */


	/**
	* @task feed
	*/
	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return false;
	}


	/**
	* @task feed
	*/
	protected function getFeedStoryType() {
	return 'PhabricatorApplicationTransactionFeedStory';
	}


	/**
	* @task feed
	*/
	protected function getFeedRelatedPHIDs(
	PhabricatorLiskDAO $object,
	array $xactions) {

	return array(
	$object->getPHID(),
	$this->requireActor()->getPHID(),
	);
	}


	/**
	* @task feed
	*/
	protected function getFeedNotifyPHIDs(
	PhabricatorLiskDAO $object,
	array $xactions) {

	return array_unique(array_merge(
	$this->getMailTo($object),
	$this->getMailCC($object)));
	}


	/**
	* @task feed
	*/
	protected function getFeedStoryData(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$xactions = msort($xactions, 'getActionStrength');
	$xactions = array_reverse($xactions);

	return array(
	'objectPHID' => $object->getPHID(),
	'transactionPHIDs' => mpull($xactions, 'getPHID'),
	);
	}


	/**
	* @task feed
	*/
	protected function publishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions,
	array $mailed_phids) {

	$xactions = mfilter($xactions, 'shouldHideForFeed', true);

	if (!$xactions) {
	return;
	}

	$related_phids = $this->getFeedRelatedPHIDs($object, $xactions);
	$subscribed_phids = $this->getFeedNotifyPHIDs($object, $xactions);

	$story_type = $this->getFeedStoryType();
	$story_data = $this->getFeedStoryData($object, $xactions);

	id(new PhabricatorFeedStoryPublisher())
	->setStoryType($story_type)
	->setStoryData($story_data)
	->setStoryTime(time())
	->setStoryAuthorPHID($this->requireActor()->getPHID())
	->setRelatedPHIDs($related_phids)
	->setPrimaryObjectPHID($object->getPHID())
	->setSubscribedPHIDs($subscribed_phids)
	->setMailRecipientPHIDs($mailed_phids)
	->publish();
	}


	/* -( Search Index )------------------------------------------------------- */


	/**
	* @task search
	*/
	protected function supportsSearch() {
	return false;
	}


	/* -( Herald Integration )-------------------------------------------------- */


	protected function shouldApplyHeraldRules(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return false;
	}

	protected function buildHeraldAdapter(
	PhabricatorLiskDAO $object,
	array $xactions) {
	throw new Exception('No herald adapter specified.');
	}

	private function setHeraldAdapter(HeraldAdapter $adapter) {
	$this->heraldAdapter = $adapter;
	return $this;
	}

	protected function getHeraldAdapter() {
	return $this->heraldAdapter;
	}

	private function setHeraldTranscript(HeraldTranscript $transcript) {
	$this->heraldTranscript = $transcript;
	return $this;
	}

	protected function getHeraldTranscript() {
	return $this->heraldTranscript;
	}

	private function applyHeraldRules(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$adapter = $this->buildHeraldAdapter($object, $xactions);
	$adapter->setContentSource($this->getContentSource());
	$adapter->setIsNewObject($this->getIsNewObject());
	$xscript = HeraldEngine::loadAndApplyRules($adapter);

	$this->setHeraldAdapter($adapter);
	$this->setHeraldTranscript($xscript);

	return $this->didApplyHeraldRules($object, $adapter, $xscript);
	}

	protected function didApplyHeraldRules(
	PhabricatorLiskDAO $object,
	HeraldAdapter $adapter,
	HeraldTranscript $transcript) {
	return array();
	}


	/* -( Custom Fields )------------------------------------------------------ */


	/**
	* @task customfield
	*/
	private function getCustomFieldForTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$field_key = $xaction->getMetadataValue('customfield:key');
	if (!$field_key) {
	throw new Exception(
	"Custom field transaction has no 'customfield:key'!");
	}

	$field = PhabricatorCustomField::getObjectField(
	$object,
	PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS,
	$field_key);

	if (!$field) {
	throw new Exception(
	"Custom field transaction has invalid 'customfield:key'; field ".
	"'{$field_key}' is disabled or does not exist.");
	}

	if (!$field->shouldAppearInApplicationTransactions()) {
	throw new Exception(
	"Custom field transaction '{$field_key}' does not implement ".
	"integration for ApplicationTransactions.");
	}

	$field->setViewer($this->getActor());

	return $field;
	}


	/* -( Files )-------------------------------------------------------------- */


	/**
	* Extract the PHIDs of any files which these transactions attach.
	*
	* @task files
	*/
	private function extractFilePHIDs(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$blocks = array();
	foreach ($xactions as $xaction) {
	$blocks[] = $this->getRemarkupBlocksFromTransaction($xaction);
	}
	$blocks = array_mergev($blocks);

	$phids = array();
	if ($blocks) {
	$phids[] = PhabricatorMarkupEngine::extractFilePHIDsFromEmbeddedFiles(
	+ $this->getActor(),
	$blocks);
	}

	foreach ($xactions as $xaction) {
	$phids[] = $this->extractFilePHIDsFromCustomTransaction(
	$object,
	$xaction);
	}

	$phids = array_unique(array_filter(array_mergev($phids)));
	if (!$phids) {
	return array();
	}

	// Only let a user attach files they can actually see, since this would
	// otherwise let you access any file by attaching it to an object you have
	// view permission on.

	$files = id(new PhabricatorFileQuery())
	->setViewer($this->getActor())
	->withPHIDs($phids)
	->execute();

	return mpull($files, 'getPHID');
	}

	/**
	* @task files
	*/
	protected function extractFilePHIDsFromCustomTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	return array();
	}


	/**
	* @task files
	*/
	private function attachFiles(
	PhabricatorLiskDAO $object,
	array $file_phids) {

	if (!$file_phids) {
	return;
	}

	$editor = id(new PhabricatorEdgeEditor())
	->setActor($this->getActor());

	// TODO: Edge-based events were almost certainly a terrible idea. If we
	// don't suppress this event, the Maniphest listener reenters and adds
	// more transactions. Just suppress it until that can get cleaned up.
	$editor->setSuppressEvents(true);

	$src = $object->getPHID();
	$type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_FILE;
	foreach ($file_phids as $dst) {
	$editor->addEdge($src, $type, $dst);
	}

	$editor->save();
	}

	}
	diff --git a/src/infrastructure/markup/PhabricatorMarkupEngine.php b/src/infrastructure/markup/PhabricatorMarkupEngine.php
	index 20a211177d..87555f1d64 100644
	--- a/src/infrastructure/markup/PhabricatorMarkupEngine.php
	+++ b/src/infrastructure/markup/PhabricatorMarkupEngine.php
	@@ -1,593 +1,597 @@
	<?php

	/**
	* Manages markup engine selection, configuration, application, caching and
	* pipelining.
	*
	* @{class:PhabricatorMarkupEngine} can be used to render objects which
	* implement @{interface:PhabricatorMarkupInterface} in a batched, cache-aware
	* way. For example, if you have a list of comments written in remarkup (and
	* the objects implement the correct interface) you can render them by first
	* building an engine and adding the fields with @{method:addObject}.
	*
	* $field = 'field:body'; // Field you want to render. Each object exposes
	* // one or more fields of markup.
	*
	* $engine = new PhabricatorMarkupEngine();
	* foreach ($comments as $comment) {
	* $engine->addObject($comment, $field);
	* }
	*
	* Now, call @{method:process} to perform the actual cache/rendering
	* step. This is a heavyweight call which does batched data access and
	* transforms the markup into output.
	*
	* $engine->process();
	*
	* Finally, do something with the results:
	*
	* $results = array();
	* foreach ($comments as $comment) {
	* $results[] = $engine->getOutput($comment, $field);
	* }
	*
	* If you have a single object to render, you can use the convenience method
	* @{method:renderOneObject}.
	*
	* @task markup Markup Pipeline
	* @task engine Engine Construction
	*/
	final class PhabricatorMarkupEngine {

	private $objects = array();
	private $viewer;
	private $version = 8;


	/* -( Markup Pipeline )---------------------------------------------------- */


	/**
	* Convenience method for pushing a single object through the markup
	* pipeline.
	*
	* @param PhabricatorMarkupInterface The object to render.
	* @param string The field to render.
	* @param PhabricatorUser User viewing the markup.
	* @return string Marked up output.
	* @task markup
	*/
	public static function renderOneObject(
	PhabricatorMarkupInterface $object,
	$field,
	PhabricatorUser $viewer) {
	return id(new PhabricatorMarkupEngine())
	->setViewer($viewer)
	->addObject($object, $field)
	->process()
	->getOutput($object, $field);
	}


	/**
	* Queue an object for markup generation when @{method:process} is
	* called. You can retrieve the output later with @{method:getOutput}.
	*
	* @param PhabricatorMarkupInterface The object to render.
	* @param string The field to render.
	* @return this
	* @task markup
	*/
	public function addObject(PhabricatorMarkupInterface $object, $field) {
	$key = $this->getMarkupFieldKey($object, $field);
	$this->objects[$key] = array(
	'object' => $object,
	'field' => $field,
	);

	return $this;
	}


	/**
	* Process objects queued with @{method:addObject}. You can then retrieve
	* the output with @{method:getOutput}.
	*
	* @return this
	* @task markup
	*/
	public function process() {
	$keys = array();
	foreach ($this->objects as $key => $info) {
	if (!isset($info['markup'])) {
	$keys[] = $key;
	}
	}

	if (!$keys) {
	return;
	}

	$objects = array_select_keys($this->objects, $keys);

	// Build all the markup engines. We need an engine for each field whether
	// we have a cache or not, since we still need to postprocess the cache.
	$engines = array();
	foreach ($objects as $key => $info) {
	$engines[$key] = $info['object']->newMarkupEngine($info['field']);
	$engines[$key]->setConfig('viewer', $this->viewer);
	}

	// Load or build the preprocessor caches.
	$blocks = $this->loadPreprocessorCaches($engines, $objects);
	$blocks = mpull($blocks, 'getCacheData');

	$this->engineCaches = $blocks;

	// Finalize the output.
	foreach ($objects as $key => $info) {
	$engine = $engines[$key];
	$field = $info['field'];
	$object = $info['object'];

	$output = $engine->postprocessText($blocks[$key]);
	$output = $object->didMarkupText($field, $output, $engine);
	$this->objects[$key]['output'] = $output;
	}

	return $this;
	}


	/**
	* Get the output of markup processing for a field queued with
	* @{method:addObject}. Before you can call this method, you must call
	* @{method:process}.
	*
	* @param PhabricatorMarkupInterface The object to retrieve.
	* @param string The field to retrieve.
	* @return string Processed output.
	* @task markup
	*/
	public function getOutput(PhabricatorMarkupInterface $object, $field) {
	$key = $this->getMarkupFieldKey($object, $field);
	$this->requireKeyProcessed($key);

	return $this->objects[$key]['output'];
	}


	/**
	* Retrieve engine metadata for a given field.
	*
	* @param PhabricatorMarkupInterface The object to retrieve.
	* @param string The field to retrieve.
	* @param string The engine metadata field to retrieve.
	* @param wild Optional default value.
	* @task markup
	*/
	public function getEngineMetadata(
	PhabricatorMarkupInterface $object,
	$field,
	$metadata_key,
	$default = null) {

	$key = $this->getMarkupFieldKey($object, $field);
	$this->requireKeyProcessed($key);

	return idx($this->engineCaches[$key]['metadata'], $metadata_key, $default);
	}


	/**
	* @task markup
	*/
	private function requireKeyProcessed($key) {
	if (empty($this->objects[$key])) {
	throw new Exception(
	"Call addObject() before using results (key = '{$key}').");
	}

	if (!isset($this->objects[$key]['output'])) {
	throw new Exception(
	"Call process() before using results.");
	}
	}


	/**
	* @task markup
	*/
	private function getMarkupFieldKey(
	PhabricatorMarkupInterface $object,
	$field) {

	static $custom;
	if ($custom === null) {
	$custom = array_merge(
	self::loadCustomInlineRules(),
	self::loadCustomBlockRules());

	$custom = mpull($custom, 'getRuleVersion', null);
	ksort($custom);
	$custom = PhabricatorHash::digestForIndex(serialize($custom));
	}

	return $object->getMarkupFieldKey($field).'@'.$this->version.'@'.$custom;
	}


	/**
	* @task markup
	*/
	private function loadPreprocessorCaches(array $engines, array $objects) {
	$blocks = array();

	$use_cache = array();
	foreach ($objects as $key => $info) {
	if ($info['object']->shouldUseMarkupCache($info['field'])) {
	$use_cache[$key] = true;
	}
	}

	if ($use_cache) {
	try {
	$blocks = id(new PhabricatorMarkupCache())->loadAllWhere(
	'cacheKey IN (%Ls)',
	array_keys($use_cache));
	$blocks = mpull($blocks, null, 'getCacheKey');
	} catch (Exception $ex) {
	phlog($ex);
	}
	}

	foreach ($objects as $key => $info) {
	// False check in case MySQL doesn't support unicode characters
	// in the string (T1191), resulting in unserialize returning false.
	if (isset($blocks[$key]) && $blocks[$key]->getCacheData() !== false) {
	// If we already have a preprocessing cache, we don't need to rebuild
	// it.
	continue;
	}

	$text = $info['object']->getMarkupText($info['field']);
	$data = $engines[$key]->preprocessText($text);

	// NOTE: This is just debugging information to help sort out cache issues.
	// If one machine is misconfigured and poisoning caches you can use this
	// field to hunt it down.

	$metadata = array(
	'host' => php_uname('n'),
	);

	$blocks[$key] = id(new PhabricatorMarkupCache())
	->setCacheKey($key)
	->setCacheData($data)
	->setMetadata($metadata);

	if (isset($use_cache[$key])) {
	// This is just filling a cache and always safe, even on a read pathway.
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$blocks[$key]->replace();
	unset($unguarded);
	}
	}

	return $blocks;
	}


	/**
	* Set the viewing user. Used to implement object permissions.
	*
	* @param PhabricatorUser The viewing user.
	* @return this
	* @task markup
	*/
	public function setViewer(PhabricatorUser $viewer) {
	$this->viewer = $viewer;
	return $this;
	}


	/* -( Engine Construction )------------------------------------------------ */



	/**
	* @task engine
	*/
	public static function newManiphestMarkupEngine() {
	return self::newMarkupEngine(array(
	));
	}


	/**
	* @task engine
	*/
	public static function newPhrictionMarkupEngine() {
	return self::newMarkupEngine(array(
	'header.generate-toc' => true,
	));
	}


	/**
	* @task engine
	*/
	public static function newPhameMarkupEngine() {
	return self::newMarkupEngine(array(
	'macros' => false,
	));
	}


	/**
	* @task engine
	*/
	public static function newFeedMarkupEngine() {
	return self::newMarkupEngine(
	array(
	'macros' => false,
	'youtube' => false,

	));
	}


	/**
	* @task engine
	*/
	public static function newDifferentialMarkupEngine(array $options = array()) {
	return self::newMarkupEngine(array(
	'differential.diff' => idx($options, 'differential.diff'),
	));
	}


	/**
	* @task engine
	*/
	public static function newDiffusionMarkupEngine(array $options = array()) {
	return self::newMarkupEngine(array(
	'header.generate-toc' => true,
	));
	}

	/**
	* @task engine
	*/
	public static function getEngine($ruleset = 'default') {
	static $engines = array();
	if (isset($engines[$ruleset])) {
	return $engines[$ruleset];
	}

	$engine = null;
	switch ($ruleset) {
	case 'default':
	$engine = self::newMarkupEngine(array());
	break;
	case 'nolinebreaks':
	$engine = self::newMarkupEngine(array());
	$engine->setConfig('preserve-linebreaks', false);
	break;
	case 'diviner':
	$engine = self::newMarkupEngine(array());
	$engine->setConfig('preserve-linebreaks', false);
	// $engine->setConfig('diviner.renderer', new DivinerDefaultRenderer());
	$engine->setConfig('header.generate-toc', true);
	break;
	case 'extract':
	// Engine used for reference/edge extraction. Turn off anything which
	// is slow and doesn't change reference extraction.
	$engine = self::newMarkupEngine(array());
	$engine->setConfig('pygments.enabled', false);
	break;
	default:
	throw new Exception("Unknown engine ruleset: {$ruleset}!");
	}

	$engines[$ruleset] = $engine;
	return $engine;
	}

	/**
	* @task engine
	*/
	private static function getMarkupEngineDefaultConfiguration() {
	return array(
	'pygments' => PhabricatorEnv::getEnvConfig('pygments.enabled'),
	'youtube' => PhabricatorEnv::getEnvConfig(
	'remarkup.enable-embedded-youtube'),
	'differential.diff' => null,
	'header.generate-toc' => false,
	'macros' => true,
	'uri.allowed-protocols' => PhabricatorEnv::getEnvConfig(
	'uri.allowed-protocols'),
	'syntax-highlighter.engine' => PhabricatorEnv::getEnvConfig(
	'syntax-highlighter.engine'),
	'preserve-linebreaks' => true,
	);
	}


	/**
	* @task engine
	*/
	public static function newMarkupEngine(array $options) {

	$options += self::getMarkupEngineDefaultConfiguration();

	$engine = new PhutilRemarkupEngine();

	$engine->setConfig('preserve-linebreaks', $options['preserve-linebreaks']);
	$engine->setConfig('pygments.enabled', $options['pygments']);
	$engine->setConfig(
	'uri.allowed-protocols',
	$options['uri.allowed-protocols']);
	$engine->setConfig('differential.diff', $options['differential.diff']);
	$engine->setConfig('header.generate-toc', $options['header.generate-toc']);
	$engine->setConfig(
	'syntax-highlighter.engine',
	$options['syntax-highlighter.engine']);

	$rules = array();
	$rules[] = new PhutilRemarkupRuleEscapeRemarkup();
	$rules[] = new PhutilRemarkupRuleMonospace();


	$rules[] = new PhutilRemarkupRuleDocumentLink();

	if ($options['youtube']) {
	$rules[] = new PhabricatorRemarkupRuleYoutube();
	}

	$applications = PhabricatorApplication::getAllInstalledApplications();
	foreach ($applications as $application) {
	foreach ($application->getRemarkupRules() as $rule) {
	$rules[] = $rule;
	}
	}

	$rules[] = new PhutilRemarkupRuleHyperlink();

	if ($options['macros']) {
	$rules[] = new PhabricatorRemarkupRuleImageMacro();
	$rules[] = new PhabricatorRemarkupRuleMeme();
	}

	$rules[] = new PhutilRemarkupRuleBold();
	$rules[] = new PhutilRemarkupRuleItalic();
	$rules[] = new PhutilRemarkupRuleDel();
	$rules[] = new PhutilRemarkupRuleUnderline();

	foreach (self::loadCustomInlineRules() as $rule) {
	$rules[] = $rule;
	}

	$blocks = array();
	$blocks[] = new PhutilRemarkupEngineRemarkupQuotesBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupLiteralBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupHeaderBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupHorizontalRuleBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupListBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupCodeBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupNoteBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupTableBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupSimpleTableBlockRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupInterpreterRule();
	$blocks[] = new PhutilRemarkupEngineRemarkupDefaultBlockRule();

	foreach (self::loadCustomBlockRules() as $rule) {
	$blocks[] = $rule;
	}

	foreach ($blocks as $block) {
	$block->setMarkupRules($rules);
	}

	$engine->setBlockRules($blocks);

	return $engine;
	}

	- public static function extractPHIDsFromMentions(array $content_blocks) {
	+ public static function extractPHIDsFromMentions(
	+ PhabricatorUser $viewer,
	+ array $content_blocks) {
	+
	$mentions = array();

	$engine = self::newDifferentialMarkupEngine();
	- $engine->setConfig('viewer', PhabricatorUser::getOmnipotentUser());
	+ $engine->setConfig('viewer', $viewer);

	foreach ($content_blocks as $content_block) {
	$engine->markupText($content_block);
	$phids = $engine->getTextMetadata(
	PhabricatorRemarkupRuleMention::KEY_MENTIONED,
	array());
	$mentions += $phids;
	}

	return $mentions;
	}

	public static function extractFilePHIDsFromEmbeddedFiles(
	+ PhabricatorUser $viewer,
	array $content_blocks) {
	$files = array();

	$engine = self::newDifferentialMarkupEngine();
	- $engine->setConfig('viewer', PhabricatorUser::getOmnipotentUser());
	+ $engine->setConfig('viewer', $viewer);

	foreach ($content_blocks as $content_block) {
	$engine->markupText($content_block);
	$ids = $engine->getTextMetadata(
	PhabricatorRemarkupRuleEmbedFile::KEY_EMBED_FILE_PHIDS,
	array());
	$files += $ids;
	}

	return $files;
	}

	/**
	* Produce a corpus summary, in a way that shortens the underlying text
	* without truncating it somewhere awkward.
	*
	* TODO: We could do a better job of this.
	*
	* @param string Remarkup corpus to summarize.
	* @return string Summarized corpus.
	*/
	public static function summarize($corpus) {

	// Major goals here are:
	// - Don't split in the middle of a character (utf-8).
	// - Don't split in the middle of, e.g., bold text, since
	// we end up with hanging '**' in the summary.
	// - Try not to pick an image macro, header, embedded file, etc.
	// - Hopefully don't return too much text. We don't explicitly limit
	// this right now.

	$blocks = preg_split("/\n \n\s/", trim($corpus));

	$best = null;
	foreach ($blocks as $block) {
	// This is a test for normal spaces in the block, i.e. a heuristic to
	// distinguish standard paragraphs from things like image macros. It may
	// not work well for non-latin text. We prefer to summarize with a
	// paragraph of normal words over an image macro, if possible.
	$has_space = preg_match('/\w\s\w/', $block);

	// This is a test to find embedded images and headers. We prefer to
	// summarize with a normal paragraph over a header or an embedded object,
	// if possible.
	$has_embed = preg_match('/^[{=]/', $block);

	if ($has_space && !$has_embed) {
	// This seems like a good summary, so return it.
	return $block;
	}

	if (!$best) {
	// This is the first block we found; if everything is garbage just
	// use the first block.
	$best = $block;
	}
	}

	return $best;
	}

	private static function loadCustomInlineRules() {
	return id(new PhutilSymbolLoader())
	->setAncestorClass('PhabricatorRemarkupCustomInlineRule')
	->loadObjects();
	}

	private static function loadCustomBlockRules() {
	return id(new PhutilSymbolLoader())
	->setAncestorClass('PhabricatorRemarkupCustomBlockRule')
	->loadObjects();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jul 28, 11:12 AM (1 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 186735
Default Alt Text: (144 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions