No OneTemporary
Actions

Size

97 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/maniphest/storage/ManiphestTransaction.php b/src/applications/maniphest/storage/ManiphestTransaction.php
	index e7777333fc..4ad89458b2 100644
	--- a/src/applications/maniphest/storage/ManiphestTransaction.php
	+++ b/src/applications/maniphest/storage/ManiphestTransaction.php
	@@ -1,447 +1,639 @@
	<?php

	final class ManiphestTransaction
	extends PhabricatorApplicationTransaction {

	const TYPE_TITLE = 'title';
	const TYPE_STATUS = 'status';
	const TYPE_DESCRIPTION = 'description';
	const TYPE_OWNER = 'reassign';
	const TYPE_CCS = 'ccs';
	const TYPE_PROJECTS = 'projects';
	const TYPE_PRIORITY = 'priority';
	const TYPE_EDGE = 'edge';
	const TYPE_ATTACH = 'attach';

	public function getApplicationName() {
	return 'maniphest';
	}

	public function getApplicationTransactionType() {
	return ManiphestPHIDTypeTask::TYPECONST;
	}

	public function getApplicationTransactionCommentObject() {
	return new ManiphestTransactionComment();
	}

	public function getRequiredHandlePHIDs() {
	$phids = parent::getRequiredHandlePHIDs();

	$new = $this->getNewValue();
	$old = $this->getOldValue();

	switch ($this->getTransactionType()) {
	case self::TYPE_OWNER:
	if ($new) {
	$phids[] = $new;
	}

	if ($old) {
	$phids[] = $old;
	}
	break;
	case self::TYPE_CCS:
	case self::TYPE_PROJECTS:
	$phids = array_mergev(
	array(
	$phids,
	nonempty($old, array()),
	nonempty($new, array()),
	));
	break;
	case self::TYPE_EDGE:
	$phids = array_mergev(
	array(
	$phids,
	array_keys(nonempty($old, array())),
	array_keys(nonempty($new, array())),
	));
	break;
	case self::TYPE_ATTACH:
	$old = nonempty($old, array());
	$new = nonempty($new, array());
	$phids = array_mergev(
	array(
	$phids,
	array_keys(idx($new, 'FILE', array())),
	array_keys(idx($old, 'FILE', array())),
	));
	break;

	}

	return $phids;
	}


	public function getColor() {
	$old = $this->getOldValue();
	$new = $this->getNewValue();

	switch ($this->getTransactionType()) {
	case self::TYPE_STATUS:
	if ($new == ManiphestTaskStatus::STATUS_OPEN) {
	if ($old) {
	return 'violet';
	} else {
	return 'green';
	}
	} else {
	return 'black';
	}

	case self::TYPE_PRIORITY:
	if ($old == ManiphestTaskPriority::getDefaultPriority()) {
	return 'green';
	} else if ($old > $new) {
	return 'grey';
	} else {
	return 'yellow';
	}

	}

	return parent::getColor();
	}

	public function getActionName() {
	$old = $this->getOldValue();
	$new = $this->getNewValue();

	switch ($this->getTransactionType()) {
	case self::TYPE_TITLE:
	return pht('Retitled');

	case self::TYPE_STATUS:
	if ($new == ManiphestTaskStatus::STATUS_OPEN) {
	if ($old) {
	return pht('Reopened');
	} else {
	return pht('Created');
	}
	} else {
	switch ($new) {
	case ManiphestTaskStatus::STATUS_CLOSED_SPITE:
	return pht('Spited');
	case ManiphestTaskStatus::STATUS_CLOSED_DUPLICATE:
	return pht('Merged');
	default:
	return pht('Closed');
	}
	}

	case self::TYPE_DESCRIPTION:
	return pht('Edited');

	case self::TYPE_OWNER:
	if ($this->getAuthorPHID() == $new) {
	return pht('Claimed');
	} else if (!$new) {
	return pht('Up For Grabs');
	} else if (!$old) {
	return pht('Assigned');
	} else {
	return pht('Reassigned');
	}

	case self::TYPE_CCS:
	return pht('Changed CC');

	case self::TYPE_PROJECTS:
	return pht('Changed Projects');

	case self::TYPE_PRIORITY:
	if ($old == ManiphestTaskPriority::getDefaultPriority()) {
	return pht('Triaged');
	} else if ($old > $new) {
	return pht('Lowered Priority');
	} else {
	return pht('Raised Priority');
	}

	case self::TYPE_EDGE:
	case self::TYPE_ATTACH:
	return pht('Attached');
	}

	return parent::getActionName();
	}

	public function getIcon() {
	$old = $this->getOldValue();
	$new = $this->getNewValue();

	switch ($this->getTransactionType()) {
	case self::TYPE_TITLE:
	return 'edit';

	case self::TYPE_STATUS:
	if ($new == ManiphestTaskStatus::STATUS_OPEN) {
	return 'create';
	} else {
	switch ($new) {
	case ManiphestTaskStatus::STATUS_CLOSED_SPITE:
	return 'dislike';
	case ManiphestTaskStatus::STATUS_CLOSED_DUPLICATE:
	return 'delete';
	default:
	return 'check';
	}
	}

	case self::TYPE_DESCRIPTION:
	return 'edit';

	case self::TYPE_PROJECTS:
	return 'tag';

	case self::TYPE_PRIORITY:
	if ($old == ManiphestTaskPriority::getDefaultPriority()) {
	return 'start-sandcastle';
	return pht('Triaged');
	} else if ($old > $new) {
	return 'download-alt';
	} else {
	return 'upload';
	}

	case self::TYPE_EDGE:
	case self::TYPE_ATTACH:
	return 'attach';

	}

	return parent::getIcon();
	}



	public function getTitle() {
	$author_phid = $this->getAuthorPHID();

	$old = $this->getOldValue();
	$new = $this->getNewValue();

	switch ($this->getTransactionType()) {
	case self::TYPE_TITLE:
	return pht(
	'%s changed the title from "%s" to "%s".',
	$this->renderHandleLink($author_phid),
	$old,
	$new);

	case self::TYPE_DESCRIPTION:
	return pht(
	'%s edited the task description.',
	$this->renderHandleLink($author_phid));

	case self::TYPE_STATUS:
	if ($new == ManiphestTaskStatus::STATUS_OPEN) {
	if ($old) {
	return pht(
	'%s reopened this task.',
	$this->renderHandleLink($author_phid));
	} else {
	return pht(
	'%s created this task.',
	$this->renderHandleLink($author_phid));
	}
	} else {
	switch ($new) {
	case ManiphestTaskStatus::STATUS_CLOSED_SPITE:
	return pht(
	'%s closed this task out of spite.',
	$this->renderHandleLink($author_phid));
	case ManiphestTaskStatus::STATUS_CLOSED_DUPLICATE:
	return pht(
	'%s closed this task as a duplicate.',
	$this->renderHandleLink($author_phid));
	default:
	$status_name = idx(
	ManiphestTaskStatus::getTaskStatusMap(),
	$new,
	'???');
	return pht(
	'%s closed this task as "%s".',
	$this->renderHandleLink($author_phid),
	$status_name);
	}
	}

	case self::TYPE_OWNER:
	if ($author_phid == $new) {
	return pht(
	'%s claimed this task.',
	$this->renderHandleLink($author_phid));
	} else if (!$new) {
	return pht(
	'%s placed this task up for grabs.',
	$this->renderHandleLink($author_phid));
	} else if (!$old) {
	return pht(
	'%s assigned this task to %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($new));
	} else {
	return pht(
	'%s reassigned this task from %s to %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($old),
	$this->renderHandleLink($new));
	}

	case self::TYPE_PROJECTS:
	$added = array_diff($new, $old);
	$removed = array_diff($old, $new);
	if ($added && !$removed) {
	return pht(
	'%s added %d project(s): %s',
	$this->renderHandleLink($author_phid),
	count($added),
	$this->renderHandleList($added));
	} else if ($removed && !$added) {
	return pht(
	'%s removed %d project(s): %s',
	$this->renderHandleLink($author_phid),
	count($removed),
	$this->renderHandleList($removed));
	} else if ($removed && $added) {
	return pht(
	'%s changed project(s), added %d: %s; removed %d: %s',
	$this->renderHandleLink($author_phid),
	count($added),
	$this->renderHandleList($added),
	count($removed),
	$this->renderHandleList($removed));
	} else {
	// This is hit when rendering previews.
	return pht(
	'%s changed projects...',
	$this->renderHandleLink($author_phid));
	}

	case self::TYPE_PRIORITY:
	$old_name = ManiphestTaskPriority::getTaskPriorityName($old);
	$new_name = ManiphestTaskPriority::getTaskPriorityName($new);

	if ($old == ManiphestTaskPriority::getDefaultPriority()) {
	return pht(
	'%s triaged this task as "%s" priority.',
	$this->renderHandleLink($author_phid),
	$new_name);
	} else if ($old > $new) {
	return pht(
	'%s lowered the priority of this task from "%s" to "%s".',
	$this->renderHandleLink($author_phid),
	$old_name,
	$new_name);
	} else {
	return pht(
	'%s raised the priority of this task from "%s" to "%s".',
	$this->renderHandleLink($author_phid),
	$old_name,
	$new_name);
	}

	case self::TYPE_CCS:
	// TODO: Remove this when we switch to subscribers. Just reuse the
	// code in the parent.
	$clone = clone $this;
	$clone->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
	return $clone->getTitle();

	case self::TYPE_EDGE:
	// TODO: Remove this when we switch to real edges. Just reuse the
	// code in the parent;
	$clone = clone $this;
	$clone->setTransactionType(PhabricatorTransactions::TYPE_EDGE);
	return $clone->getTitle();

	case self::TYPE_ATTACH:
	$old = nonempty($old, array());
	$new = nonempty($new, array());
	$new = array_keys(idx($new, 'FILE', array()));
	$old = array_keys(idx($old, 'FILE', array()));

	$added = array_diff($new, $old);
	$removed = array_diff($old, $new);
	if ($added && !$removed) {
	return pht(
	'%s attached %d file(s): %s',
	$this->renderHandleLink($author_phid),
	count($added),
	$this->renderHandleList($added));
	} else if ($removed && !$added) {
	return pht(
	'%s detached %d file(s): %s',
	$this->renderHandleLink($author_phid),
	count($removed),
	$this->renderHandleList($removed));
	} else {
	return pht(
	'%s changed file(s), attached %d: %s; detached %d: %s',
	$this->renderHandleLink($author_phid),
	count($added),
	$this->renderHandleList($added),
	count($removed),
	$this->renderHandleList($removed));
	}


	}

	return parent::getTitle();
	}

	+ public function getTitleForFeed(PhabricatorFeedStory $story) {
	+ $author_phid = $this->getAuthorPHID();
	+ $object_phid = $this->getObjectPHID();
	+
	+ $old = $this->getOldValue();
	+ $new = $this->getNewValue();
	+
	+ switch ($this->getTransactionType()) {
	+ case self::TYPE_TITLE:
	+ return pht(
	+ '%s renamed %s from "%s" to "%s".',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ $old,
	+ $new);
	+
	+ case self::TYPE_DESCRIPTION:
	+ return pht(
	+ '%s edited the description of %s.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+
	+ case self::TYPE_STATUS:
	+ if ($new == ManiphestTaskStatus::STATUS_OPEN) {
	+ if ($old) {
	+ return pht(
	+ '%s reopened %s.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ } else {
	+ return pht(
	+ '%s created %s.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ }
	+ } else {
	+ switch ($new) {
	+ case ManiphestTaskStatus::STATUS_CLOSED_SPITE:
	+ return pht(
	+ '%s closed %s out of spite.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ case ManiphestTaskStatus::STATUS_CLOSED_DUPLICATE:
	+ return pht(
	+ '%s closed %s as a duplicate.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ default:
	+ $status_name = idx(
	+ ManiphestTaskStatus::getTaskStatusMap(),
	+ $new,
	+ '???');
	+ return pht(
	+ '%s closed %s as "%s".',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ $status_name);
	+ }
	+ }
	+
	+ case self::TYPE_OWNER:
	+ if ($author_phid == $new) {
	+ return pht(
	+ '%s claimed %s.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ } else if (!$new) {
	+ return pht(
	+ '%s placed %s up for grabs.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ } else if (!$old) {
	+ return pht(
	+ '%s assigned %s to %s.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ $this->renderHandleLink($new));
	+ } else {
	+ return pht(
	+ '%s reassigned %s from %s to %s.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ $this->renderHandleLink($old),
	+ $this->renderHandleLink($new));
	+ }
	+
	+ case self::TYPE_PROJECTS:
	+ $added = array_diff($new, $old);
	+ $removed = array_diff($old, $new);
	+ if ($added && !$removed) {
	+ return pht(
	+ '%s added %d project(s) to %s: %s',
	+ $this->renderHandleLink($author_phid),
	+ count($added),
	+ $this->renderHandleLink($object_phid),
	+ $this->renderHandleList($added));
	+ } else if ($removed && !$added) {
	+ return pht(
	+ '%s removed %d project(s) to %s: %s',
	+ $this->renderHandleLink($author_phid),
	+ count($removed),
	+ $this->renderHandleLink($object_phid),
	+ $this->renderHandleList($removed));
	+ } else if ($removed && $added) {
	+ return pht(
	+ '%s changed project(s) of %s, added %d: %s; removed %d: %s',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ count($added),
	+ $this->renderHandleList($added),
	+ count($removed),
	+ $this->renderHandleList($removed));
	+ }
	+
	+ case self::TYPE_PRIORITY:
	+ $old_name = ManiphestTaskPriority::getTaskPriorityName($old);
	+ $new_name = ManiphestTaskPriority::getTaskPriorityName($new);
	+
	+ if ($old == ManiphestTaskPriority::getDefaultPriority()) {
	+ return pht(
	+ '%s triaged %s as "%s" priority.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ $new_name);
	+ } else if ($old > $new) {
	+ return pht(
	+ '%s lowered the priority of %s from "%s" to "%s".',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ $old_name,
	+ $new_name);
	+ } else {
	+ return pht(
	+ '%s raised the priority of %s from "%s" to "%s".',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ $old_name,
	+ $new_name);
	+ }
	+
	+ case self::TYPE_CCS:
	+ // TODO: Remove this when we switch to subscribers. Just reuse the
	+ // code in the parent.
	+ $clone = clone $this;
	+ $clone->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
	+ return $clone->getTitleForFeed($story);
	+
	+ case self::TYPE_EDGE:
	+ // TODO: Remove this when we switch to real edges. Just reuse the
	+ // code in the parent;
	+ $clone = clone $this;
	+ $clone->setTransactionType(PhabricatorTransactions::TYPE_EDGE);
	+ return $clone->getTitleForFeed($story);
	+
	+ case self::TYPE_ATTACH:
	+ $old = nonempty($old, array());
	+ $new = nonempty($new, array());
	+ $new = array_keys(idx($new, 'FILE', array()));
	+ $old = array_keys(idx($old, 'FILE', array()));
	+
	+ $added = array_diff($new, $old);
	+ $removed = array_diff($old, $new);
	+ if ($added && !$removed) {
	+ return pht(
	+ '%s attached %d file(s) of %s: %s',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ count($added),
	+ $this->renderHandleList($added));
	+ } else if ($removed && !$added) {
	+ return pht(
	+ '%s detached %d file(s) of %s: %s',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ count($removed),
	+ $this->renderHandleList($removed));
	+ } else {
	+ return pht(
	+ '%s changed file(s) for %s, attached %d: %s; detached %d: %s',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ count($added),
	+ $this->renderHandleList($added),
	+ count($removed),
	+ $this->renderHandleList($removed));
	+ }
	+
	+ }
	+
	+ return parent::getTitleForFeed($story);
	+ }
	+
	public function hasChangeDetails() {
	switch ($this->getTransactionType()) {
	case self::TYPE_DESCRIPTION:
	return true;
	}
	return parent::hasChangeDetails();
	}

	public function renderChangeDetails(PhabricatorUser $viewer) {
	$old = $this->getOldValue();
	$new = $this->getNewValue();

	$view = id(new PhabricatorApplicationTransactionTextDiffDetailView())
	->setUser($viewer)
	->setOldText($old)
	->setNewText($new);

	return $view->render();
	}

	public function getMailTags() {
	$tags = array();
	switch ($this->getTransactionType()) {
	case self::TYPE_STATUS:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_STATUS;
	break;
	case self::TYPE_OWNER:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_OWNER;
	break;
	case self::TYPE_CCS:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_CC;
	break;
	case self::TYPE_PROJECTS:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_PROJECTS;
	break;
	case self::TYPE_PRIORITY:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_PRIORITY;
	break;
	case PhabricatorTransactions::TYPE_COMMENT:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_COMMENT;
	break;
	default:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_OTHER;
	break;
	}
	return $tags;
	}


	}

	diff --git a/src/applications/transactions/storage/PhabricatorApplicationTransaction.php b/src/applications/transactions/storage/PhabricatorApplicationTransaction.php
	index 1f3089caf7..4442cd038f 100644
	--- a/src/applications/transactions/storage/PhabricatorApplicationTransaction.php
	+++ b/src/applications/transactions/storage/PhabricatorApplicationTransaction.php
	@@ -1,517 +1,536 @@
	<?php

	abstract class PhabricatorApplicationTransaction
	extends PhabricatorLiskDAO
	implements PhabricatorPolicyInterface {

	const TARGET_TEXT = 'text';
	const TARGET_HTML = 'html';

	protected $phid;
	protected $objectPHID;
	protected $authorPHID;
	protected $viewPolicy;
	protected $editPolicy;

	protected $commentPHID;
	protected $commentVersion = 0;
	protected $transactionType;
	protected $oldValue;
	protected $newValue;
	protected $metadata = array();

	protected $contentSource;

	private $comment;
	private $commentNotLoaded;

	private $handles;
	private $renderingTarget = self::TARGET_HTML;
	private $transactionGroup = array();
	private $viewer = self::ATTACHABLE;

	abstract public function getApplicationTransactionType();

	private function getApplicationObjectTypeName() {
	$types = PhabricatorPHIDType::getAllTypes();

	$type = idx($types, $this->getApplicationTransactionType());
	if ($type) {
	return $type->getTypeName();
	}

	return pht('Object');
	}

	public function getApplicationTransactionCommentObject() {
	throw new Exception("Not implemented!");
	}

	public function getApplicationTransactionViewObject() {
	return new PhabricatorApplicationTransactionView();
	}

	public function getMetadataValue($key, $default = null) {
	return idx($this->metadata, $key, $default);
	}

	public function setMetadataValue($key, $value) {
	$this->metadata[$key] = $value;
	return $this;
	}

	public function generatePHID() {
	$type = PhabricatorApplicationTransactionPHIDTypeTransaction::TYPECONST;
	$subtype = $this->getApplicationTransactionType();

	return PhabricatorPHID::generateNewPHID($type, $subtype);
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'oldValue' => self::SERIALIZATION_JSON,
	'newValue' => self::SERIALIZATION_JSON,
	'metadata' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

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

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

	public function hasComment() {
	return $this->getComment() && strlen($this->getComment()->getContent());
	}

	public function getComment() {
	if ($this->commentNotLoaded) {
	throw new Exception("Comment for this transaction was not loaded.");
	}
	return $this->comment;
	}

	public function attachComment(
	PhabricatorApplicationTransactionComment $comment) {
	$this->comment = $comment;
	$this->commentNotLoaded = false;
	return $this;
	}

	public function setCommentNotLoaded($not_loaded) {
	$this->commentNotLoaded = $not_loaded;
	return $this;
	}

	/* -( Rendering )---------------------------------------------------------- */

	public function setRenderingTarget($rendering_target) {
	$this->renderingTarget = $rendering_target;
	return $this;
	}

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

	public function attachViewer(PhabricatorUser $viewer) {
	$this->viewer = $viewer;
	return $this;
	}

	public function getViewer() {
	return $this->assertAttached($this->viewer);
	}

	public function getRequiredHandlePHIDs() {
	$phids = array();

	$old = $this->getOldValue();
	$new = $this->getNewValue();

	$phids[] = array($this->getAuthorPHID());
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	$phids[] = $old;
	$phids[] = $new;
	break;
	case PhabricatorTransactions::TYPE_EDGE:
	$phids[] = ipull($old, 'dst');
	$phids[] = ipull($new, 'dst');
	break;
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	if (!PhabricatorPolicyQuery::isGlobalPolicy($old)) {
	$phids[] = array($old);
	}
	if (!PhabricatorPolicyQuery::isGlobalPolicy($new)) {
	$phids[] = array($new);
	}
	break;
	}

	return array_mergev($phids);
	}

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

	public function getHandle($phid) {
	if (empty($this->handles[$phid])) {
	throw new Exception(
	"Transaction requires a handle ('{$phid}') it did not load.");
	}
	return $this->handles[$phid];
	}

	public function getHandleIfExists($phid) {
	return idx($this->handles, $phid);
	}

	public function getHandles() {
	if ($this->handles === null) {
	throw new Exception(
	'Transaction requires handles and it did not load them.'
	);
	}
	return $this->handles;
	}

	public function renderHandleLink($phid) {
	if ($this->renderingTarget == self::TARGET_HTML) {
	return $this->getHandle($phid)->renderLink();
	} else {
	return hsprintf('%s', $this->getHandle($phid)->getName());
	}
	}

	public function renderHandleList(array $phids) {
	$links = array();
	foreach ($phids as $phid) {
	$links[] = $this->renderHandleLink($phid);
	}
	return phutil_implode_html(', ', $links);
	}

	public function getIcon() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return 'comment';
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return 'message';
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return 'lock';
	case PhabricatorTransactions::TYPE_EDGE:
	return 'link';
	}

	return null;
	}

	public function getColor() {
	return null;
	}

	public function shouldHide() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	if ($this->getOldValue() === null) {
	return true;
	} else {
	return false;
	}
	break;
	}

	return false;
	}

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

	public function getNoEffectDescription() {

	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return pht('You can not post an empty comment.');
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	return pht(
	'This %s already has that view policy.',
	$this->getApplicationObjectTypeName());
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return pht(
	'This %s already has that edit policy.',
	$this->getApplicationObjectTypeName());
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return pht(
	'All users are already subscribed to this %s.',
	$this->getApplicationObjectTypeName());
	case PhabricatorTransactions::TYPE_EDGE:
	return pht('Edges already exist; transaction has no effect.');
	}

	return pht('Transaction has no effect.');
	}

	public function getTitle() {
	$author_phid = $this->getAuthorPHID();

	$old = $this->getOldValue();
	$new = $this->getNewValue();

	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return pht(
	'%s added a comment.',
	$this->renderHandleLink($author_phid));
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	return pht(
	'%s changed the visibility of this %s from "%s" to "%s".',
	$this->renderHandleLink($author_phid),
	$this->getApplicationObjectTypeName(),
	PhabricatorPolicy::newFromPolicyAndHandle(
	$old,
	$this->getHandleIfExists($old))->renderDescription(),
	PhabricatorPolicy::newFromPolicyAndHandle(
	$new,
	$this->getHandleIfExists($new))->renderDescription());
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return pht(
	'%s changed the edit policy of this %s from "%s" to "%s".',
	$this->renderHandleLink($author_phid),
	$this->getApplicationObjectTypeName(),
	PhabricatorPolicy::newFromPolicyAndHandle(
	$old,
	$this->getHandleIfExists($old))->renderDescription(),
	PhabricatorPolicy::newFromPolicyAndHandle(
	$new,
	$this->getHandleIfExists($new))->renderDescription());
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	$add = array_diff($new, $old);
	$rem = array_diff($old, $new);

	if ($add && $rem) {
	return pht(
	'%s edited subscriber(s), added %d: %s; removed %d: %s.',
	$this->renderHandleLink($author_phid),
	count($add),
	$this->renderHandleList($add),
	count($rem),
	$this->renderHandleList($rem));
	} else if ($add) {
	return pht(
	'%s added %d subscriber(s): %s.',
	$this->renderHandleLink($author_phid),
	count($add),
	$this->renderHandleList($add));
	} else if ($rem) {
	return pht(
	'%s removed %d subscriber(s): %s.',
	$this->renderHandleLink($author_phid),
	count($rem),
	$this->renderHandleList($rem));
	} else {
	// This is used when rendering previews, before the user actually
	// selects any CCs.
	return pht(
	'%s updated subscribers...',
	$this->renderHandleLink($author_phid));
	}
	break;
	case PhabricatorTransactions::TYPE_EDGE:
	$new = ipull($new, 'dst');
	$old = ipull($old, 'dst');
	$add = array_diff($new, $old);
	$rem = array_diff($old, $new);
	$type = $this->getMetadata('edge:type');
	$type = head($type);

	if ($add && $rem) {
	$string = PhabricatorEdgeConfig::getEditStringForEdgeType($type);
	return pht(
	$string,
	$this->renderHandleLink($author_phid),
	count($add),
	$this->renderHandleList($add),
	count($rem),
	$this->renderHandleList($rem));
	} else if ($add) {
	$string = PhabricatorEdgeConfig::getAddStringForEdgeType($type);
	return pht(
	$string,
	$this->renderHandleLink($author_phid),
	count($add),
	$this->renderHandleList($add));
	} else {
	$string = PhabricatorEdgeConfig::getRemoveStringForEdgeType($type);
	return pht(
	$string,
	$this->renderHandleLink($author_phid),
	count($rem),
	$this->renderHandleList($rem));
	}

	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$key = $this->getMetadataValue('customfield:key');
	$field = PhabricatorCustomField::getObjectField(
	// TODO: This is a giant hack, but we currently don't have a way to
	// get the contextual object and this pathway is only hit by
	// Maniphest. We should provide a way to get the actual object here.
	new ManiphestTask(),
	PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS,
	$key);
	if ($field) {
	$field->setViewer($this->getViewer());
	return $field->getApplicationTransactionTitle($this);
	} else {
	return pht(
	'%s edited a custom field.',
	$this->renderHandleLink($author_phid));
	}

	default:
	return pht(
	'%s edited this %s.',
	$this->renderHandleLink($author_phid),
	$this->getApplicationObjectTypeName());
	}
	}

	public function getTitleForFeed(PhabricatorFeedStory $story) {
	$author_phid = $this->getAuthorPHID();
	$object_phid = $this->getObjectPHID();

	$old = $this->getOldValue();
	$new = $this->getNewValue();

	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return pht(
	'%s added a comment to %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	return pht(
	'%s changed the visibility for %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return pht(
	'%s changed the edit policy for %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return pht(
	'%s updated subscribers of %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	case PhabricatorTransactions::TYPE_EDGE:
	$type = $this->getMetadata('edge:type');
	$type = head($type);
	$string = PhabricatorEdgeConfig::getFeedStringForEdgeType($type);
	return pht(
	$string,
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	+ case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	+ $key = $this->getMetadataValue('customfield:key');
	+ $field = PhabricatorCustomField::getObjectField(
	+ // TODO: This is a giant hack, but we currently don't have a way to
	+ // get the contextual object and this pathway is only hit by
	+ // Maniphest. We should provide a way to get the actual object here.
	+ new ManiphestTask(),
	+ PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS,
	+ $key);
	+ if ($field) {
	+ $field->setViewer($this->getViewer());
	+ return $field->getApplicationTransactionTitleForFeed($this, $story);
	+ } else {
	+ return pht(
	+ '%s edited a custom field on %s.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ }
	+
	}

	return $this->getTitle();
	}

	public function getBodyForFeed(PhabricatorFeedStory $story) {
	$old = $this->getOldValue();
	$new = $this->getNewValue();

	$body = null;

	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	$text = $this->getComment()->getContent();
	$body = phutil_escape_html_newlines(
	phutil_utf8_shorten($text, 128));
	break;
	}
	return $body;
	}

	public function getActionStrength() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return 0.5;
	}
	return 1.0;
	}

	public function getActionName() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return pht('Commented On');
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return pht('Changed Policy');
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return pht('Changed Subscribers');
	default:
	return pht('Updated');
	}
	}

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

	public function hasChangeDetails() {
	return false;
	}

	public function renderChangeDetails(PhabricatorUser $viewer) {
	return null;
	}

	public function attachTransactionGroup(array $group) {
	assert_instances_of($group, 'PhabricatorApplicationTransaction');
	$this->transactionGroup = $group;
	return $this;
	}

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


	/* -( PhabricatorPolicyInterface Implementation )-------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return ($viewer->getPHID() == $this->getAuthorPHID());
	}

	}
	diff --git a/src/infrastructure/customfield/field/PhabricatorCustomField.php b/src/infrastructure/customfield/field/PhabricatorCustomField.php
	index ed594ec02e..f4b6ac2b10 100644
	--- a/src/infrastructure/customfield/field/PhabricatorCustomField.php
	+++ b/src/infrastructure/customfield/field/PhabricatorCustomField.php
	@@ -1,998 +1,1015 @@
	<?php

	/**
	* @task apps Building Applications with Custom Fields
	* @task core Core Properties and Field Identity
	* @task proxy Field Proxies
	* @task context Contextual Data
	* @task storage Field Storage
	* @task appsearch Integration with ApplicationSearch
	* @task appxaction Integration with ApplicationTransactions
	* @task edit Integration with edit views
	* @task view Integration with property views
	* @task list Integration with list views
	*/
	abstract class PhabricatorCustomField {

	private $viewer;
	private $object;
	private $proxy;

	const ROLE_APPLICATIONTRANSACTIONS = 'ApplicationTransactions';
	const ROLE_APPLICATIONSEARCH = 'ApplicationSearch';
	const ROLE_STORAGE = 'storage';
	const ROLE_DEFAULT = 'default';
	const ROLE_EDIT = 'edit';
	const ROLE_VIEW = 'view';
	const ROLE_LIST = 'list';


	/* -( Building Applications with Custom Fields )--------------------------- */


	/**
	* @task apps
	*/
	public static function getObjectFields(
	PhabricatorCustomFieldInterface $object,
	$role) {

	try {
	$attachment = $object->getCustomFields();
	} catch (PhabricatorDataNotAttachedException $ex) {
	$attachment = new PhabricatorCustomFieldAttachment();
	$object->attachCustomFields($attachment);
	}

	try {
	$field_list = $attachment->getCustomFieldList($role);
	} catch (PhabricatorCustomFieldNotAttachedException $ex) {
	$base_class = $object->getCustomFieldBaseClass();

	$spec = $object->getCustomFieldSpecificationForRole($role);
	if (!is_array($spec)) {
	$obj_class = get_class($object);
	throw new Exception(
	"Expected an array from getCustomFieldSpecificationForRole() for ".
	"object of class '{$obj_class}'.");
	}

	$fields = PhabricatorCustomField::buildFieldList($base_class, $spec);

	foreach ($fields as $key => $field) {
	if (!$field->shouldEnableForRole($role)) {
	unset($fields[$key]);
	}
	}

	foreach ($fields as $field) {
	$field->setObject($object);
	}

	$field_list = new PhabricatorCustomFieldList($fields);
	$attachment->addCustomFieldList($role, $field_list);
	}

	return $field_list;
	}


	/**
	* @task apps
	*/
	public static function getObjectField(
	PhabricatorCustomFieldInterface $object,
	$role,
	$field_key) {

	$fields = self::getObjectFields($object, $role)->getFields();

	return idx($fields, $field_key);
	}


	/**
	* @task apps
	*/
	public static function buildFieldList($base_class, array $spec) {
	$field_objects = id(new PhutilSymbolLoader())
	->setAncestorClass($base_class)
	->loadObjects();

	$fields = array();
	$from_map = array();
	foreach ($field_objects as $field_object) {
	$current_class = get_class($field_object);
	foreach ($field_object->createFields() as $field) {
	$key = $field->getFieldKey();
	if (isset($fields[$key])) {
	$original_class = $from_map[$key];
	throw new Exception(
	"Both '{$original_class}' and '{$current_class}' define a custom ".
	"field with field key '{$key}'. Field keys must be unique.");
	}
	$from_map[$key] = $current_class;
	$fields[$key] = $field;
	}
	}

	foreach ($fields as $key => $field) {
	if (!$field->isFieldEnabled()) {
	unset($fields[$key]);
	}
	}

	$fields = array_select_keys($fields, array_keys($spec)) + $fields;

	foreach ($spec as $key => $config) {
	if (empty($fields[$key])) {
	continue;
	}
	if (!empty($config['disabled'])) {
	if ($fields[$key]->canDisableField()) {
	unset($fields[$key]);
	}
	}
	}

	return $fields;
	}


	/* -( Core Properties and Field Identity )--------------------------------- */


	/**
	* Return a key which uniquely identifies this field, like
	* "mycompany:dinosaur:count". Normally you should provide some level of
	* namespacing to prevent collisions.
	*
	* @return string String which uniquely identifies this field.
	* @task core
	*/
	public function getFieldKey() {
	if ($this->proxy) {
	return $this->proxy->getFieldKey();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException(
	$this,
	$field_key_is_incomplete = true);
	}


	/**
	* Return a human-readable field name.
	*
	* @return string Human readable field name.
	* @task core
	*/
	public function getFieldName() {
	if ($this->proxy) {
	return $this->proxy->getFieldName();
	}
	return $this->getFieldKey();
	}


	/**
	* Return a short, human-readable description of the field's behavior. This
	* provides more context to administrators when they are customizing fields.
	*
	* @return string\|null Optional human-readable description.
	* @task core
	*/
	public function getFieldDescription() {
	if ($this->proxy) {
	return $this->proxy->getFieldDescription();
	}
	return null;
	}


	/**
	* Most field implementations are unique, in that one class corresponds to
	* one field. However, some field implementations are general and a single
	* implementation may drive several fields.
	*
	* For general implementations, the general field implementation can return
	* multiple field instances here.
	*
	* @return list<PhabricatorCustomField> List of fields.
	* @task core
	*/
	public function createFields() {
	return array($this);
	}


	/**
	* You can return `false` here if the field should not be enabled for any
	* role. For example, it might depend on something (like an application or
	* library) which isn't installed, or might have some global configuration
	* which allows it to be disabled.
	*
	* @return bool False to completely disable this field for all roles.
	* @task core
	*/
	public function isFieldEnabled() {
	if ($this->proxy) {
	return $this->proxy->isFieldEnabled();
	}
	return true;
	}


	/**
	* Low level selector for field availability. Fields can appear in different
	* roles (like an edit view, a list view, etc.), but not every field needs
	* to appear everywhere. Fields that are disabled in a role won't appear in
	* that context within applications.
	*
	* Normally, you do not need to override this method. Instead, override the
	* methods specific to roles you want to enable. For example, implement
	* @{method:shouldUseStorage()} to activate the `'storage'` role.
	*
	* @return bool True to enable the field for the given role.
	* @task core
	*/
	public function shouldEnableForRole($role) {
	if ($this->proxy) {
	return $this->proxy->shouldEnableForRole($role);
	}

	switch ($role) {
	case self::ROLE_APPLICATIONTRANSACTIONS:
	return $this->shouldAppearInApplicationTransactions();
	case self::ROLE_APPLICATIONSEARCH:
	return $this->shouldAppearInApplicationSearch();
	case self::ROLE_STORAGE:
	return $this->shouldUseStorage();
	case self::ROLE_EDIT:
	return $this->shouldAppearInEditView();
	case self::ROLE_VIEW:
	return $this->shouldAppearInPropertyView();
	case self::ROLE_LIST:
	return $this->shouldAppearInListView();
	case self::ROLE_DEFAULT:
	return true;
	default:
	throw new Exception("Unknown field role '{$role}'!");
	}
	}


	/**
	* Allow administrators to disable this field. Most fields should allow this,
	* but some are fundamental to the behavior of the application and can be
	* locked down to avoid chaos, disorder, and the decline of civilization.
	*
	* @return bool False to prevent this field from being disabled through
	* configuration.
	* @task core
	*/
	public function canDisableField() {
	return true;
	}


	/**
	* Return an index string which uniquely identifies this field.
	*
	* @return string Index string which uniquely identifies this field.
	* @task core
	*/
	final public function getFieldIndex() {
	return PhabricatorHash::digestForIndex($this->getFieldKey());
	}


	/* -( Field Proxies )------------------------------------------------------ */


	/**
	* Proxies allow a field to use some other field's implementation for most
	* of their behavior while still subclassing an application field. When a
	* proxy is set for a field with @{method:setProxy}, all of its methods will
	* call through to the proxy by default.
	*
	* This is most commonly used to implement configuration-driven custom fields
	* using @{class:PhabricatorStandardCustomField}.
	*
	* This method must be overridden to return `true` before a field can accept
	* proxies.
	*
	* @return bool True if you can @{method:setProxy} this field.
	* @task proxy
	*/
	public function canSetProxy() {
	if ($this instanceof PhabricatorStandardCustomFieldInterface) {
	return true;
	}
	return false;
	}


	/**
	* Set the proxy implementation for this field. See @{method:canSetProxy} for
	* discussion of field proxies.
	*
	* @param PhabricatorCustomField Field implementation.
	* @return this
	*/
	final public function setProxy(PhabricatorCustomField $proxy) {
	if (!$this->canSetProxy()) {
	throw new PhabricatorCustomFieldNotProxyException($this);
	}

	$this->proxy = $proxy;
	return $this;
	}


	/**
	* Get the field's proxy implementation, if any. For discussion, see
	* @{method:canSetProxy}.
	*
	* @return PhabricatorCustomField\|null Proxy field, if one is set.
	*/
	final public function getProxy() {
	return $this->proxy;
	}


	/* -( Contextual Data )---------------------------------------------------- */


	/**
	* Sets the object this field belongs to.
	*
	* @param PhabricatorCustomFieldInterface The object this field belongs to.
	* @task context
	*/
	final public function setObject(PhabricatorCustomFieldInterface $object) {
	if ($this->proxy) {
	$this->proxy->setObject($object);
	return $this;
	}

	$this->object = $object;
	$this->didSetObject($object);
	return $this;
	}


	/**
	* Get the object this field belongs to.
	*
	* @return PhabricatorCustomFieldInterface The object this field belongs to.
	* @task context
	*/
	final public function getObject() {
	if ($this->proxy) {
	return $this->proxy->getObject();
	}

	return $this->object;
	}


	/**
	* This is a hook, primarily for subclasses to load object data.
	*
	* @return PhabricatorCustomFieldInterface The object this field belongs to.
	* @return void
	*/
	protected function didSetObject(PhabricatorCustomFieldInterface $object) {
	return;
	}


	/**
	* @task context
	*/
	final public function setViewer(PhabricatorUser $viewer) {
	if ($this->proxy) {
	$this->proxy->setViewer($viewer);
	return $this;
	}

	$this->viewer = $viewer;
	return $this;
	}


	/**
	* @task context
	*/
	final public function getViewer() {
	if ($this->proxy) {
	return $this->proxy->getViewer();
	}

	return $this->viewer;
	}


	/**
	* @task context
	*/
	final protected function requireViewer() {
	if ($this->proxy) {
	return $this->proxy->requireViewer();
	}

	if (!$this->viewer) {
	throw new PhabricatorCustomFieldDataNotAvailableException($this);
	}
	return $this->viewer;
	}


	/* -( Storage )------------------------------------------------------------ */


	/**
	* Return true to use field storage.
	*
	* Fields which can be edited by the user will most commonly use storage,
	* while some other types of fields (for instance, those which just display
	* information in some stylized way) may not. Many builtin fields do not use
	* storage because their data is available on the object itself.
	*
	* If you implement this, you must also implement @{method:getValueForStorage}
	* and @{method:setValueFromStorage}.
	*
	* @return bool True to use storage.
	* @task storage
	*/
	public function shouldUseStorage() {
	if ($this->proxy) {
	return $this->proxy->shouldUseStorage();
	}
	return false;
	}


	/**
	* Return a new, empty storage object. This should be a subclass of
	* @{class:PhabricatorCustomFieldStorage} which is bound to the application's
	* database.
	*
	* @return PhabricatorCustomFieldStorage New empty storage object.
	* @task storage
	*/
	public function newStorageObject() {
	if ($this->proxy) {
	return $this->proxy->newStorageObject();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Return a serialized representation of the field value, appropriate for
	* storing in auxiliary field storage. You must implement this method if
	* you implement @{method:shouldUseStorage}.
	*
	* If the field value is a scalar, it can be returned unmodiifed. If not,
	* it should be serialized (for example, using JSON).
	*
	* @return string Serialized field value.
	* @task storage
	*/
	public function getValueForStorage() {
	if ($this->proxy) {
	return $this->proxy->getValueForStorage();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Set the field's value given a serialized storage value. This is called
	* when the field is loaded; if no data is available, the value will be
	* null. You must implement this method if you implement
	* @{method:shouldUseStorage}.
	*
	* Usually, the value can be loaded directly. If it isn't a scalar, you'll
	* need to undo whatever serialization you applied in
	* @{method:getValueForStorage}.
	*
	* @param string\|null Serialized field representation (from
	* @{method:getValueForStorage}) or null if no value has
	* ever been stored.
	* @return this
	* @task storage
	*/
	public function setValueFromStorage($value) {
	if ($this->proxy) {
	return $this->proxy->setValueFromStorage($value);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/* -( ApplicationSearch )-------------------------------------------------- */


	/**
	* Appearing in ApplicationSearch allows a field to be indexed and searched
	* for.
	*
	* @return bool True to appear in ApplicationSearch.
	* @task appsearch
	*/
	public function shouldAppearInApplicationSearch() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInApplicationSearch();
	}
	return false;
	}


	/**
	* Return one or more indexes which this field can meaningfully query against
	* to implement ApplicationSearch.
	*
	* Normally, you should build these using @{method:newStringIndex} and
	* @{method:newNumericIndex}. For example, if a field holds a numeric value
	* it might return a single numeric index:
	*
	* return array($this->newNumericIndex($this->getValue()));
	*
	* If a field holds a more complex value (like a list of users), it might
	* return several string indexes:
	*
	* $indexes = array();
	* foreach ($this->getValue() as $phid) {
	* $indexes[] = $this->newStringIndex($phid);
	* }
	* return $indexes;
	*
	* @return list<PhabricatorCustomFieldIndexStorage> List of indexes.
	* @task appsearch
	*/
	public function buildFieldIndexes() {
	if ($this->proxy) {
	return $this->proxy->buildFieldIndexes();
	}
	return array();
	}


	/**
	* Build a new empty storage object for storing string indexes. Normally,
	* this should be a concrete subclass of
	* @{class:PhabricatorCustomFieldStringIndexStorage}.
	*
	* @return PhabricatorCustomFieldStringIndexStorage Storage object.
	* @task appsearch
	*/
	protected function newStringIndexStorage() {
	// NOTE: This intentionally isn't proxied, to avoid call cycles.
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Build a new empty storage object for storing string indexes. Normally,
	* this should be a concrete subclass of
	* @{class:PhabricatorCustomFieldStringIndexStorage}.
	*
	* @return PhabricatorCustomFieldStringIndexStorage Storage object.
	* @task appsearch
	*/
	protected function newNumericIndexStorage() {
	// NOTE: This intentionally isn't proxied, to avoid call cycles.
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Build and populate storage for a string index.
	*
	* @param string String to index.
	* @return PhabricatorCustomFieldStringIndexStorage Populated storage.
	* @task appsearch
	*/
	protected function newStringIndex($value) {
	if ($this->proxy) {
	return $this->proxy->newStringIndex();
	}

	$key = $this->getFieldIndex();
	return $this->newStringIndexStorage()
	->setIndexKey($key)
	->setIndexValue($value);
	}


	/**
	* Build and populate storage for a numeric index.
	*
	* @param string Numeric value to index.
	* @return PhabricatorCustomFieldNumericIndexStorage Populated storage.
	* @task appsearch
	*/
	protected function newNumericIndex($value) {
	if ($this->proxy) {
	return $this->proxy->newNumericIndex();
	}
	$key = $this->getFieldIndex();
	return $this->newNumericIndexStorage()
	->setIndexKey($key)
	->setIndexValue($value);
	}


	/**
	* Read a query value from a request, for storage in a saved query. Normally,
	* this method should, e.g., read a string out of the request.
	*
	* @param PhabricatorApplicationSearchEngine Engine building the query.
	* @param AphrontRequest Request to read from.
	* @return wild
	* @task appsearch
	*/
	public function readApplicationSearchValueFromRequest(
	PhabricatorApplicationSearchEngine $engine,
	AphrontRequest $request) {
	if ($this->proxy) {
	return $this->proxy->readApplicationSearchValueFromRequest(
	$engine,
	$request);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Constrain a query, given a field value. Generally, this method should
	* use `with...()` methods to apply filters or other constraints to the
	* query.
	*
	* @param PhabricatorApplicationSearchEngine Engine executing the query.
	* @param PhabricatorCursorPagedPolicyAwareQuery Query to constrain.
	* @param wild Constraint provided by the user.
	* @return void
	* @task appsearch
	*/
	public function applyApplicationSearchConstraintToQuery(
	PhabricatorApplicationSearchEngine $engine,
	PhabricatorCursorPagedPolicyAwareQuery $query,
	$value) {
	if ($this->proxy) {
	return $this->proxy->applyApplicationSearchConstraintToQuery(
	$engine,
	$query,
	$value);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Append search controls to the interface. If you need handles, use
	* @{method:getRequiredHandlePHIDsForApplicationSearch} to get them.
	*
	* @param PhabricatorApplicationSearchEngine Engine constructing the form.
	* @param AphrontFormView The form to update.
	* @param wild Value from the saved query.
	* @param list<PhabricatorObjectHandle> List of handles.
	* @return void
	* @task appsearch
	*/
	public function appendToApplicationSearchForm(
	PhabricatorApplicationSearchEngine $engine,
	AphrontFormView $form,
	$value,
	array $handles) {
	if ($this->proxy) {
	return $this->proxy->appendToApplicationSearchForm(
	$engine,
	$form,
	$value,
	$handles);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Return a list of PHIDs which @{method:appendToApplicationSearchForm} needs
	* handles for. This is primarily useful if the field stores PHIDs and you
	* need to (for example) render a tokenizer control.
	*
	* @param wild Value from the saved query.
	* @return list<phid> List of PHIDs.
	* @task appsearch
	*/
	public function getRequiredHandlePHIDsForApplicationSearch($value) {
	if ($this->proxy) {
	return $this->proxy->getRequiredHandlePHIDsForApplicationSearch($value);
	}
	return array();
	}


	/* -( ApplicationTransactions )-------------------------------------------- */


	/**
	* Appearing in ApplicationTrasactions allows a field to be edited using
	* standard workflows.
	*
	* @return bool True to appear in ApplicationTransactions.
	* @task appxaction
	*/
	public function shouldAppearInApplicationTransactions() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInApplicationTransactions();
	}
	return false;
	}


	/**
	* @task appxaction
	*/
	public function getOldValueForApplicationTransactions() {
	if ($this->proxy) {
	return $this->proxy->getOldValueForApplicationTransactions();
	}
	return $this->getValueForStorage();
	}


	/**
	* @task appxaction
	*/
	public function getNewValueForApplicationTransactions() {
	if ($this->proxy) {
	return $this->proxy->getNewValueForApplicationTransactions();
	}
	return $this->getValueForStorage();
	}


	/**
	* @task appxaction
	*/
	public function setValueFromApplicationTransactions($value) {
	if ($this->proxy) {
	return $this->proxy->setValueFromApplicationTransactions($value);
	}
	return $this->setValueFromStorage($value);
	}


	/**
	* @task appxaction
	*/
	public function getNewValueFromApplicationTransactions(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getNewValueFromApplicationTransactions($xaction);
	}
	return $xaction->getNewValue();
	}


	/**
	* @task appxaction
	*/
	public function getApplicationTransactionHasEffect(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionHasEffect($xaction);
	}
	return ($xaction->getOldValue() !== $xaction->getNewValue());
	}


	/**
	* @task appxaction
	*/
	public function applyApplicationTransactionInternalEffects(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->applyApplicationTransactionInternalEffects($xaction);
	}
	return;
	}


	/**
	* @task appxaction
	*/
	public function applyApplicationTransactionExternalEffects(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->applyApplicationTransactionExternalEffects($xaction);
	}

	if (!$this->shouldEnableForRole(self::ROLE_STORAGE)) {
	return;
	}

	$this->setValueFromApplicationTransactions($xaction->getNewValue());
	$value = $this->getValueForStorage();

	$table = $this->newStorageObject();
	$conn_w = $table->establishConnection('w');

	if ($value === null) {
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE objectPHID = %s AND fieldIndex = %s',
	$table->getTableName(),
	$this->getObject()->getPHID(),
	$this->getFieldIndex());
	} else {
	queryfx(
	$conn_w,
	'INSERT INTO %T (objectPHID, fieldIndex, fieldValue)
	VALUES (%s, %s, %s)
	ON DUPLICATE KEY UPDATE fieldValue = VALUES(fieldValue)',
	$table->getTableName(),
	$this->getObject()->getPHID(),
	$this->getFieldIndex(),
	$value);
	}

	return;
	}


	/**
	* Validate transactions for an object. This allows you to raise an error
	* when a transaction would set a field to an invalid value, or when a field
	* is required but no transactions provide value.
	*
	* @param PhabricatorLiskDAO Editor applying the transactions.
	* @param string Transaction type. This type is always
	* `PhabricatorTransactions::TYPE_CUSTOMFIELD`, it is provided for
	* convenience when constructing exceptions.
	* @param list<PhabricatorApplicationTransaction> Transactions being applied,
	* which may be empty if this field is not being edited.
	* @return list<PhabricatorApplicationTransactionValidationError> Validation
	* errors.
	*
	* @task appxaction
	*/
	public function validateApplicationTransactions(
	PhabricatorApplicationTransactionEditor $editor,
	$type,
	array $xactions) {
	if ($this->proxy) {
	return $this->proxy->validateApplicationTransactions(
	$editor,
	$type,
	$xactions);
	}
	return array();
	}

	public function getApplicationTransactionTitle(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionTitle(
	$xaction);
	}

	$author_phid = $xaction->getAuthorPHID();
	return pht(
	'%s updated this object.',
	$xaction->renderHandleLink($author_phid));
	}

	+ public function getApplicationTransactionTitleForFeed(
	+ PhabricatorApplicationTransaction $xaction,
	+ PhabricatorFeedStory $story) {
	+ if ($this->proxy) {
	+ return $this->proxy->getApplicationTransactionTitleForFeed(
	+ $xaction,
	+ $story);
	+ }
	+
	+ $author_phid = $xaction->getAuthorPHID();
	+ $object_phid = $xaction->getObjectPHID();
	+ return pht(
	+ '%s updated %s.',
	+ $xaction->renderHandleLink($author_phid),
	+ $xaction->renderHandleLink($object_phid));
	+ }
	+

	/* -( Edit View )---------------------------------------------------------- */


	/**
	* @task edit
	*/
	public function shouldAppearInEditView() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInEditView();
	}
	return false;
	}


	/**
	* @task edit
	*/
	public function readValueFromRequest(AphrontRequest $request) {
	if ($this->proxy) {
	return $this->proxy->readValueFromRequest($request);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* @task edit
	*/
	public function renderEditControl() {
	if ($this->proxy) {
	return $this->proxy->renderEditControl();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/* -( Property View )------------------------------------------------------ */


	/**
	* @task view
	*/
	public function shouldAppearInPropertyView() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInPropertyView();
	}
	return false;
	}


	/**
	* @task view
	*/
	public function renderPropertyViewLabel() {
	if ($this->proxy) {
	return $this->proxy->renderPropertyViewLabel();
	}
	return $this->getFieldName();
	}


	/**
	* @task view
	*/
	public function renderPropertyViewValue() {
	if ($this->proxy) {
	return $this->proxy->renderPropertyViewValue();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* @task view
	*/
	public function getStyleForPropertyView() {
	if ($this->proxy) {
	return $this->proxy->getStyleForPropertyView();
	}
	return 'property';
	}


	/* -( List View )---------------------------------------------------------- */


	/**
	* @task list
	*/
	public function shouldAppearInListView() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInListView();
	}
	return false;
	}


	/**
	* @task list
	*/
	public function renderOnListItem(PHUIObjectItemView $view) {
	if ($this->proxy) {
	return $this->proxy->renderOnListItem($view);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	}
	diff --git a/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php b/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
	index a4691fd492..947a7ca7ae 100644
	--- a/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
	+++ b/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
	@@ -1,337 +1,371 @@
	<?php

	abstract class PhabricatorStandardCustomField
	extends PhabricatorCustomField {

	private $fieldKey;
	private $fieldName;
	private $fieldValue;
	private $fieldDescription;
	private $fieldConfig;
	private $applicationField;
	private $strings = array();
	private $caption;
	private $fieldError;
	private $required;
	private $default;

	abstract public function getFieldType();

	public static function buildStandardFields(
	PhabricatorCustomField $template,
	array $config) {

	$types = id(new PhutilSymbolLoader())
	->setAncestorClass(__CLASS__)
	->loadObjects();
	$types = mpull($types, null, 'getFieldType');

	$fields = array();
	foreach ($config as $key => $value) {
	$type = idx($value, 'type', 'text');
	if (empty($types[$type])) {
	// TODO: We should have better typechecking somewhere, and then make
	// this more serious.
	continue;
	}

	$namespace = $template->getStandardCustomFieldNamespace();
	$full_key = "std:{$namespace}:{$key}";

	$template = clone $template;
	$standard = id(clone $types[$type])
	->setFieldKey($full_key)
	->setFieldConfig($value)
	->setApplicationField($template);

	$field = $template->setProxy($standard);
	$fields[] = $field;
	}

	return $fields;
	}

	public function setApplicationField(
	PhabricatorStandardCustomFieldInterface $application_field) {
	$this->applicationField = $application_field;
	return $this;
	}

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

	public function setFieldName($name) {
	$this->fieldName = $name;
	return $this;
	}

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

	public function setFieldValue($value) {
	$this->fieldValue = $value;
	return $this;
	}

	public function setCaption($caption) {
	$this->caption = $caption;
	return $this;
	}

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

	public function setFieldDescription($description) {
	$this->fieldDescription = $description;
	return $this;
	}

	public function setFieldConfig(array $config) {
	foreach ($config as $key => $value) {
	switch ($key) {
	case 'name':
	$this->setFieldName($value);
	break;
	case 'description':
	$this->setFieldDescription($value);
	break;
	case 'strings':
	$this->setStrings($value);
	break;
	case 'caption':
	$this->setCaption($value);
	break;
	case 'required':
	$this->setRequired($value);
	$this->setFieldError(true);
	break;
	case 'default':
	$this->setFieldValue($value);
	break;
	case 'type':
	// We set this earlier on.
	break;
	}
	}
	$this->fieldConfig = $config;
	return $this;
	}

	public function getFieldConfigValue($key, $default = null) {
	return idx($this->fieldConfig, $key, $default);
	}

	public function setFieldError($field_error) {
	$this->fieldError = $field_error;
	return $this;
	}

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

	public function setRequired($required) {
	$this->required = $required;
	return $this;
	}

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


	/* -( PhabricatorCustomField )--------------------------------------------- */


	public function setFieldKey($field_key) {
	$this->fieldKey = $field_key;
	return $this;
	}

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

	public function getFieldName() {
	return coalesce($this->fieldName, parent::getFieldName());
	}

	public function getFieldDescription() {
	return coalesce($this->fieldDescription, parent::getFieldDescription());
	}

	public function setStrings(array $strings) {
	$this->strings = $strings;
	return;
	}

	public function getString($key, $default = null) {
	return idx($this->strings, $key, $default);
	}

	public function shouldUseStorage() {
	return true;
	}

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

	public function setValueFromStorage($value) {
	return $this->setFieldValue($value);
	}

	public function shouldAppearInApplicationTransactions() {
	return true;
	}

	public function shouldAppearInEditView() {
	return $this->getFieldConfigValue('edit', true);
	}

	public function readValueFromRequest(AphrontRequest $request) {
	$value = $request->getStr($this->getFieldKey());
	if (!strlen($value)) {
	$value = null;
	}
	$this->setFieldValue($value);
	}

	public function renderEditControl() {
	return id(new AphrontFormTextControl())
	->setName($this->getFieldKey())
	->setCaption($this->getCaption())
	->setValue($this->getFieldValue())
	->setError($this->getFieldError())
	->setLabel($this->getFieldName());
	}

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

	public function shouldAppearInPropertyView() {
	return $this->getFieldConfigValue('view', true);
	}

	public function renderPropertyViewValue() {
	if (!strlen($this->getFieldValue())) {
	return null;
	}
	return $this->getFieldValue();
	}

	public function shouldAppearInApplicationSearch() {
	return $this->getFieldConfigValue('search', false);
	}

	protected function newStringIndexStorage() {
	return $this->getApplicationField()->newStringIndexStorage();
	}

	protected function newNumericIndexStorage() {
	return $this->getApplicationField()->newNumericIndexStorage();
	}

	public function buildFieldIndexes() {
	return array();
	}

	public function readApplicationSearchValueFromRequest(
	PhabricatorApplicationSearchEngine $engine,
	AphrontRequest $request) {
	return;
	}

	public function applyApplicationSearchConstraintToQuery(
	PhabricatorApplicationSearchEngine $engine,
	PhabricatorCursorPagedPolicyAwareQuery $query,
	$value) {
	return;
	}

	public function appendToApplicationSearchForm(
	PhabricatorApplicationSearchEngine $engine,
	AphrontFormView $form,
	$value,
	array $handles) {
	return;
	}

	public function validateApplicationTransactions(
	PhabricatorApplicationTransactionEditor $editor,
	$type,
	array $xactions) {

	$this->setFieldError(null);

	$errors = parent::validateApplicationTransactions(
	$editor,
	$type,
	$xactions);

	if ($this->getRequired()) {
	$value = $this->getOldValueForApplicationTransactions();

	$transaction = null;
	foreach ($xactions as $xaction) {
	$value = $xaction->getNewValue();
	if (!$this->isValueEmpty($value)) {
	$transaction = $xaction;
	break;
	}
	}
	if ($this->isValueEmpty($value)) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Required'),
	pht('%s is required.', $this->getFieldName()),
	$transaction);
	$error->setIsMissingFieldError(true);
	$errors[] = $error;
	$this->setFieldError(pht('Required'));
	}
	}

	return $errors;
	}

	protected function isValueEmpty($value) {
	if (is_array($value)) {
	return empty($value);
	}
	return !strlen($value);
	}

	public function getApplicationTransactionTitle(
	PhabricatorApplicationTransaction $xaction) {
	$author_phid = $xaction->getAuthorPHID();
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	if (!$old) {
	return pht(
	'%s set %s to %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName(),
	$new);
	} else if (!$new) {
	return pht(
	'%s removed %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName());
	} else {
	return pht(
	'%s changed %s from %s to %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName(),
	$old,
	$new);
	}
	}

	+ public function getApplicationTransactionTitleForFeed(
	+ PhabricatorApplicationTransaction $xaction,
	+ PhabricatorFeedStory $story) {
	+
	+ $author_phid = $xaction->getAuthorPHID();
	+ $object_phid = $xaction->getObjectPHID();
	+
	+ $old = $xaction->getOldValue();
	+ $new = $xaction->getNewValue();
	+
	+ if (!$old) {
	+ return pht(
	+ '%s set %s to %s on %s.',
	+ $xaction->renderHandleLink($author_phid),
	+ $this->getFieldName(),
	+ $new,
	+ $xaction->renderHandleLink($object_phid));
	+ } else if (!$new) {
	+ return pht(
	+ '%s removed %s on %s.',
	+ $xaction->renderHandleLink($author_phid),
	+ $this->getFieldName(),
	+ $xaction->renderHandleLink($object_phid));
	+ } else {
	+ return pht(
	+ '%s changed %s from %s to %s on %s.',
	+ $xaction->renderHandleLink($author_phid),
	+ $this->getFieldName(),
	+ $old,
	+ $new,
	+ $xaction->renderHandleLink($object_phid));
	+ }
	+ }
	+

	}
	diff --git a/src/infrastructure/internationalization/PhabricatorBaseEnglishTranslation.php b/src/infrastructure/internationalization/PhabricatorBaseEnglishTranslation.php
	index 509fe3c959..749c159626 100644
	--- a/src/infrastructure/internationalization/PhabricatorBaseEnglishTranslation.php
	+++ b/src/infrastructure/internationalization/PhabricatorBaseEnglishTranslation.php
	@@ -1,751 +1,782 @@
	<?php

	abstract class PhabricatorBaseEnglishTranslation
	extends PhabricatorTranslation {

	final public function getLanguage() {
	return 'en';
	}

	public function getTranslations() {
	return array(
	'These %d configuration value(s) are related:' => array(
	'This configuration value is related:',
	'These configuration values are related:',
	),
	'Differential Revision(s)' => array(
	'Differential Revision',
	'Differential Revisions',
	),
	'file(s)' => array('file', 'files'),
	'Maniphest Task(s)' => array('Maniphest Task', 'Maniphest Tasks'),
	'Task(s)' => array('Task', 'Tasks'),

	'Please fix these errors and try again.' => array(
	'Please fix this error and try again.',
	'Please fix these errors and try again.',
	),

	'%d Error(s)' => array('%d Error', '%d Errors'),
	'%d Warning(s)' => array('%d Warning', '%d Warnings'),
	'%d Auto-Fix(es)' => array('%d Auto-Fix', '%d Auto-Fixes'),
	'%d Advice(s)' => array('%d Advice', '%d Pieces of Advice'),
	'%d Detail(s)' => array('%d Detail', '%d Details'),

	'(%d line(s))' => array('(%d line)', '(%d lines)'),

	'COMMIT(S)' => array('COMMIT', 'COMMITS'),

	'%d line(s)' => array('%d line', '%d lines'),
	'%d path(s)' => array('%d path', '%d paths'),
	'%d diff(s)' => array('%d diff', '%d diffs'),

	'added %d commit(s): %s' => array(
	'added commit: %2$s',
	'added commits: %2$s',
	),

	'removed %d commit(s): %s' => array(
	'removed commit: %2$s',
	'removed commits: %2$s',
	),

	'changed %d commit(s), added %d: %s; removed %d: %s' =>
	'changed commits, added: %3$s; removed: %5$s',

	'ATTACHED %d COMMIT(S)' => array(
	'ATTACHED COMMIT',
	'ATTACHED COMMITS',
	),

	'added %d mock(s): %s' => array(
	'added a mock: %2$s',
	'added mocks: %2$s',
	),

	'removed %d mock(s): %s' => array(
	'removed a mock: %2$s',
	'removed mocks: %2$s',
	),

	'changed %d mock(s), added %d: %s; removed %d: %s' =>
	'changed mocks, added: %3$s; removed: %5$s',

	'ATTACHED %d MOCK(S)' => array(
	'ATTACHED MOCK',
	'ATTACHED MOCKS',
	),

	'added %d dependencie(s): %s' => array(
	'added dependency: %2$s',
	'added dependencies: %2$s',
	),

	'added %d dependent task(s): %s' => array(
	'added dependent task: %2$s',
	'added dependent tasks: %2$s',
	),

	'removed %d dependencie(s): %s' => array(
	'removed dependency: %2$s',
	'removed dependencies: %2$s',
	),

	'removed %d dependent task(s): %s' => array(
	'removed dependent task: %2$s',
	'removed dependent tasks: %2$s',
	),

	'changed %d dependencie(s), added %d: %s; removed %d: %s' =>
	'changed dependencies, added: %3$s; removed: %5$s',

	'changed %d dependent task(s), added %d: %s; removed %d: %s',
	'changed dependent tasks, added: %3$s; removed: %5$s',

	'DEPENDENT %d TASK(s)' => array(
	'DEPENDENT TASK',
	'DEPENDENT TASKS',
	),

	'DEPENDS ON %d TASK(S)' => array(
	'DEPENDS ON TASK',
	'DEPENDS ON TASKS',
	),

	'DIFFERENTIAL %d REVISION(S)' => array(
	'DIFFERENTIAL REVISION',
	'DIFFERENTIAL REVISIONS',
	),

	'added %d revision(s): %s' => array(
	'added revision: %2$s',
	'added revisions: %2$s',
	),

	'removed %d revision(s): %s' => array(
	'removed revision: %2$s',
	'removed revisions: %2$s',
	),

	'changed %d revision(s), added %d: %s; removed %d: %s' =>
	'changed revisions, added %3$s; removed %5$s',

	'%s edited revision(s), added %d: %s; removed %d: %s.' =>
	'%s edited revisions, added: %3$s; removed: %5$s',

	'There are %d raw fact(s) in storage.' => array(
	'There is %d raw fact in storage.',
	'There are %d raw facts in storage.',
	),

	'There are %d aggregate fact(s) in storage.' => array(
	'There is %d aggregate fact in storage.',
	'There are %d aggregate facts in storage.',
	),

	'%d Commit(s) Awaiting Audit' => array(
	'%d Commit Awaiting Audit',
	'%d Commits Awaiting Audit',
	),

	'%d Problem Commit(s)' => array(
	'%d Problem Commit',
	'%d Problem Commits',
	),

	'%d Review(s) Blocking Others' => array(
	'%d Review Blocking Others',
	'%d Reviews Blocking Others',
	),

	'%d Review(s) Need Attention' => array(
	'%d Review Needs Attention',
	'%d Reviews Need Attention',
	),

	'%d Review(s) Waiting on Others' => array(
	'%d Review Waiting on Others',
	'%d Reviews Waiting on Others',
	),

	'%d Flagged Object(s)' => array(
	'%d Flagged Object',
	'%d Flagged Objects',
	),

	'%d Unbreak Now Task(s)!' => array(
	'%d Unbreak Now Task!',
	'%d Unbreak Now Tasks!',
	),

	'%d Assigned Task(s)' => array(
	'%d Assigned Task',
	'%d Assigned Tasks',
	),

	'Show %d Lint Message(s)' => array(
	'Show %d Lint Message',
	'Show %d Lint Messages',
	),
	'Hide %d Lint Message(s)' => array(
	'Hide %d Lint Message',
	'Hide %d Lint Messages',
	),
	'Switch for %d Lint Message(s)' => array(
	'Switch for %d Lint Message',
	'Switch for %d Lint Messages',
	),
	'%d Lint Message(s)' => array(
	'%d Lint Message',
	'%d Lint Messages',
	),

	'This is a binary file. It is %s byte(s) in length.' => array(
	'This is a binary file. It is %s byte in length.',
	'This is a binary file. It is %s bytes in length.',
	),

	'%d Action(s) Have No Effect' => array(
	'Action Has No Effect',
	'Actions Have No Effect',
	),

	'%d Action(s) With No Effect' => array(
	'Action With No Effect',
	'Actions With No Effect',
	),

	'%s edited post(s), added %d: %s; removed %d: %s.' =>
	'%s edited posts, added: %3$s; removed: %5$s',

	'%s added %d post(s): %s.' => array(
	array(
	'%s added a post: %3$s.',
	'%s added posts: %3$s.',
	),
	),

	'%s removed %d post(s): %s.' => array(
	array(
	'%s removed a post: %3$s.',
	'%s removed posts: %3$s.',
	),
	),

	'%s edited blog(s), added %d: %s; removed %d: %s.' =>
	'%s edited blogs, added: %3$s; removed: %5$s',

	'%s added %d blog(s): %s.' => array(
	array(
	'%s added a blog: %3$s.',
	'%s added blogs: %3$s.',
	),
	),

	'%s removed %d blog(s): %s.' => array(
	array(
	'%s removed a blog: %3$s.',
	'%s removed blogs: %3$s.',
	),
	),

	'%s edited blogger(s), added %d: %s; removed %d: %s.' =>
	'%s edited bloggers, added: %3$s; removed: %5$s',

	'%s added %d blogger(s): %s.' => array(
	array(
	'%s added a blogger: %3$s.',
	'%s added bloggers: %3$s.',
	),
	),

	'%s removed %d blogger(s): %s.' => array(
	array(
	'%s removed a blogger: %3$s.',
	'%s removed bloggers: %3$s.',
	),
	),

	'%s edited member(s), added %d: %s; removed %d: %s.' =>
	'%s edited members, added: %3$s; removed: %5$s',

	'%s added %d member(s): %s.' => array(
	array(
	'%s added a member: %3$s.',
	'%s added members: %3$s.',
	),
	),

	'%s removed %d member(s): %s.' => array(
	array(
	'%s removed a member: %3$s.',
	'%s removed members: %3$s.',
	),
	),

	'%s edited project(s), added %d: %s; removed %d: %s.' =>
	'%s edited projects, added: %3$s; removed: %5$s',

	'%s added %d project(s): %s.' => array(
	array(
	'%s added a project: %3$s.',
	'%s added projects: %3$s.',
	),
	),

	'%s removed %d project(s): %s.' => array(
	array(
	'%s removed a project: %3$s.',
	'%s removed projects: %3$s.',
	),
	),

	'%s edited voting user(s), added %d: %s; removed %d: %s.' =>
	'%s edited voting users, added: %3$s; removed: %5$s',

	'%s added %d voting user(s): %s.' => array(
	array(
	'%s added a voting user: %3$s.',
	'%s added voting users: %3$s.',
	),
	),

	'%s removed %d voting user(s): %s.' => array(
	array(
	'%s removed a voting user: %3$s.',
	'%s removed voting users: %3$s.',
	),
	),

	'%s edited answer(s), added %d: %s; removed %d: %s.' =>
	'%s edited answers, added: %3$s; removed: %5$s',

	'%s added %d answer(s): %s.' => array(
	array(
	'%s added a answer: %3$s.',
	'%s added answers: %3$s.',
	),
	),

	'%s removed %d answer(s): %s.' => array(
	array(
	'%s removed a answer: %3$s.',
	'%s removed answers: %3$s.',
	),
	),

	'%s edited question(s), added %d: %s; removed %d: %s.' =>
	'%s edited questions, added: %3$s; removed: %5$s',

	'%s added %d question(s): %s.' => array(
	array(
	'%s added a question: %3$s.',
	'%s added questions: %3$s.',
	),
	),

	'%s removed %d question(s): %s.' => array(
	array(
	'%s removed a question: %3$s.',
	'%s removed questions: %3$s.',
	),
	),

	'%s edited mock(s), added %d: %s; removed %d: %s.' =>
	'%s edited mocks, added: %3$s; removed: %5$s',

	'%s added %d mock(s): %s.' => array(
	array(
	'%s added a mock: %3$s.',
	'%s added mocks: %3$s.',
	),
	),

	'%s removed %d mock(s): %s.' => array(
	array(
	'%s removed a mock: %3$s.',
	'%s removed mocks: %3$s.',
	),
	),

	'%s edited task(s), added %d: %s; removed %d: %s.' =>
	'%s edited tasks, added: %3$s; removed: %5$s',

	'%s added %d task(s): %s.' => array(
	array(
	'%s added a task: %3$s.',
	'%s added tasks: %3$s.',
	),
	),

	'%s removed %d task(s): %s.' => array(
	array(
	'%s removed a task: %3$s.',
	'%s removed tasks: %3$s.',
	),
	),

	'%s edited file(s), added %d: %s; removed %d: %s.' =>
	'%s edited files, added: %3$s; removed: %5$s',

	'%s added %d file(s): %s.' => array(
	array(
	'%s added a file: %3$s.',
	'%s added files: %3$s.',
	),
	),

	'%s removed %d file(s): %s.' => array(
	array(
	'%s removed a file: %3$s.',
	'%s removed files: %3$s.',
	),
	),

	'%s edited account(s), added %d: %s; removed %d: %s.' =>
	'%s edited accounts, added: %3$s; removed: %5$s',

	'%s added %d account(s): %s.' => array(
	array(
	'%s added a account: %3$s.',
	'%s added accounts: %3$s.',
	),
	),

	'%s removed %d account(s): %s.' => array(
	array(
	'%s removed a account: %3$s.',
	'%s removed accounts: %3$s.',
	),
	),

	'%s edited charge(s), added %d: %s; removed %d: %s.' =>
	'%s edited charges, added: %3$s; removed: %5$s',

	'%s added %d charge(s): %s.' => array(
	array(
	'%s added a charge: %3$s.',
	'%s added charges: %3$s.',
	),
	),

	'%s removed %d charge(s): %s.' => array(
	array(
	'%s removed a charge: %3$s.',
	'%s removed charges: %3$s.',
	),
	),

	'%s edited purchase(s), added %d: %s; removed %d: %s.' =>
	'%s edited purchases, added: %3$s; removed: %5$s',

	'%s added %d purchase(s): %s.' => array(
	array(
	'%s added a purchase: %3$s.',
	'%s added purchases: %3$s.',
	),
	),

	'%s removed %d purchase(s): %s.' => array(
	array(
	'%s removed a purchase: %3$s.',
	'%s removed purchases: %3$s.',
	),
	),

	'%s edited contributor(s), added %d: %s; removed %d: %s.' =>
	'%s edited contributors, added: %3$s; removed: %5$s',

	'%s added %d contributor(s): %s.' => array(
	array(
	'%s added a contributor: %3$s.',
	'%s added contributors: %3$s.',
	),
	),

	'%s removed %d contributor(s): %s.' => array(
	array(
	'%s removed a contributor: %3$s.',
	'%s removed contributors: %3$s.',
	),
	),

	'%s edited reviewer(s), added %d: %s; removed %d: %s.' =>
	'%s edited reviewers, added: %3$s; removed: %5$s',

	'%s added %d reviewer(s): %s.' => array(
	array(
	'%s added a reviewer: %3$s.',
	'%s added reviewers: %3$s.',
	),
	),

	'%s removed %d reviewer(s): %s.' => array(
	array(
	'%s removed a reviewer: %3$s.',
	'%s removed reviewers: %3$s.',
	),
	),

	'%s edited object(s), added %d: %s; removed %d: %s.' =>
	'%s edited objects, added: %3$s; removed: %5$s',

	'%s added %d object(s): %s.' => array(
	array(
	'%s added a object: %3$s.',
	'%s added objects: %3$s.',
	),
	),

	'%s removed %d object(s): %s.' => array(
	array(
	'%s removed a object: %3$s.',
	'%s removed objects: %3$s.',
	),
	),

	'%s edited subscriber(s), added %d: %s; removed %d: %s.' =>
	'%s edited subscribers, added: %3$s; removed: %5$s',

	'%s added %d subscriber(s): %s.' => array(
	array(
	'%s added a subscriber: %3$s.',
	'%s added subscribers: %3$s.',
	),
	),

	'%s removed %d subscriber(s): %s.' => array(
	array(
	'%s removed a subscriber: %3$s.',
	'%s removed subscribers: %3$s.',
	),
	),

	'%s edited unsubscriber(s), added %d: %s; removed %d: %s.' =>
	'%s edited unsubscribers, added: %3$s; removed: %5$s',

	'%s added %d unsubscriber(s): %s.' => array(
	array(
	'%s added a unsubscriber: %3$s.',
	'%s added unsubscribers: %3$s.',
	),
	),

	'%s removed %d unsubscriber(s): %s.' => array(
	array(
	'%s removed a unsubscriber: %3$s.',
	'%s removed unsubscribers: %3$s.',
	),
	),

	'%s edited participant(s), added %d: %s; removed %d: %s.' =>
	'%s edited participants, added: %3$s; removed: %5$s',

	'%s added %d participant(s): %s.' => array(
	array(
	'%s added a participant: %3$s.',
	'%s added participants: %3$s.',
	),
	),

	'%s removed %d participant(s): %s.' => array(
	array(
	'%s removed a participant: %3$s.',
	'%s removed participants: %3$s.',
	),
	),

	'%s edited image(s), added %d: %s; removed %d: %s.' =>
	'%s edited images, added: %3$s; removed: %5$s',

	'%s added %d image(s): %s.' => array(
	array(
	'%s added an image: %3$s.',
	'%s added images: %3$s.',
	),
	),

	'%s removed %d image(s): %s.' => array(
	array(
	'%s removed an image: %3$s.',
	'%s removed images: %3$s.',
	),
	),

	'%d people(s)' => array(
	array(
	'%d person',
	'%d people',
	),
	),

	'%s Line(s)' => array(
	'%s Line',
	'%s Lines',
	),

	"Indexing %d object(s) of type %s." => array(
	"Indexing %d object of type %s.",
	"Indexing %d object of type %s.",
	),

	'Run these %d command(s):' => array(
	'Run this command:',
	'Run these commands:',
	),

	'Install these %d PHP extension(s):' => array(
	'Install this PHP extension:',
	'Install these PHP extensions:',
	),

	'The current Phabricator configuration has these %d value(s):' => array(
	'The current Phabricator configuration has this value:',
	'The current Phabricator configuration has these values:',
	),

	'To update these %d value(s), run these command(s) from the command line:'
	=> array(
	'To update this value, run this command from the command line:',
	'To update these values, run these commands from the command line:',
	),

	'You can update these %d value(s) here:' => array(
	'You can update this value here:',
	'You can update these values here:',
	),

	'The current PHP configuration has these %d value(s):' => array(
	'The current PHP configuration has this value:',
	'The current PHP configuration has these values:',
	),

	'To update these %d value(s), edit your PHP configuration file.' => array(
	'To update this %d value, edit your PHP configuration file.',
	'To update these %d values, edit your PHP configuration file.',
	),

	'To update these %d value(s), edit your PHP configuration file, located '.
	'here:' => array(
	'To update this value, edit your PHP configuration file, located '.
	'here:',
	'To update these values, edit your PHP configuration file, located '.
	'here:',
	),

	'PHP also loaded these configuration file(s):' => array(
	'PHP also loaded this configuration file:',
	'PHP also loaded these configuration files:',
	),

	'You have %d unresolved setup issue(s)...' => array(
	'You have an unresolved setup issue...',
	'You have %d unresolved setup issues...',
	),

	'%s added %d inline comment(s).' => array(
	array(
	'%s added an inline comment.',
	'%s added inline comments.',
	),
	),

	'%d comment(s)' => array('%d comment', '%d comments'),
	'%d rejection(s)' => array('%d rejection', '%d rejections'),
	'%d update(s)' => array('%d update', '%d updates'),

	'This configuration value is defined in these %d '.
	'configuration source(s): %s.' => array(
	'This configuration value is defined in this '.
	'configuration source: %2$s.',
	'This configuration value is defined in these %d '.
	'configuration sources: %s.',
	),

	'%d Open Pull Request(s)' => array(
	'%d Open Pull Request',
	'%d Open Pull Requests',
	),

	'Stale (%s day(s))' => array(
	'Stale (%s day)',
	'Stale (%s days)',
	),

	'Old (%s day(s))' => array(
	'Old (%s day)',
	'Old (%s days)',
	),

	'%s Commit(s)' => array(
	'%s Commit',
	'%s Commits',
	),

	'%s added %d project(s): %s' => array(
	array(
	- '%s added a project: %2$s',
	- '%s added projects: %2$s',
	+ '%s added a project: %3$s',
	+ '%s added projects: %3$s',
	),
	),

	'%s removed %d project(s): %s' => array(
	array(
	- '%s removed a project: %2$s',
	- '%s removed projects: %2$s',
	+ '%s removed a project: %3$s',
	+ '%s removed projects: %3$s',
	),
	),

	'%s changed project(s), added %d: %s; removed %d: %s' =>
	'%s changed projects, added: %3$s; removed: %5$s',

	'%s attached %d file(s): %s' => array(
	array(
	'%s attached a file: %3$s',
	'%s attached files: %3$s',
	),
	),

	'%s detached %d file(s): %s' => array(
	array(
	'%s detached a file: %3$s',
	'%s detached files: %3$s',
	),
	),

	'%s changed file(s), attached %d: %s; detached %d: %s' =>
	'%s changed files, attached: %3$s; detached: %5$s',


	'%s added %d dependencie(s): %s.' => array(
	array(
	'%s added a dependency: %3$s',
	'%s added a dependencies: %3$s',
	),
	),

	'%s added %d dependent task(s): %s.' => array(
	array(
	'%s added a dependent task: %3$s',
	'%s added dependent tasks: %3$s',
	),
	),

	'%s removed %d dependencie(s): %s.' => array(
	array(
	'%s removed a dependency: %3$s.',
	'%s removed dependencies: %3$s.',
	),
	),

	'%s removed %d dependent task(s): %s.' => array(
	array(
	'%s removed a dependent task: %3$s.',
	'%s removed dependent tasks: %3$s.',
	),
	),

	+ '%s added %d revision(s): %s.' => array(
	+ array(
	+ '%s added a revision: %3$s.',
	+ '%s added revisions: %3$s.',
	+ ),
	+ ),
	+
	+ '%s removed %d revision(s): %s.' => array(
	+ array(
	+ '%s removed a revision: %3$s.',
	+ '%s removed revisions: %3$s.',
	+ ),
	+ ),
	+
	+ '%s added %d commit(s): %s.' => array(
	+ array(
	+ '%s added a commit: %3$s.',
	+ '%s added commits: %3$s.',
	+ ),
	+ ),
	+
	+ '%s removed %d commit(s): %s.' => array(
	+ array(
	+ '%s removed a commit: %3$s.',
	+ '%s removed commits: %3$s.',
	+ ),
	+ ),
	+
	+ '%s edited commit(s), added %d: %s; removed %d: %s.' =>
	+ '%s edited commits, added %3$s; removed %5$s.',
	+
	);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Nov 13, 3:47 PM (1 h, 48 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 336250
Default Alt Text: (97 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions