No OneTemporary
Actions

Size

56 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/controller/subscribe/DifferentialSubscribeController.php b/src/applications/differential/controller/subscribe/DifferentialSubscribeController.php
	index bbd22df5ac..de72ff86fc 100644
	--- a/src/applications/differential/controller/subscribe/DifferentialSubscribeController.php
	+++ b/src/applications/differential/controller/subscribe/DifferentialSubscribeController.php
	@@ -1,92 +1,92 @@
	<?php

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

	final class DifferentialSubscribeController extends DifferentialController {

	private $id;
	private $action;

	public function willProcessRequest(array $data) {
	$this->id = $data['id'];
	$this->action = $data['action'];
	}

	public function processRequest() {

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

	$revision = id(new DifferentialRevision())->load($this->id);
	if (!$revision) {
	return new Aphront404Response();
	}

	if (!$request->isFormPost()) {
	$dialog = new AphrontDialogView();

	switch ($this->action) {
	case 'add':
	$button = 'Subscribe';
	$title = 'Subscribe to Revision';
	$prompt = 'Really subscribe to this revision?';
	break;
	case 'rem':
	$button = 'Unsubscribe';
	$title = 'Unsubscribe from Revision';
	- // TODO: Once herald is in, add a notice about not getting any more
	- // herald notifications.
	- $prompt = 'Really unsubscribe from this revision?';
	+ $prompt = 'Really unsubscribe from this revision? Herald will '.
	+ 'not resubscribe you to a revision you unsubscribe '.
	+ 'from.';
	break;
	default:
	return new Aphront400Response();
	}

	$dialog
	->setUser($user)
	->setTitle($title)
	->appendChild('<p>'.$prompt.'</p>')
	->setSubmitURI($request->getRequestURI())
	->addSubmitButton($button)
	->addCancelButton('/D'.$revision->getID());

	return id(new AphrontDialogResponse())->setDialog($dialog);
	}

	$revision->loadRelationships();
	$phid = $user->getPHID();

	switch ($this->action) {
	case 'add':
	DifferentialRevisionEditor::addCCAndUpdateRevision(
	$revision,
	$phid,
	$phid);
	break;
	case 'rem':
	DifferentialRevisionEditor::removeCCAndUpdateRevision(
	$revision,
	$phid,
	$phid);
	break;
	default:
	return new Aphront400Response();
	}

	return id(new AphrontRedirectResponse())->setURI('/D'.$revision->getID());
	}
	}
	diff --git a/src/applications/differential/editor/revision/DifferentialRevisionEditor.php b/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
	index fc8ffaf617..681a321eaa 100644
	--- a/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
	+++ b/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
	@@ -1,938 +1,944 @@
	<?php

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

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

	protected $revision;
	protected $actorPHID;

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

	private $auxiliaryFields = array();
	private $contentSource;

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

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

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

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

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

	$editor->copyFieldsFromConduit($fields);

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

	return $revision;
	}

	public function copyFieldsFromConduit(array $fields) {

	$revision = $this->revision;
	$revision->loadRelationships();

	$aux_fields = DifferentialFieldSelector::newSelector()
	->getFieldSpecifications();

	$user = id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$this->actorPHID);

	foreach ($aux_fields as $key => $aux_field) {
	$aux_field->setRevision($revision);
	$aux_field->setUser($user);
	if (!$aux_field->shouldAppearOnCommitMessage()) {
	unset($aux_fields[$key]);
	}
	}

	$aux_fields = mpull($aux_fields, null, 'getCommitMessageKey');

	foreach ($fields as $field => $value) {
	if (empty($aux_fields[$field])) {
	throw new Exception(
	"Parsed commit message contains unrecognized field '{$field}'.");
	}
	$aux_fields[$field]->setValueFromParsedCommitMessage($value);
	}

	foreach ($aux_fields as $aux_field) {
	$aux_field->validateField();
	}

	$aux_fields = array_values($aux_fields);
	$this->setAuxiliaryFields($aux_fields);
	}

	public function setAuxiliaryFields(array $auxiliary_fields) {
	$this->auxiliaryFields = $auxiliary_fields;
	return $this;
	}

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

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

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

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

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

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

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

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

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

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

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

	$is_new = $this->isNewRevision();
	if ($is_new) {
	$this->initializeNewRevision($revision);
	}

	$revision->loadRelationships();

	$this->willWriteRevision();

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

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

	$diff = $this->getDiff();
	if ($diff) {
	$revision->setLineCount($diff->getLineCount());
	}

	// Save the revision, to generate its ID and PHID if it is new. We need
	// the ID/PHID in order to record them in Herald transcripts, but don't
	// want to hold a transaction open while running Herald because it is
	// potentially somewhat slow. The downside is that we may end up with a
	// saved revision/diff pair without appropriate CCs. We could be better
	// about this -- for example:
	//
	// - Herald can't affect reviewers, so we could compute them before
	// opening the transaction and then save them in the transaction.
	// - Herald doesn't really need PHIDs to compute its effects, we could
	// run it before saving these objects and then hand over the PHIDs later.
	//
	// But this should address the problem of orphaned revisions, which is
	// currently the only problem we experience in practice.

	$revision->openTransaction();

	$revision->save();
	if ($diff) {
	$diff->setRevisionID($revision->getID());
	$diff->save();
	}

	$revision->saveTransaction();


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

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

	$xscript_header = null;
	$xscript_uri = null;

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

	$rem_ccs = array();
	+ $xscript_phid = null;
	if ($diff) {
	$adapter = new HeraldDifferentialRevisionAdapter(
	$revision,
	$diff);
	$adapter->setExplicitCCs($new['ccs']);
	$adapter->setExplicitReviewers($new['rev']);
	$adapter->setForbiddenCCs($revision->getUnsubscribedPHIDs());

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

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

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

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

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

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

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

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

	-/*
	-
	- // TODO: When Herald is brought over, run through this stuff to figure
	- // out which adds are Herald's fault.
	-
	- // TODO: Still need to do this.
	+ // We want to attribute new CCs to a "reasonPHID", representing the reason
	+ // they were added. This is either a user (if some user explicitly CCs
	+ // them, or uses "Add CCs...") or a Herald transcript PHID, indicating that
	+ // they were added by a Herald rule.

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

	$this->updateAuxiliaryFields();

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

	$mail = array();

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

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

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

	// Save the changes we made above.

	$diff->setDescription(preg_replace('/\n.*/s', '', $this->getComments()));
	$diff->save();

	$this->updateAffectedPathTable($revision, $diff, $changesets);
	$this->updateRevisionHashTable($revision, $diff);

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

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

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

	$revision->save();

	$this->didWriteRevision();

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

	id(new PhabricatorFeedStoryPublisher())
	->setStoryType(PhabricatorFeedStoryTypeConstants::STORY_DIFFERENTIAL)
	->setStoryData($event_data)
	->setStoryTime(time())
	->setStoryAuthorPHID($revision->getAuthorPHID())
	->setRelatedPHIDs(
	array(
	$revision->getPHID(),
	$revision->getAuthorPHID(),
	))
	->publish();

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

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

	$revision->loadRelationships();

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

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

	$mail[] = $message;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

	$revision->loadRelationships();
	}


	private function createComment() {
	$revision_id = $this->revision->getID();
	$comment = id(new DifferentialComment())
	->setAuthorPHID($this->getActorPHID())
	->setRevisionID($revision_id)
	->setContent($this->getComments())
	->setAction(DifferentialAction::ACTION_UPDATE)
	->setMetadata(
	array(
	DifferentialComment::METADATA_DIFF_ID => $this->getDiff()->getID(),
	));

	if ($this->contentSource) {
	$comment->setContentSource($this->contentSource);
	}

	$comment->save();

	return $comment;
	}

	private function updateAuxiliaryFields() {
	$aux_map = array();
	foreach ($this->auxiliaryFields as $aux_field) {
	$key = $aux_field->getStorageKey();
	if ($key !== null) {
	$val = $aux_field->getValueForStorage();
	$aux_map[$key] = $val;
	}
	}

	if (!$aux_map) {
	return;
	}

	$revision = $this->revision;

	$fields = id(new DifferentialAuxiliaryField())->loadAllWhere(
	'revisionPHID = %s AND name IN (%Ls)',
	$revision->getPHID(),
	array_keys($aux_map));
	$fields = mpull($fields, null, 'getName');

	foreach ($aux_map as $key => $val) {
	$obj = idx($fields, $key);
	if (!strlen($val)) {
	// If the new value is empty, just delete the old row if one exists and
	// don't add a new row if it doesn't.
	if ($obj) {
	$obj->delete();
	}
	} else {
	if (!$obj) {
	$obj = new DifferentialAuxiliaryField();
	$obj->setRevisionPHID($revision->getPHID());
	$obj->setName($key);
	}

	if ($obj->getValue() !== $val) {
	$obj->setValue($val);
	$obj->save();
	}
	}
	}
	}

	private function willWriteRevision() {
	foreach ($this->auxiliaryFields as $aux_field) {
	$aux_field->willWriteRevision($this);
	}
	}

	private function didWriteRevision() {
	foreach ($this->auxiliaryFields as $aux_field) {
	$aux_field->didWriteRevision($this);
	}
	}

	/**
	* Update the table which links Differential revisions to paths they affect,
	* so Diffusion can efficiently find pending revisions for a given file.
	*/
	private function updateAffectedPathTable(
	DifferentialRevision $revision,
	DifferentialDiff $diff,
	array $changesets) {

	$project = $diff->loadArcanistProject();
	if (!$project) {
	// Probably an old revision from before projects.
	return;
	}

	$repository = $project->loadRepository();
	if (!$repository) {
	// Probably no project <-> repository link, or the repository where the
	// project lives is untracked.
	return;
	}

	$path_prefix = null;

	$local_root = $diff->getSourceControlPath();
	if ($local_root) {
	// We're in a working copy which supports subdirectory checkouts (e.g.,
	// SVN) so we need to figure out what prefix we should add to each path
	// (e.g., trunk/projects/example/) to get the absolute path from the
	// root of the repository. DVCS systems like Git and Mercurial are not
	// affected.

	// Normalize both paths and check if the repository root is a prefix of
	// the local root. If so, throw it away. Note that this correctly handles
	// the case where the remote path is "/".
	$local_root = id(new PhutilURI($local_root))->getPath();
	$local_root = rtrim($local_root, '/');

	$repo_root = id(new PhutilURI($repository->getRemoteURI()))->getPath();
	$repo_root = rtrim($repo_root, '/');

	if (!strncmp($repo_root, $local_root, strlen($repo_root))) {
	$path_prefix = substr($local_root, strlen($repo_root));
	}
	}

	$paths = array();
	foreach ($changesets as $changeset) {
	$paths[] = $path_prefix.'/'.$changeset->getFilename();
	}

	// Mark this as also touching all parent paths, so you can see all pending
	// changes to any file within a directory.
	$all_paths = array();
	foreach ($paths as $local) {
	foreach (DiffusionPathIDQuery::expandPathToRoot($local) as $path) {
	$all_paths[$path] = true;
	}
	}
	$all_paths = array_keys($all_paths);

	$path_map = id(new DiffusionPathIDQuery($all_paths))->loadPathIDs();

	$table = new DifferentialAffectedPath();
	$conn_w = $table->establishConnection('w');

	$sql = array();
	foreach ($all_paths as $path) {
	$path_id = idx($path_map, $path);
	if (!$path_id) {
	// Don't bother creating these, it probably means we're either adding
	// a file (in which case having this row is irrelevant since Diffusion
	// won't be querying for it) or something is misconfigured (in which
	// case we'd just be writing garbage).
	continue;
	}
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %d, %d, %d)',
	$repository->getID(),
	$path_id,
	time(),
	$revision->getID());
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d',
	$table->getTableName(),
	$revision->getID());
	foreach (array_chunk($sql, 256) as $chunk) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (repositoryID, pathID, epoch, revisionID) VALUES %Q',
	$table->getTableName(),
	implode(', ', $chunk));
	}
	}


	/**
	* Update the table connecting revisions to DVCS local hashes, so we can
	* identify revisions by commit/tree hashes.
	*/
	private function updateRevisionHashTable(
	DifferentialRevision $revision,
	DifferentialDiff $diff) {

	$vcs = $diff->getSourceControlSystem();
	if ($vcs == DifferentialRevisionControlSystem::SVN) {
	// Subversion has no local commit or tree hash information, so we don't
	// have to do anything.
	return;
	}

	$property = id(new DifferentialDiffProperty())->loadOneWhere(
	'diffID = %d AND name = %s',
	$diff->getID(),
	'local:commits');
	if (!$property) {
	return;
	}

	$hashes = array();

	$data = $property->getData();
	switch ($vcs) {
	case DifferentialRevisionControlSystem::GIT:
	foreach ($data as $commit) {
	$hashes[] = array(
	ArcanistDifferentialRevisionHash::HASH_GIT_COMMIT,
	$commit['commit'],
	);
	$hashes[] = array(
	ArcanistDifferentialRevisionHash::HASH_GIT_TREE,
	$commit['tree'],
	);
	}
	break;
	case DifferentialRevisionControlSystem::MERCURIAL:
	foreach ($data as $commit) {
	$hashes[] = array(
	ArcanistDifferentialRevisionHash::HASH_MERCURIAL_COMMIT,
	$commit['rev'],
	);
	}
	break;
	}

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

	$sql = array();
	foreach ($hashes as $info) {
	list($type, $hash) = $info;
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %s, %s)',
	$revision->getID(),
	$type,
	$hash);
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d',
	ArcanistDifferentialRevisionHash::TABLE_NAME,
	$revision->getID());

	if ($sql) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (revisionID, type, hash) VALUES %Q',
	ArcanistDifferentialRevisionHash::TABLE_NAME,
	implode(', ', $sql));
	}
	}

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

	}

	diff --git a/src/applications/differential/mail/base/DifferentialMail.php b/src/applications/differential/mail/base/DifferentialMail.php
	index 67b1b963a7..9358446b3a 100644
	--- a/src/applications/differential/mail/base/DifferentialMail.php
	+++ b/src/applications/differential/mail/base/DifferentialMail.php
	@@ -1,371 +1,398 @@
	<?php

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

	abstract class DifferentialMail {

	protected $to = array();
	protected $cc = array();

	protected $actorHandle;

	protected $revision;
	protected $comment;
	protected $changesets;
	protected $inlineComments;
	protected $isFirstMailAboutRevision;
	protected $isFirstMailToRecipients;
	protected $heraldTranscriptURI;
	protected $heraldRulesHeader;
	protected $replyHandler;
	protected $parentMessageID;

	abstract protected function renderSubject();
	abstract protected function renderBody();

	public function setActorHandle($actor_handle) {
	$this->actorHandle = $actor_handle;
	return $this;
	}

	public function getActorHandle() {
	return $this->actorHandle;
	}

	protected function getActorName() {
	$handle = $this->getActorHandle();
	if ($handle) {
	return $handle->getName();
	}
	return '???';
	}

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

	public function setXHeraldRulesHeader($header) {
	$this->heraldRulesHeader = $header;
	return $this;
	}

	public function send() {
	$to_phids = $this->getToPHIDs();
	if (!$to_phids) {
	throw new Exception('No "To:" users provided!');
	}

	$cc_phids = $this->getCCPHIDs();
	$subject = $this->buildSubject();
	$body = $this->buildBody();
	$attachments = $this->buildAttachments();

	$template = new PhabricatorMetaMTAMail();
	$actor_handle = $this->getActorHandle();
	$reply_handler = $this->getReplyHandler();

	if ($actor_handle) {
	$template->setFrom($actor_handle->getPHID());
	}

	$template
	->setSubject($subject)
	->setBody($body)
	->setIsHTML($this->shouldMarkMailAsHTML())
	->setParentMessageID($this->parentMessageID)
	->addHeader('Thread-Topic', $this->getRevision()->getTitle());

	$template->setAttachments($attachments);

	$template->setThreadID(
	$this->getThreadID(),
	$this->isFirstMailAboutRevision());

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

	$revision = $this->revision;
	if ($revision) {
	if ($revision->getAuthorPHID()) {
	$template->addHeader(
	'X-Differential-Author',
	'<'.$revision->getAuthorPHID().'>');
	}
	if ($revision->getReviewers()) {
	$template->addHeader(
	'X-Differential-Reviewers',
	'<'.implode('>, <', $revision->getReviewers()).'>');
	}
	if ($revision->getCCPHIDs()) {
	$template->addHeader(
	'X-Differential-CCs',
	'<'.implode('>, <', $revision->getCCPHIDs()).'>');
	+
	+ // Determine explicit CCs (those added by humans) and put them in a
	+ // header so users can differentiate between Herald CCs and human CCs.
	+
	+ $relation_subscribed = DifferentialRevision::RELATION_SUBSCRIBED;
	+ $raw = $revision->getRawRelations($relation_subscribed);
	+
	+ $reason_phids = ipull($raw, 'reasonPHID');
	+ $reason_handles = id(new PhabricatorObjectHandleData($reason_phids))
	+ ->loadHandles();
	+
	+ $explicit_cc = array();
	+ foreach ($raw as $relation) {
	+ if (!$relation['reasonPHID']) {
	+ continue;
	+ }
	+ $type = $reason_handles[$relation['reasonPHID']]->getType();
	+ if ($type == PhabricatorPHIDConstants::PHID_TYPE_USER) {
	+ $explicit_cc[] = $relation['objectPHID'];
	+ }
	+ }
	+
	+ if ($explicit_cc) {
	+ $template->addHeader(
	+ 'X-Differential-Explicit-CCs',
	+ '<'.implode('>, <', $explicit_cc).'>');
	+ }
	}
	}

	$template->setIsBulk(true);
	$template->setRelatedPHID($this->getRevision()->getPHID());

	$mailtags = $this->getMailTags();
	if ($mailtags) {
	$template->setMailTags($mailtags);
	}

	$phids = array();
	foreach ($to_phids as $phid) {
	$phids[$phid] = true;
	}
	foreach ($cc_phids as $phid) {
	$phids[$phid] = true;
	}
	$phids = array_keys($phids);

	$handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_DIFFERENTIAL_WILLSENDMAIL,
	array(
	'mail' => $template,
	)
	);
	PhutilEventEngine::dispatchEvent($event);

	$template = $event->getValue('mail');

	$mails = $reply_handler->multiplexMail(
	$template,
	array_select_keys($handles, $to_phids),
	array_select_keys($handles, $cc_phids));

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

	protected function getMailTags() {
	return array();
	}

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

	protected function buildSubject() {
	return trim($this->getSubjectPrefix().' '.$this->renderSubject());
	}

	protected function shouldMarkMailAsHTML() {
	return false;
	}

	protected function buildBody() {

	$body = $this->renderBody();

	$reply_handler = $this->getReplyHandler();
	$reply_instructions = $reply_handler->getReplyHandlerInstructions();
	if ($reply_instructions) {
	$body .=
	"\nREPLY HANDLER ACTIONS\n".
	" {$reply_instructions}\n";
	}

	if ($this->getHeraldTranscriptURI() && $this->isFirstMailToRecipients()) {
	$manage_uri = PhabricatorEnv::getProductionURI(
	'/herald/view/differential/');

	$xscript_uri = $this->getHeraldTranscriptURI();
	$body .= <<<EOTEXT

	MANAGE HERALD DIFFERENTIAL RULES
	{$manage_uri}

	WHY DID I GET THIS EMAIL?
	{$xscript_uri}

	EOTEXT;
	}

	return $body;
	}

	/**
	* You can override this method in a subclass and return array of attachments
	* to be sent with the email. Each attachment is an instance of
	* PhabricatorMetaMTAAttachment.
	*/
	protected function buildAttachments() {
	return array();
	}

	public function getReplyHandler() {
	if (!$this->replyHandler) {
	$this->replyHandler =
	self::newReplyHandlerForRevision($this->getRevision());
	}

	return $this->replyHandler;
	}

	public static function newReplyHandlerForRevision(
	DifferentialRevision $revision) {

	$reply_handler = PhabricatorEnv::newObjectFromConfig(
	'metamta.differential.reply-handler');
	$reply_handler->setMailReceiver($revision);

	return $reply_handler;
	}


	protected function formatText($text) {
	$text = explode("\n", $text);
	foreach ($text as &$line) {
	$line = rtrim(' '.$line);
	}
	unset($line);
	return implode("\n", $text);
	}

	public function setToPHIDs(array $to) {
	$this->to = $this->filterContactPHIDs($to);
	return $this;
	}

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

	protected function filterContactPHIDs(array $phids) {
	return $phids;

	// TODO: actually do this?

	// Differential revisions use Subscriptions for CCs, so any arbitrary
	// PHID can end up CC'd to them. Only try to actually send email PHIDs
	// which have ToolsHandle types that are marked emailable. If we don't
	// filter here, sending the email will fail.
	/*
	$handles = array();
	prep(new ToolsHandleData($phids, $handles));
	foreach ($handles as $phid => $handle) {
	if (!$handle->isEmailable()) {
	unset($handles[$phid]);
	}
	}
	return array_keys($handles);
	*/
	}

	protected function getToPHIDs() {
	return $this->to;
	}

	protected function getCCPHIDs() {
	return $this->cc;
	}

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

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

	protected function getThreadID() {
	$phid = $this->getRevision()->getPHID();
	$domain = PhabricatorEnv::getEnvConfig('metamta.domain');
	return "<differential-rev-{$phid}-req@{$domain}>";
	}

	public function setComment($comment) {
	$this->comment = $comment;
	return $this;
	}

	public function getComment() {
	return $this->comment;
	}

	public function setChangesets($changesets) {
	$this->changesets = $changesets;
	return $this;
	}

	public function getChangesets() {
	return $this->changesets;
	}

	public function setInlineComments(array $inline_comments) {
	$this->inlineComments = $inline_comments;
	return $this;
	}

	public function getInlineComments() {
	return $this->inlineComments;
	}

	public function renderRevisionDetailLink() {
	$uri = $this->getRevisionURI();
	return "REVISION DETAIL\n {$uri}";
	}

	public function getRevisionURI() {
	return PhabricatorEnv::getProductionURI('/D'.$this->getRevision()->getID());
	}

	public function setIsFirstMailToRecipients($first) {
	$this->isFirstMailToRecipients = $first;
	return $this;
	}

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

	public function setIsFirstMailAboutRevision($first) {
	$this->isFirstMailAboutRevision = $first;
	return $this;
	}

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

	public function setHeraldTranscriptURI($herald_transcript_uri) {
	$this->heraldTranscriptURI = $herald_transcript_uri;
	return $this;
	}

	public function getHeraldTranscriptURI() {
	return $this->heraldTranscriptURI;
	}

	protected function renderHandleList(array $handles, array $phids) {
	$names = array();
	foreach ($phids as $phid) {
	$names[] = $handles[$phid]->getName();
	}
	return implode(', ', $names);
	}

	}
	diff --git a/src/applications/differential/mail/base/__init__.php b/src/applications/differential/mail/base/__init__.php
	index 7c9230ba90..b1b70e951e 100644
	--- a/src/applications/differential/mail/base/__init__.php
	+++ b/src/applications/differential/mail/base/__init__.php
	@@ -1,19 +1,21 @@
	<?php
	/**
	* This file is automatically generated. Lint this module to rebuild it.
	* @generated
	*/



	+phutil_require_module('phabricator', 'applications/differential/storage/revision');
	phutil_require_module('phabricator', 'applications/metamta/storage/mail');
	+phutil_require_module('phabricator', 'applications/phid/constants');
	phutil_require_module('phabricator', 'applications/phid/handle/data');
	phutil_require_module('phabricator', 'infrastructure/env');
	phutil_require_module('phabricator', 'infrastructure/events/constant/type');
	phutil_require_module('phabricator', 'infrastructure/events/event');

	phutil_require_module('phutil', 'events/engine');
	phutil_require_module('phutil', 'utils');


	phutil_require_source('DifferentialMail.php');
	diff --git a/src/applications/differential/view/revisioncomment/DifferentialRevisionCommentView.php b/src/applications/differential/view/revisioncomment/DifferentialRevisionCommentView.php
	index a08df37894..fdec2a3b1d 100644
	--- a/src/applications/differential/view/revisioncomment/DifferentialRevisionCommentView.php
	+++ b/src/applications/differential/view/revisioncomment/DifferentialRevisionCommentView.php
	@@ -1,301 +1,303 @@
	<?php

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

	final class DifferentialRevisionCommentView extends AphrontView {

	private $comment;
	private $handles;
	private $markupEngine;
	private $preview;
	private $inlines;
	private $changesets;
	private $target;
	private $anchorName;
	private $user;
	private $versusDiffID;

	public function setComment($comment) {
	$this->comment = $comment;
	return $this;
	}

	public function setHandles(array $handles) {
	$this->handles = $handles;
	return $this;
	}

	public function setMarkupEngine($markup_engine) {
	$this->markupEngine = $markup_engine;
	return $this;
	}

	public function setPreview($preview) {
	$this->preview = $preview;
	return $this;
	}

	public function setInlineComments(array $inline_comments) {
	$this->inlines = $inline_comments;
	return $this;
	}

	public function setChangesets(array $changesets) {
	// Ship these in sorted by getSortKey() and keyed by ID... or else!
	$this->changesets = $changesets;
	return $this;
	}

	public function setTargetDiff($target) {
	$this->target = $target;
	return $this;
	}

	public function setVersusDiffID($diff_vs) {
	$this->versusDiffID = $diff_vs;
	return $this;
	}

	public function setAnchorName($anchor_name) {
	$this->anchorName = $anchor_name;
	return $this;
	}

	public function setUser(PhabricatorUser $user) {
	$this->user = $user;
	return $this;
	}

	public function render() {

	if (!$this->user) {
	throw new Exception("Call setUser() before rendering!");
	}

	require_celerity_resource('phabricator-remarkup-css');
	require_celerity_resource('differential-revision-comment-css');

	$comment = $this->comment;

	$action = $comment->getAction();

	$action_class = 'differential-comment-action-'.$action;

	$info = array();

	$content = $comment->getContent();
	$hide_comments = true;
	if (strlen(rtrim($content))) {
	$hide_comments = false;
	$cache = $comment->getCache();
	if (strlen($cache)) {
	$content = $cache;
	} else {
	$content = $this->markupEngine->markupText($content);
	if ($comment->getID()) {
	$comment->setCache($content);

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$comment->save();
	unset($unguarded);
	}
	}
	$content =
	'<div class="phabricator-remarkup">'.
	$content.
	'</div>';
	}

	$inline_render = $this->renderInlineComments();
	if ($inline_render) {
	$hide_comments = false;
	}

	$author = $this->handles[$comment->getAuthorPHID()];
	$author_link = $author->renderLink();

	$metadata = $comment->getMetadata();
	$added_reviewers = idx(
	$metadata,
	- DifferentialComment::METADATA_ADDED_REVIEWERS);
	+ DifferentialComment::METADATA_ADDED_REVIEWERS,
	+ array());
	$added_ccs = idx(
	$metadata,
	- DifferentialComment::METADATA_ADDED_CCS);
	+ DifferentialComment::METADATA_ADDED_CCS,
	+ array());

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

	$actions = array();
	switch ($comment->getAction()) {
	case DifferentialAction::ACTION_ADDCCS:
	$actions[] = "{$author_link} added CCs: ".
	$this->renderHandleList($added_ccs).".";
	$added_ccs = null;
	break;
	case DifferentialAction::ACTION_ADDREVIEWERS:
	$actions[] = "{$author_link} added reviewers: ".
	$this->renderHandleList($added_reviewers).".";
	$added_reviewers = null;
	break;
	case DifferentialAction::ACTION_UPDATE:
	$diff_id = idx($metadata, DifferentialComment::METADATA_DIFF_ID);
	if ($diff_id) {
	$diff_link = phutil_render_tag(
	'a',
	array(
	'href' => '/D'.$comment->getRevisionID().'?id='.$diff_id,
	),
	'Diff #'.phutil_escape_html($diff_id));
	$actions[] = "{$author_link} updated this revision to {$diff_link}.";
	} else {
	$actions[] = "{$author_link} {$verb} this revision.";
	}
	break;
	default:
	$actions[] = "{$author_link} {$verb} this revision.";
	break;
	}

	if ($added_reviewers) {
	$actions[] = "{$author_link} added reviewers: ".
	$this->renderHandleList($added_reviewers).".";
	}

	if ($added_ccs) {
	$actions[] = "{$author_link} added CCs: ".
	$this->renderHandleList($added_ccs).".";
	}

	foreach ($actions as $key => $action) {
	$actions[$key] = '<div>'.$action.'</div>';
	}

	$xaction_view = id(new PhabricatorTransactionView())
	->setUser($this->user)
	->setImageURI($author->getImageURI())
	->setContentSource($comment->getContentSource())
	->addClass($action_class)
	->setActions($actions);

	if ($this->preview) {
	$xaction_view->setIsPreview($this->preview);
	} else {
	$xaction_view->setEpoch($comment->getDateCreated());
	if ($this->anchorName) {
	$anchor_name = $this->anchorName;
	$anchor_text = 'D'.$comment->getRevisionID().'#'.$anchor_name;

	$xaction_view->setAnchor($anchor_name, $anchor_text);
	}
	}

	if (!$hide_comments) {
	$xaction_view->appendChild(
	'<div class="differential-comment-core">'.
	$content.
	'</div>'.
	$this->renderSingleView($inline_render));
	}

	return $xaction_view->render();
	}

	private function renderHandleList(array $phids) {
	$result = array();
	foreach ($phids as $phid) {
	$result[] = $this->handles[$phid]->renderLink();
	}
	return implode(', ', $result);
	}

	private function renderInlineComments() {
	if (!$this->inlines) {
	return null;
	}

	$inlines = $this->inlines;
	$changesets = $this->changesets;
	$inlines_by_changeset = mgroup($inlines, 'getChangesetID');
	$inlines_by_changeset = array_select_keys(
	$inlines_by_changeset,
	array_keys($this->changesets));

	$view = new PhabricatorInlineSummaryView();
	foreach ($inlines_by_changeset as $changeset_id => $inlines) {
	$changeset = $changesets[$changeset_id];
	$items = array();
	foreach ($inlines as $inline) {

	$on_target = ($this->target) &&
	($this->target->getID() == $changeset->getDiffID());

	$is_visible = false;
	if ($inline->getIsNewFile()) {
	// This comment is on the right side of the versus diff, and visible
	// on the left side of the page.
	if ($this->versusDiffID) {
	if ($changeset->getDiffID() == $this->versusDiffID) {
	$is_visible = true;
	}
	}

	// This comment is on the right side of the target diff, and visible
	// on the right side of the page.
	if ($on_target) {
	$is_visible = true;
	}
	} else {
	// Ths comment is on the left side of the target diff, and visible
	// on the left side of the page.
	if (!$this->versusDiffID) {
	if ($on_target) {
	$is_visible = true;
	}
	}

	// TODO: We still get one edge case wrong here, when we have a
	// versus diff and the file didn't exist in the old version. The
	// comment is visible because we show the left side of the target
	// diff when there's no corresponding file in the versus diff, but
	// we incorrectly link it off-page.
	}

	$item = array(
	'id' => $inline->getID(),
	'line' => $inline->getLineNumber(),
	'length' => $inline->getLineLength(),
	'content' => PhabricatorInlineSummaryView::renderCommentContent(
	$inline,
	$this->markupEngine),
	);

	if (!$is_visible) {
	$diff_id = $changeset->getDiffID();
	$item['where'] = '(On Diff #'.$diff_id.')';
	$item['href'] = '?id='.$diff_id.'#inline-'.$inline->getID();
	}

	$items[] = $item;
	}
	$view->addCommentGroup($changeset->getFilename(), $items);
	}

	return $view;
	}


	}
	diff --git a/src/docs/userguide/mail_rules.diviner b/src/docs/userguide/mail_rules.diviner
	index 07bb07bc51..27079b93d7 100644
	--- a/src/docs/userguide/mail_rules.diviner
	+++ b/src/docs/userguide/mail_rules.diviner
	@@ -1,72 +1,75 @@
	@title User Guide: Managing Phabricator Email
	@group userguide

	How to effectively manage Phabricator email notifications.

	= Overview =

	Phabricator uses email as a major notification channel, but the amount of email
	it sends can seem overwhelming if you're working on an active team. This
	document discusses some strategies for managing email.

	By far the best approach to managing mail is to write mail rules to
	categorize mail. Essentially all modern mail clients allow you to quickly
	write sophisticated rules to route, categorize, or delete email.

	= Reducing Email =

	You can reduce the amount of email you receive by turning off some types of
	email in ##Settings -> Email Preferences##. For example, you can turn off email
	produced by your own actions (like when you comment on a revision), and some
	types of less-important notifications about events.

	= Mail Rules =

	The best approach to managing mail is to write mail rules. Simply writing rules
	to move mail from Differential, Maniphest and Herald to separate folders will
	vastly simplify mail management.

	Phabricator also sets a large number of headers (see below) which can allow you
	to write more sophisticated mail rules.

	= Mail Headers =

	Phabricator sends a variety of mail headers that can be useful in crafting rules
	to route and manage mail.

	Many of these headers contain lists. A list containing two items, ##1## and
	##15## will generally be formatted like this:

	X-Header: <1>, <15>

	The intent is to allow you to write a rule which matches against "<1>". If you
	just match against "1", you'll incorrectly match "15", but matching "<1>" will
	correctly match only "<1>".

	The headers Phabricator adds to mail are:

	- ##X-Phabricator-Sent-This-Message##: this is attached to all mail
	Phabricator sends. You can use it to differentiate between email from
	Phabricator and replies/forwards of Phabricator mail from human beings.
	- ##X-Phabricator-To##: this is attached to all mail Phabricator sends.
	It this shows the PHIDs of the original "To" line, before any mutation
	by the mailer configuration.
	- ##X-Phabricator-Cc##: this is attached to all mail Phabricator sends.
	It shows the PHIDs of the original "Cc" line, before any mutation by the
	mailer configuration.
	- ##X-Differential-Author##: this is attached to Differential mail and shows
	the revision's author. You can use it to filter mail about your revisions
	(or other users' revisions).
	- ##X-Differential-Reviewers##: this is attached to Differential mail and
	shows the reviewers. You can use it to filter mail about revisions you
	are reviewing, versus revisions you are explicitly CC'd on or CC'd as
	a result of Herald rules.
	- ##X-Differential-CCs##: this is attached to Differential mail and shows
	- the explicit CCs on the revision.
	+ the CCs on the revision.
	+ - ##X-Differential-Explicit-CCs##: this is attached to Differential mail and
	+ shows the explicit CCs on the revision (those that were added by humans,
	+ not by Herald).
	- ##X-Phabricator-Mail-Tags##: this is attached to some mail and has
	a list of descriptors about the mail. (This is fairly new and subject
	to some change.)
	- ##X-Herald-Rules##: this is attached to some mail and shows Herald rule
	IDs which have triggered for the object. You can use this to sort or
	categorize mail that has triggered specific rules.

File Metadata

Mime Type: text/x-diff
Expires: Fri, Nov 14, 10:39 AM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 336933
Default Alt Text: (56 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions