No OneTemporary
Actions

Size

92 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/scripts/symbols/import_repository_symbols.php b/scripts/symbols/import_repository_symbols.php
	index 94cf601a34..2ac2b3c8a9 100755
	--- a/scripts/symbols/import_repository_symbols.php
	+++ b/scripts/symbols/import_repository_symbols.php
	@@ -1,229 +1,229 @@
	#!/usr/bin/env php
	<?php

	$root = dirname(dirname(dirname(__FILE__)));
	require_once $root.'/scripts/__init_script__.php';

	$args = new PhutilArgumentParser($argv);
	$args->setSynopsis(<<<EOSYNOPSIS
	import_repository_symbols.php [__options__] __callsign__ < symbols

	Import repository symbols (symbols are read from stdin).
	EOSYNOPSIS
	);
	$args->parseStandardArguments();
	$args->parse(
	array(
	array(
	'name' => 'no-purge',
	'help' => pht(
	'Do not clear all symbols for this repository before '.
	'uploading new symbols. Useful for incremental updating.'),
	),
	array(
	'name' => 'ignore-errors',
	'help' => pht(
	"If a line can't be parsed, ignore that line and ".
	"continue instead of exiting."),
	),
	array(
	'name' => 'max-transaction',
	'param' => 'num-syms',
	'default' => '100000',
	'help' => pht(
	'Maximum number of symbols that should '.
	'be part of a single transaction.'),
	),
	array(
	'name' => 'callsign',
	'wildcard' => true,
	),
	));

	$callsigns = $args->getArg('callsign');
	if (count($callsigns) !== 1) {
	$args->printHelpAndExit();
	}

	$callsign = head($callsigns);
	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withCallsigns($callsigns)
	->executeOne();

	if (!$repository) {
	echo pht("Repository '%s' does not exist.", $callsign);
	exit(1);
	}

	if (!function_exists('posix_isatty') \|\| posix_isatty(STDIN)) {
	echo pht('Parsing input from stdin...'), "\n";
	}

	$input = file_get_contents('php://stdin');
	$input = trim($input);
	$input = explode("\n", $input);


	function commit_symbols(
	array $symbols,
	PhabricatorRepository $repository,
	$no_purge) {

	echo pht('Looking up path IDs...'), "\n";
	$path_map =
	PhabricatorRepositoryCommitChangeParserWorker::lookupOrCreatePaths(
	ipull($symbols, 'path'));

	$symbol = new PhabricatorRepositorySymbol();
	$conn_w = $symbol->establishConnection('w');

	echo pht('Preparing queries...'), "\n";
	$sql = array();
	foreach ($symbols as $dict) {
	$sql[] = qsprintf(
	$conn_w,
	'(%s, %s, %s, %s, %s, %d, %d)',
	$repository->getPHID(),
	$dict['ctxt'],
	$dict['name'],
	$dict['type'],
	$dict['lang'],
	$dict['line'],
	$path_map[$dict['path']]);
	}

	if (!$no_purge) {
	echo pht('Purging old symbols...'), "\n";
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryPHID = %s',
	$symbol->getTableName(),
	$repository->getPHID());
	}

	echo pht('Loading %s symbols...', new PhutilNumber(count($sql))), "\n";
	foreach (array_chunk($sql, 128) as $chunk) {
	queryfx(
	$conn_w,
	'INSERT INTO %T
	(repositoryPHID, symbolContext, symbolName, symbolType,
	symbolLanguage, lineNumber, pathID) VALUES %Q',
	$symbol->getTableName(),
	implode(', ', $chunk));
	}
	}

	function check_string_value($value, $field_name, $line_no, $max_length) {
	if (strlen($value) > $max_length) {
	throw new Exception(
	pht(
	"%s '%s' defined on line #%d is too long, ".
	"maximum %s length is %d characters.",
	$field_name,
	$value,
	$line_no,
	$field_name,
	$max_length));
	}

	if (!phutil_is_utf8_with_only_bmp_characters($value)) {
	throw new Exception(
	pht(
	"%s '%s' defined on line #%d is not a valid ".
	"UTF-8 string, it should contain only UTF-8 characters.",
	$field_name,
	$value,
	$line_no));
	}
	}

	$no_purge = $args->getArg('no-purge');
	$symbols = array();
	foreach ($input as $key => $line) {
	try {
	$line_no = $key + 1;
	$matches = null;
	$ok = preg_match(
	'/^((?P<context>[^ ]+)? )?(?P<name>[^ ]+) (?P<type>[^ ]+) '.
	'(?P<lang>[^ ]+) (?P<line>\d+) (?P<path>.*)$/',
	$line,
	$matches);
	if (!$ok) {
	throw new Exception(
	pht(
	"Line #%d of input is invalid. Expected five or six space-delimited ".
	"fields: maybe symbol context, symbol name, symbol type, symbol ".
	"language, line number, path. For example:\n\n%s\n\n".
	"Actual line was:\n\n%s",
	$line_no,
	'idx function php 13 /path/to/some/file.php',
	$line));
	}
	if (empty($matches['context'])) {
	$matches['context'] = '';
	}
	$context = $matches['context'];
	$name = $matches['name'];
	$type = $matches['type'];
	$lang = $matches['lang'];
	$line_number = $matches['line'];
	$path = $matches['path'];

	check_string_value($context, pht('Symbol context'), $line_no, 128);
	check_string_value($name, pht('Symbol name'), $line_no, 128);
	check_string_value($type, pht('Symbol type'), $line_no, 12);
	check_string_value($lang, pht('Symbol language'), $line_no, 32);
	check_string_value($path, pht('Path'), $line_no, 512);

	if (!strlen($path) \|\| $path[0] != '/') {
	throw new Exception(
	pht(
	"Path '%s' defined on line #%d is invalid. Paths should begin with ".
	"'%s' and specify a path from the root of the project, like '%s'.",
	$path,
	$line_no,
	'/',
	'/src/utils/utils.php'));
	}

	$symbols[] = array(
	'ctxt' => $context,
	'name' => $name,
	'type' => $type,
	'lang' => $lang,
	'line' => $line_number,
	'path' => $path,
	);
	} catch (Exception $e) {
	if ($args->getArg('ignore-errors')) {
	continue;
	} else {
	throw $e;
	}
	}

	- if (count ($symbols) >= $args->getArg('max-transaction')) {
	+ if (count($symbols) >= $args->getArg('max-transaction')) {
	try {
	echo pht(
	"Committing %s symbols...\n",
	new PhutilNumber($args->getArg('max-transaction')));
	commit_symbols($symbols, $repository, $no_purge);
	$no_purge = true;
	unset($symbols);
	$symbols = array();
	} catch (Exception $e) {
	if ($args->getArg('ignore-errors')) {
	continue;
	} else {
	throw $e;
	}
	}
	}
	}

	if (count($symbols)) {
	commit_symbols($symbols, $repository, $no_purge);
	}

	echo pht('Done.')."\n";
	diff --git a/src/applications/audit/editor/PhabricatorAuditEditor.php b/src/applications/audit/editor/PhabricatorAuditEditor.php
	index e9dd384812..7c0f3d2e34 100644
	--- a/src/applications/audit/editor/PhabricatorAuditEditor.php
	+++ b/src/applications/audit/editor/PhabricatorAuditEditor.php
	@@ -1,968 +1,968 @@
	<?php

	final class PhabricatorAuditEditor
	extends PhabricatorApplicationTransactionEditor {

	const MAX_FILES_SHOWN_IN_EMAIL = 1000;

	private $auditReasonMap = array();
	private $affectedFiles;
	private $rawPatch;
	private $auditorPHIDs = array();

	private $didExpandInlineState;

	public function addAuditReason($phid, $reason) {
	if (!isset($this->auditReasonMap[$phid])) {
	$this->auditReasonMap[$phid] = array();
	}
	$this->auditReasonMap[$phid][] = $reason;
	return $this;
	}

	private function getAuditReasons($phid) {
	if (isset($this->auditReasonMap[$phid])) {
	return $this->auditReasonMap[$phid];
	}
	if ($this->getIsHeraldEditor()) {
	$name = 'herald';
	} else {
	$name = $this->getActor()->getUsername();
	}
	return array(pht('Added by %s.', $name));
	}

	public function setRawPatch($patch) {
	$this->rawPatch = $patch;
	return $this;
	}

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

	public function getEditorApplicationClass() {
	return 'PhabricatorAuditApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Audits');
	}

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

	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = PhabricatorTransactions::TYPE_EDGE;
	$types[] = PhabricatorTransactions::TYPE_INLINESTATE;

	$types[] = PhabricatorAuditTransaction::TYPE_COMMIT;

	// TODO: These will get modernized eventually, but that can happen one
	// at a time later on.
	$types[] = PhabricatorAuditActionConstants::ACTION;
	$types[] = PhabricatorAuditActionConstants::INLINE;
	$types[] = PhabricatorAuditActionConstants::ADD_AUDITORS;

	return $types;
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::INLINE:
	return $xaction->hasComment();
	}

	return parent::transactionHasEffect($object, $xaction);
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::ACTION:
	case PhabricatorAuditActionConstants::INLINE:
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return null;
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	// TODO: For now, just record the added PHIDs. Eventually, turn these
	// into real edge transactions, probably?
	return array();
	}

	return parent::getCustomTransactionOldValue($object, $xaction);
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::ACTION:
	case PhabricatorAuditActionConstants::INLINE:
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return $xaction->getNewValue();
	}

	return parent::getCustomTransactionNewValue($object, $xaction);
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::ACTION:
	case PhabricatorAuditActionConstants::INLINE:
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return;
	}

	return parent::applyCustomInternalTransaction($object, $xaction);
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::ACTION:
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return;
	case PhabricatorAuditActionConstants::INLINE:
	$reply = $xaction->getComment()->getReplyToComment();
	if ($reply && !$reply->getHasReplies()) {
	$reply->setHasReplies(1)->save();
	}
	return;
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	$new = $xaction->getNewValue();
	if (!is_array($new)) {
	$new = array();
	}

	$old = $xaction->getOldValue();
	if (!is_array($old)) {
	$old = array();
	}

	$add = array_diff_key($new, $old);

	$actor = $this->requireActor();

	$requests = $object->getAudits();
	$requests = mpull($requests, null, 'getAuditorPHID');
	foreach ($add as $phid) {
	if (isset($requests[$phid])) {
	continue;
	}

	if ($this->getIsHeraldEditor()) {
	$audit_requested = $xaction->getMetadataValue('auditStatus');
	$audit_reason_map = $xaction->getMetadataValue('auditReasonMap');
	$audit_reason = $audit_reason_map[$phid];
	} else {
	$audit_requested = PhabricatorAuditStatusConstants::AUDIT_REQUESTED;
	$audit_reason = $this->getAuditReasons($phid);
	}
	- $requests[] = id (new PhabricatorRepositoryAuditRequest())
	+ $requests[] = id(new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($object->getPHID())
	->setAuditorPHID($phid)
	->setAuditStatus($audit_requested)
	->setAuditReasons($audit_reason)
	->save();
	}

	$object->attachAudits($requests);
	return;
	}

	return parent::applyCustomExternalTransaction($object, $xaction);
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_INLINESTATE:
	$table = new PhabricatorAuditTransactionComment();
	$conn_w = $table->establishConnection('w');
	foreach ($xaction->getNewValue() as $phid => $state) {
	queryfx(
	$conn_w,
	'UPDATE %T SET fixedState = %s WHERE phid = %s',
	$table->getTableName(),
	$state,
	$phid);
	}
	break;
	}

	return parent::applyBuiltinExternalTransaction($object, $xaction);
	}

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

	// Load auditors explicitly; we may not have them if the caller was a
	// generic piece of infrastructure.

	$commit = id(new DiffusionCommitQuery())
	->setViewer($this->requireActor())
	->withIDs(array($object->getID()))
	->needAuditRequests(true)
	->executeOne();
	if (!$commit) {
	throw new Exception(
	pht('Failed to load commit during transaction finalization!'));
	}
	$object->attachAudits($commit->getAudits());

	$status_concerned = PhabricatorAuditStatusConstants::CONCERNED;
	$status_closed = PhabricatorAuditStatusConstants::CLOSED;
	$status_resigned = PhabricatorAuditStatusConstants::RESIGNED;
	$status_accepted = PhabricatorAuditStatusConstants::ACCEPTED;
	$status_concerned = PhabricatorAuditStatusConstants::CONCERNED;

	$actor_phid = $this->getActingAsPHID();
	$actor_is_author = ($object->getAuthorPHID()) &&
	($actor_phid == $object->getAuthorPHID());

	$import_status_flag = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$import_status_flag = PhabricatorRepositoryCommit::IMPORTED_HERALD;
	break;
	case PhabricatorAuditActionConstants::ACTION:
	$new = $xaction->getNewValue();
	switch ($new) {
	case PhabricatorAuditActionConstants::CLOSE:
	// "Close" means wipe out all the concerns.
	$requests = $object->getAudits();
	foreach ($requests as $request) {
	if ($request->getAuditStatus() == $status_concerned) {
	$request
	->setAuditStatus($status_closed)
	->save();
	}
	}
	break;
	case PhabricatorAuditActionConstants::RESIGN:
	$requests = $object->getAudits();
	$requests = mpull($requests, null, 'getAuditorPHID');
	$actor_request = idx($requests, $actor_phid);

	// If the actor doesn't currently have a relationship to the
	// commit, add one explicitly. For example, this allows members
	// of a project to resign from a commit and have it drop out of
	// their queue.

	if (!$actor_request) {
	$actor_request = id(new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($object->getPHID())
	->setAuditorPHID($actor_phid);

	$requests[] = $actor_request;
	$object->attachAudits($requests);
	}

	$actor_request
	->setAuditStatus($status_resigned)
	->save();
	break;
	case PhabricatorAuditActionConstants::ACCEPT:
	case PhabricatorAuditActionConstants::CONCERN:
	if ($new == PhabricatorAuditActionConstants::ACCEPT) {
	$new_status = $status_accepted;
	} else {
	$new_status = $status_concerned;
	}

	$requests = $object->getAudits();
	$requests = mpull($requests, null, 'getAuditorPHID');

	// Figure out which requests the actor has authority over: these
	// are user requests where they are the auditor, and packages
	// and projects they are a member of.

	if ($actor_is_author) {
	// When modifying your own commits, you act only on behalf of
	// yourself, not your packages/projects -- the idea being that
	// you can't accept your own commits.
	$authority_phids = array($actor_phid);
	} else {
	$authority_phids =
	PhabricatorAuditCommentEditor::loadAuditPHIDsForUser(
	$this->requireActor());
	}

	$authority = array_select_keys(
	$requests,
	$authority_phids);

	if (!$authority) {
	// If the actor has no authority over any existing requests,
	// create a new request for them.

	$actor_request = id(new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($object->getPHID())
	->setAuditorPHID($actor_phid)
	->setAuditStatus($new_status)
	->save();

	$requests[$actor_phid] = $actor_request;
	$object->attachAudits($requests);
	} else {
	// Otherwise, update the audit status of the existing requests.
	foreach ($authority as $request) {
	$request
	->setAuditStatus($new_status)
	->save();
	}
	}
	break;

	}
	break;
	}
	}

	$requests = $object->getAudits();
	$object->updateAuditStatus($requests);
	$object->save();

	if ($import_status_flag) {
	$object->writeImportStatusFlag($import_status_flag);
	}

	// Collect auditor PHIDs for building mail.
	$this->auditorPHIDs = mpull($object->getAudits(), 'getAuditorPHID');

	return $xactions;
	}

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

	$xactions = parent::expandTransaction($object, $xaction);
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$request = $this->createAuditRequestTransactionFromCommitMessage(
	$object);
	if ($request) {
	$xactions[] = $request;
	$this->setUnmentionablePHIDMap($request->getNewValue());
	}
	break;
	default:
	break;
	}

	if (!$this->didExpandInlineState) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	case PhabricatorAuditActionConstants::ACTION:
	$this->didExpandInlineState = true;

	$actor_phid = $this->getActingAsPHID();
	$actor_is_author = ($object->getAuthorPHID() == $actor_phid);
	if (!$actor_is_author) {
	break;
	}

	$state_map = PhabricatorTransactions::getInlineStateMap();

	$inlines = id(new DiffusionDiffInlineCommentQuery())
	->setViewer($this->getActor())
	->withCommitPHIDs(array($object->getPHID()))
	->withFixedStates(array_keys($state_map))
	->execute();

	if (!$inlines) {
	break;
	}

	$old_value = mpull($inlines, 'getFixedState', 'getPHID');
	$new_value = array();
	foreach ($old_value as $key => $state) {
	$new_value[$key] = $state_map[$state];
	}

	$xactions[] = id(new PhabricatorAuditTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_INLINESTATE)
	->setIgnoreOnNoEffect(true)
	->setOldValue($old_value)
	->setNewValue($new_value);
	break;
	}
	}

	return $xactions;
	}

	private function createAuditRequestTransactionFromCommitMessage(
	PhabricatorRepositoryCommit $commit) {

	$data = $commit->getCommitData();
	$message = $data->getCommitMessage();

	$matches = null;
	if (!preg_match('/^Auditors?:\s(.)$/im', $message, $matches)) {
	return array();
	}

	$phids = id(new PhabricatorObjectListQuery())
	->setViewer($this->getActor())
	->setAllowPartialResults(true)
	->setAllowedTypes(
	array(
	PhabricatorPeopleUserPHIDType::TYPECONST,
	PhabricatorProjectProjectPHIDType::TYPECONST,
	))
	->setObjectList($matches[1])
	->execute();

	if (!$phids) {
	return array();
	}

	foreach ($phids as $phid) {
	$this->addAuditReason($phid, pht('Requested by Author'));
	}
	return id(new PhabricatorAuditTransaction())
	->setTransactionType(PhabricatorAuditActionConstants::ADD_AUDITORS)
	->setNewValue(array_fuse($phids));
	}

	protected function sortTransactions(array $xactions) {
	$xactions = parent::sortTransactions($xactions);

	$head = array();
	$tail = array();

	foreach ($xactions as $xaction) {
	$type = $xaction->getTransactionType();
	if ($type == PhabricatorAuditActionConstants::INLINE) {
	$tail[] = $xaction;
	} else {
	$head[] = $xaction;
	}
	}

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

	protected function validateTransaction(
	PhabricatorLiskDAO $object,
	$type,
	array $xactions) {

	$errors = parent::validateTransaction($object, $type, $xactions);

	foreach ($xactions as $xaction) {
	switch ($type) {
	case PhabricatorAuditActionConstants::ACTION:
	$error = $this->validateAuditAction(
	$object,
	$type,
	$xaction,
	$xaction->getNewValue());
	if ($error) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	$error,
	$xaction);
	}
	break;
	}
	}

	return $errors;
	}

	private function validateAuditAction(
	PhabricatorLiskDAO $object,
	$type,
	PhabricatorAuditTransaction $xaction,
	$action) {

	$can_author_close_key = 'audit.can-author-close-audit';
	$can_author_close = PhabricatorEnv::getEnvConfig($can_author_close_key);

	$actor_is_author = ($object->getAuthorPHID()) &&
	($object->getAuthorPHID() == $this->getActingAsPHID());

	switch ($action) {
	case PhabricatorAuditActionConstants::CLOSE:
	if (!$actor_is_author) {
	return pht(
	'You can not close this audit because you are not the author '.
	'of the commit.');
	}

	if (!$can_author_close) {
	return pht(
	'You can not close this audit because "%s" is disabled in '.
	'the Phabricator configuration.',
	$can_author_close_key);
	}

	break;
	}

	return null;
	}


	protected function supportsSearch() {
	return true;
	}

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

	// we are only really trying to find unmentionable phids here...
	// don't bother with this outside initial commit (i.e. create)
	// transaction
	$is_commit = false;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$is_commit = true;
	break;
	}
	}

	// "result" is always an array....
	$result = array();
	if (!$is_commit) {
	return $result;
	}

	$flat_blocks = array_mergev($blocks);
	$huge_block = implode("\n\n", $flat_blocks);
	$phid_map = array();
	$phid_map[] = $this->getUnmentionablePHIDMap();
	$monograms = array();

	$task_refs = id(new ManiphestCustomFieldStatusParser())
	->parseCorpus($huge_block);
	foreach ($task_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$monograms[] = $monogram;
	}
	}

	$rev_refs = id(new DifferentialCustomFieldDependsOnParser())
	->parseCorpus($huge_block);
	foreach ($rev_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$monograms[] = $monogram;
	}
	}

	$objects = id(new PhabricatorObjectQuery())
	->setViewer($this->getActor())
	->withNames($monograms)
	->execute();
	$phid_map[] = mpull($objects, 'getPHID', 'getPHID');
	$phid_map = array_mergev($phid_map);
	$this->setUnmentionablePHIDMap($phid_map);

	return $result;
	}

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	$reply_handler = new PhabricatorAuditReplyHandler();
	$reply_handler->setMailReceiver($object);
	return $reply_handler;
	}

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

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	// For backward compatibility, use this legacy thread ID.
	return 'diffusion-audit-'.$object->getPHID();
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$identifier = $object->getCommitIdentifier();
	$repository = $object->getRepository();
	$monogram = $repository->getMonogram();

	$summary = $object->getSummary();
	$name = $repository->formatCommitName($identifier);

	$subject = "{$name}: {$summary}";
	$thread_topic = "Commit {$monogram}{$identifier}";

	$template = id(new PhabricatorMetaMTAMail())
	->setSubject($subject)
	->addHeader('Thread-Topic', $thread_topic);

	$this->attachPatch(
	$template,
	$object);

	return $template;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();

	if ($object->getAuthorPHID()) {
	$phids[] = $object->getAuthorPHID();
	}

	$status_resigned = PhabricatorAuditStatusConstants::RESIGNED;
	foreach ($object->getAudits() as $audit) {
	if ($audit->getAuditStatus() != $status_resigned) {
	$phids[] = $audit->getAuditorPHID();
	}
	}

	return $phids;
	}

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

	$body = parent::buildMailBody($object, $xactions);

	$type_inline = PhabricatorAuditActionConstants::INLINE;
	$type_push = PhabricatorAuditTransaction::TYPE_COMMIT;

	$is_commit = false;
	$inlines = array();
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $type_inline) {
	$inlines[] = $xaction;
	}
	if ($xaction->getTransactionType() == $type_push) {
	$is_commit = true;
	}
	}

	if ($inlines) {
	$body->addTextSection(
	pht('INLINE COMMENTS'),
	$this->renderInlineCommentsForMail($object, $inlines));
	}

	if ($is_commit) {
	$data = $object->getCommitData();
	$body->addTextSection(pht('AFFECTED FILES'), $this->affectedFiles);
	$this->inlinePatch(
	$body,
	$object);
	}

	$data = $object->getCommitData();

	$user_phids = array();

	$author_phid = $object->getAuthorPHID();
	if ($author_phid) {
	$user_phids[$author_phid][] = pht('Author');
	}

	$committer_phid = $data->getCommitDetail('committerPHID');
	if ($committer_phid && ($committer_phid != $author_phid)) {
	$user_phids[$committer_phid][] = pht('Committer');
	}

	foreach ($this->auditorPHIDs as $auditor_phid) {
	$user_phids[$auditor_phid][] = pht('Auditor');
	}

	// TODO: It would be nice to show pusher here too, but that information
	// is a little tricky to get at right now.

	if ($user_phids) {
	$handle_phids = array_keys($user_phids);
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireActor())
	->withPHIDs($handle_phids)
	->execute();

	$user_info = array();
	foreach ($user_phids as $phid => $roles) {
	$user_info[] = pht(
	'%s (%s)',
	$handles[$phid]->getName(),
	implode(', ', $roles));
	}

	$body->addTextSection(
	pht('USERS'),
	implode("\n", $user_info));
	}

	$monogram = $object->getRepository()->formatCommitName(
	$object->getCommitIdentifier());

	$body->addLinkSection(
	pht('COMMIT'),
	PhabricatorEnv::getProductionURI('/'.$monogram));

	return $body;
	}

	private function attachPatch(
	PhabricatorMetaMTAMail $template,
	PhabricatorRepositoryCommit $commit) {

	if (!$this->getRawPatch()) {
	return;
	}

	$attach_key = 'metamta.diffusion.attach-patches';
	$attach_patches = PhabricatorEnv::getEnvConfig($attach_key);
	if (!$attach_patches) {
	return;
	}

	$repository = $commit->getRepository();
	$encoding = $repository->getDetail('encoding', 'UTF-8');

	$raw_patch = $this->getRawPatch();
	$commit_name = $repository->formatCommitName(
	$commit->getCommitIdentifier());

	$template->addAttachment(
	new PhabricatorMetaMTAAttachment(
	$raw_patch,
	$commit_name.'.patch',
	'text/x-patch; charset='.$encoding));
	}

	private function inlinePatch(
	PhabricatorMetaMTAMailBody $body,
	PhabricatorRepositoryCommit $commit) {

	if (!$this->getRawPatch()) {
	return;
	}

	$inline_key = 'metamta.diffusion.inline-patches';
	$inline_patches = PhabricatorEnv::getEnvConfig($inline_key);
	if (!$inline_patches) {
	return;
	}

	$repository = $commit->getRepository();
	$raw_patch = $this->getRawPatch();
	$result = null;
	$len = substr_count($raw_patch, "\n");
	if ($len <= $inline_patches) {
	// We send email as utf8, so we need to convert the text to utf8 if
	// we can.
	$encoding = $repository->getDetail('encoding', 'UTF-8');
	if ($encoding) {
	$raw_patch = phutil_utf8_convert($raw_patch, 'UTF-8', $encoding);
	}
	$result = phutil_utf8ize($raw_patch);
	}

	if ($result) {
	$result = "PATCH\n\n{$result}\n";
	}
	$body->addRawSection($result);
	}

	private function renderInlineCommentsForMail(
	PhabricatorLiskDAO $object,
	array $inline_xactions) {

	$inlines = mpull($inline_xactions, 'getComment');

	$block = array();

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

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

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

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

	return implode("\n", $block);
	}

	public function getMailTagsMap() {
	return array(
	PhabricatorAuditTransaction::MAILTAG_COMMIT =>
	pht('A commit is created.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_CONCERN =>
	pht('A commit has a concerned raised against it.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_ACCEPT =>
	pht('A commit is accepted.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_RESIGN =>
	pht('A commit has an auditor resign.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_CLOSE =>
	pht('A commit is closed.'),
	PhabricatorAuditTransaction::MAILTAG_ADD_AUDITORS =>
	pht('A commit has auditors added.'),
	PhabricatorAuditTransaction::MAILTAG_ADD_CCS =>
	pht("A commit's subscribers change."),
	PhabricatorAuditTransaction::MAILTAG_PROJECTS =>
	pht("A commit's projects change."),
	PhabricatorAuditTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a commit.'),
	PhabricatorAuditTransaction::MAILTAG_OTHER =>
	pht('Other commit activity not listed above occurs.'),
	);
	}

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$repository = $object->getRepository();
	if (!$repository->shouldPublish()) {
	return false;
	}
	return true;
	default:
	break;
	}
	}
	return parent::shouldApplyHeraldRules($object, $xactions);
	}

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

	return id(new HeraldCommitAdapter())
	->setCommit($object);
	}

	protected function didApplyHeraldRules(
	PhabricatorLiskDAO $object,
	HeraldAdapter $adapter,
	HeraldTranscript $transcript) {

	$limit = self::MAX_FILES_SHOWN_IN_EMAIL;
	$files = $adapter->loadAffectedPaths();
	sort($files);
	if (count($files) > $limit) {
	array_splice($files, $limit);
	$files[] = pht(
	'(This commit affected more than %d files. Only %d are shown here '.
	'and additional ones are truncated.)',
	$limit,
	$limit);
	}
	$this->affectedFiles = implode("\n", $files);

	return array();
	}

	private function isCommitMostlyImported(PhabricatorLiskDAO $object) {
	$has_message = PhabricatorRepositoryCommit::IMPORTED_MESSAGE;
	$has_changes = PhabricatorRepositoryCommit::IMPORTED_CHANGE;

	// Don't publish feed stories or email about events which occur during
	// import. In particular, this affects tasks being attached when they are
	// closed by "Fixes Txxxx" in a commit message. See T5851.

	$mask = ($has_message \| $has_changes);

	return $object->isPartiallyImported($mask);
	}


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

	// not every code path loads the repository so tread carefully
	// TODO: They should, and then we should simplify this.
	$repository = $object->getRepository($assert_attached = false);
	if ($repository != PhabricatorLiskDAO::ATTACHABLE) {
	if (!$repository->shouldPublish()) {
	return false;
	}
	}

	return $this->isCommitMostlyImported($object);
	}

	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldPublishRepositoryActivity($object, $xactions);
	}

	protected function shouldEnableMentions(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldPublishRepositoryActivity($object, $xactions);
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldPublishRepositoryActivity($object, $xactions);
	}

	protected function getCustomWorkerState() {
	return array(
	'rawPatch' => $this->rawPatch,
	'affectedFiles' => $this->affectedFiles,
	'auditorPHIDs' => $this->auditorPHIDs,
	);
	}

	protected function loadCustomWorkerState(array $state) {
	$this->rawPatch = idx($state, 'rawPatch');
	$this->affectedFiles = idx($state, 'affectedFiles');
	$this->auditorPHIDs = idx($state, 'auditorPHIDs');
	return $this;
	}

	protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
	return id(new DiffusionCommitQuery())
	->setViewer($this->requireActor())
	->withIDs(array($object->getID()))
	->needAuditRequests(true)
	->needCommitData(true)
	->executeOne();
	}

	}
	diff --git a/src/applications/diffusion/query/DiffusionCommitQuery.php b/src/applications/diffusion/query/DiffusionCommitQuery.php
	index 7098e7416f..45f8b063af 100644
	--- a/src/applications/diffusion/query/DiffusionCommitQuery.php
	+++ b/src/applications/diffusion/query/DiffusionCommitQuery.php
	@@ -1,615 +1,615 @@
	<?php

	final class DiffusionCommitQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $authorPHIDs;
	private $defaultRepository;
	private $identifiers;
	private $repositoryIDs;
	private $repositoryPHIDs;
	private $identifierMap;

	private $needAuditRequests;
	private $auditIDs;
	private $auditorPHIDs;
	private $auditAwaitingUser;
	private $auditStatus;
	private $epochMin;
	private $epochMax;
	private $importing;

	const AUDIT_STATUS_ANY = 'audit-status-any';
	const AUDIT_STATUS_OPEN = 'audit-status-open';
	const AUDIT_STATUS_CONCERN = 'audit-status-concern';
	const AUDIT_STATUS_ACCEPTED = 'audit-status-accepted';
	const AUDIT_STATUS_PARTIAL = 'audit-status-partial';

	private $needCommitData;

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function withAuthorPHIDs(array $phids) {
	$this->authorPHIDs = $phids;
	return $this;
	}

	/**
	* Load commits by partial or full identifiers, e.g. "rXab82393", "rX1234",
	* or "a9caf12". When an identifier matches multiple commits, they will all
	* be returned; callers should be prepared to deal with more results than
	* they queried for.
	*/
	public function withIdentifiers(array $identifiers) {
	$this->identifiers = $identifiers;
	return $this;
	}

	/**
	* Look up commits in a specific repository. This is a shorthand for calling
	* @{method:withDefaultRepository} and @{method:withRepositoryIDs}.
	*/
	public function withRepository(PhabricatorRepository $repository) {
	$this->withDefaultRepository($repository);
	$this->withRepositoryIDs(array($repository->getID()));
	return $this;
	}

	/**
	* Look up commits in a specific repository. Prefer
	* @{method:withRepositoryIDs}; the underyling table is keyed by ID such
	* that this method requires a separate initial query to map PHID to ID.
	*/
	public function withRepositoryPHIDs(array $phids) {
	$this->repositoryPHIDs = $phids;
	}

	/**
	* If a default repository is provided, ambiguous commit identifiers will
	* be assumed to belong to the default repository.
	*
	* For example, "r123" appearing in a commit message in repository X is
	* likely to be unambiguously "rX123". Normally the reference would be
	* considered ambiguous, but if you provide a default repository it will
	* be correctly resolved.
	*/
	public function withDefaultRepository(PhabricatorRepository $repository) {
	$this->defaultRepository = $repository;
	return $this;
	}

	public function withRepositoryIDs(array $repository_ids) {
	$this->repositoryIDs = $repository_ids;
	return $this;
	}

	public function needCommitData($need) {
	$this->needCommitData = $need;
	return $this;
	}

	public function needAuditRequests($need) {
	$this->needAuditRequests = $need;
	return $this;
	}

	/**
	* Returns true if we should join the audit table, either because we're
	* interested in the information if it's available or because matching rows
	* must always have it.
	*/
	private function shouldJoinAudits() {
	return $this->auditStatus \|\|
	$this->rowsMustHaveAudits();
	}

	/**
	* Return true if we should `JOIN` (vs `LEFT JOIN`) the audit table, because
	* matching commits will always have audit rows.
	*/
	private function rowsMustHaveAudits() {
	return
	$this->auditIDs \|\|
	$this->auditorPHIDs \|\|
	$this->auditAwaitingUser;
	}

	public function withAuditIDs(array $ids) {
	$this->auditIDs = $ids;
	return $this;
	}

	public function withAuditorPHIDs(array $auditor_phids) {
	$this->auditorPHIDs = $auditor_phids;
	return $this;
	}

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

	public function withAuditStatus($status) {
	$this->auditStatus = $status;
	return $this;
	}

	public function withEpochRange($min, $max) {
	$this->epochMin = $min;
	$this->epochMax = $max;
	return $this;
	}

	public function withImporting($importing) {
	$this->importing = $importing;
	return $this;
	}

	public function getIdentifierMap() {
	if ($this->identifierMap === null) {
	throw new Exception(
	pht(
	'You must %s the query before accessing the identifier map.',
	'execute()'));
	}
	return $this->identifierMap;
	}

	protected function getPrimaryTableAlias() {
	return 'commit';
	}

	protected function willExecute() {
	if ($this->identifierMap === null) {
	$this->identifierMap = array();
	}
	}

	protected function loadPage() {
	$table = new PhabricatorRepositoryCommit();
	$conn_r = $table->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT commit.* FROM %T commit %Q %Q %Q %Q %Q',
	$table->getTableName(),
	$this->buildJoinClause($conn_r),
	$this->buildWhereClause($conn_r),
	$this->buildGroupClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

	return $table->loadAllFromArray($data);
	}

	protected function willFilterPage(array $commits) {
	$repository_ids = mpull($commits, 'getRepositoryID', 'getRepositoryID');
	$repos = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withIDs($repository_ids)
	->execute();

	$min_qualified = PhabricatorRepository::MINIMUM_QUALIFIED_HASH;
	$result = array();

	foreach ($commits as $key => $commit) {
	$repo = idx($repos, $commit->getRepositoryID());
	if ($repo) {
	$commit->attachRepository($repo);
	} else {
	$this->didRejectResult($commit);
	unset($commits[$key]);
	continue;
	}

	// Build the identifierMap
	if ($this->identifiers !== null) {
	$ids = array_fuse($this->identifiers);
	$prefixes = array(
	'r'.$commit->getRepository()->getCallsign(),
	'r'.$commit->getRepository()->getCallsign().':',
	'R'.$commit->getRepository()->getID().':',
	'', // No prefix is valid too and will only match the commitIdentifier
	);
	$suffix = $commit->getCommitIdentifier();

	if ($commit->getRepository()->isSVN()) {
	foreach ($prefixes as $prefix) {
	if (isset($ids[$prefix.$suffix])) {
	$result[$prefix.$suffix][] = $commit;
	}
	}
	} else {
	// This awkward construction is so we can link the commits up in O(N)
	// time instead of O(N^2).
	for ($ii = $min_qualified; $ii <= strlen($suffix); $ii++) {
	$part = substr($suffix, 0, $ii);
	foreach ($prefixes as $prefix) {
	if (isset($ids[$prefix.$part])) {
	$result[$prefix.$part][] = $commit;
	}
	}
	}
	}
	}
	}

	if ($result) {
	foreach ($result as $identifier => $matching_commits) {
	if (count($matching_commits) == 1) {
	$result[$identifier] = head($matching_commits);
	} else {
	// This reference is ambiguous (it matches more than one commit) so
	// don't link it.
	unset($result[$identifier]);
	}
	}
	$this->identifierMap += $result;
	}

	return $commits;
	}

	protected function didFilterPage(array $commits) {
	if ($this->needCommitData) {
	$data = id(new PhabricatorRepositoryCommitData())->loadAllWhere(
	'commitID in (%Ld)',
	mpull($commits, 'getID'));
	$data = mpull($data, null, 'getCommitID');
	foreach ($commits as $commit) {
	$commit_data = idx($data, $commit->getID());
	if (!$commit_data) {
	$commit_data = new PhabricatorRepositoryCommitData();
	}
	$commit->attachCommitData($commit_data);
	}
	}

	// TODO: This should just be `needAuditRequests`, not `shouldJoinAudits()`,
	// but leave that for a future diff.

	if ($this->needAuditRequests \|\| $this->shouldJoinAudits()) {
	$requests = id(new PhabricatorRepositoryAuditRequest())->loadAllWhere(
	'commitPHID IN (%Ls)',
	mpull($commits, 'getPHID'));

	$requests = mgroup($requests, 'getCommitPHID');
	foreach ($commits as $commit) {
	$audit_requests = idx($requests, $commit->getPHID(), array());
	$commit->attachAudits($audit_requests);
	foreach ($audit_requests as $audit_request) {
	$audit_request->attachCommit($commit);
	}
	}
	}

	return $commits;
	}

	protected function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if ($this->repositoryPHIDs !== null) {
	- $map_repositories = id (new PhabricatorRepositoryQuery())
	+ $map_repositories = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withPHIDs($this->repositoryPHIDs)
	->execute();

	if (!$map_repositories) {
	throw new PhabricatorEmptyQueryException();
	}
	$repository_ids = mpull($map_repositories, 'getID');
	if ($this->repositoryIDs !== null) {
	$repository_ids = array_merge($repository_ids, $this->repositoryIDs);
	}
	$this->withRepositoryIDs($repository_ids);
	}

	if ($this->ids !== null) {
	$where[] = qsprintf(
	$conn_r,
	'commit.id IN (%Ld)',
	$this->ids);
	}

	if ($this->phids !== null) {
	$where[] = qsprintf(
	$conn_r,
	'commit.phid IN (%Ls)',
	$this->phids);
	}

	if ($this->repositoryIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'commit.repositoryID IN (%Ld)',
	$this->repositoryIDs);
	}

	if ($this->authorPHIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'commit.authorPHID IN (%Ls)',
	$this->authorPHIDs);
	}

	if ($this->epochMin !== null) {
	$where[] = qsprintf(
	$conn_r,
	'commit.epoch >= %d',
	$this->epochMin);
	}

	if ($this->epochMax !== null) {
	$where[] = qsprintf(
	$conn_r,
	'commit.epoch <= %d',
	$this->epochMax);
	}

	if ($this->importing !== null) {
	if ($this->importing) {
	$where[] = qsprintf(
	$conn_r,
	'(commit.importStatus & %d) != %d',
	PhabricatorRepositoryCommit::IMPORTED_ALL,
	PhabricatorRepositoryCommit::IMPORTED_ALL);
	} else {
	$where[] = qsprintf(
	$conn_r,
	'(commit.importStatus & %d) = %d',
	PhabricatorRepositoryCommit::IMPORTED_ALL,
	PhabricatorRepositoryCommit::IMPORTED_ALL);
	}
	}

	if ($this->identifiers !== null) {
	$min_unqualified = PhabricatorRepository::MINIMUM_UNQUALIFIED_HASH;
	$min_qualified = PhabricatorRepository::MINIMUM_QUALIFIED_HASH;

	$refs = array();
	$bare = array();
	foreach ($this->identifiers as $identifier) {
	$matches = null;
	preg_match('/^(?:[rR]([A-Z]+:?\|[0-9]+:))?(.*)$/',
	$identifier, $matches);
	$repo = nonempty(rtrim($matches[1], ':'), null);
	$commit_identifier = nonempty($matches[2], null);

	if ($repo === null) {
	if ($this->defaultRepository) {
	$repo = $this->defaultRepository->getCallsign();
	}
	}

	if ($repo === null) {
	if (strlen($commit_identifier) < $min_unqualified) {
	continue;
	}
	$bare[] = $commit_identifier;
	} else {
	$refs[] = array(
	'callsign' => $repo,
	'identifier' => $commit_identifier,
	);
	}
	}

	$sql = array();

	foreach ($bare as $identifier) {
	$sql[] = qsprintf(
	$conn_r,
	'(commit.commitIdentifier LIKE %> AND '.
	'LENGTH(commit.commitIdentifier) = 40)',
	$identifier);
	}

	if ($refs) {
	$callsigns = ipull($refs, 'callsign');

	$repos = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withIdentifiers($callsigns);
	$repos->execute();

	$repos = $repos->getIdentifierMap();

	foreach ($refs as $key => $ref) {
	$repo = idx($repos, $ref['callsign']);

	if (!$repo) {
	continue;
	}

	if ($repo->isSVN()) {
	if (!ctype_digit($ref['identifier'])) {
	continue;
	}
	$sql[] = qsprintf(
	$conn_r,
	'(commit.repositoryID = %d AND commit.commitIdentifier = %s)',
	$repo->getID(),
	// NOTE: Because the 'commitIdentifier' column is a string, MySQL
	// ignores the index if we hand it an integer. Hand it a string.
	// See T3377.
	(int)$ref['identifier']);
	} else {
	if (strlen($ref['identifier']) < $min_qualified) {
	continue;
	}
	$sql[] = qsprintf(
	$conn_r,
	'(commit.repositoryID = %d AND commit.commitIdentifier LIKE %>)',
	$repo->getID(),
	$ref['identifier']);
	}
	}
	}

	if (!$sql) {
	// If we discarded all possible identifiers (e.g., they all referenced
	// bogus repositories or were all too short), make sure the query finds
	// nothing.
	throw new PhabricatorEmptyQueryException(
	pht('No commit identifiers.'));
	}

	$where[] = '('.implode(' OR ', $sql).')';
	}

	if ($this->auditIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'audit.id IN (%Ld)',
	$this->auditIDs);
	}

	if ($this->auditorPHIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'audit.auditorPHID IN (%Ls)',
	$this->auditorPHIDs);
	}

	if ($this->auditAwaitingUser) {
	$awaiting_user_phid = $this->auditAwaitingUser->getPHID();
	// Exclude package and project audits associated with commits where
	// the user is the author.
	$where[] = qsprintf(
	$conn_r,
	'(commit.authorPHID IS NULL OR commit.authorPHID != %s)
	OR (audit.auditorPHID = %s)',
	$awaiting_user_phid,
	$awaiting_user_phid);
	}

	$status = $this->auditStatus;
	if ($status !== null) {
	switch ($status) {
	case self::AUDIT_STATUS_PARTIAL:
	$where[] = qsprintf(
	$conn_r,
	'commit.auditStatus = %d',
	PhabricatorAuditCommitStatusConstants::PARTIALLY_AUDITED);
	break;
	case self::AUDIT_STATUS_ACCEPTED:
	$where[] = qsprintf(
	$conn_r,
	'commit.auditStatus = %d',
	PhabricatorAuditCommitStatusConstants::FULLY_AUDITED);
	break;
	case self::AUDIT_STATUS_CONCERN:
	$where[] = qsprintf(
	$conn_r,
	'audit.auditStatus = %s',
	PhabricatorAuditStatusConstants::CONCERNED);
	break;
	case self::AUDIT_STATUS_OPEN:
	$where[] = qsprintf(
	$conn_r,
	'audit.auditStatus in (%Ls)',
	PhabricatorAuditStatusConstants::getOpenStatusConstants());
	if ($this->auditAwaitingUser) {
	$where[] = qsprintf(
	$conn_r,
	'awaiting.auditStatus IS NULL OR awaiting.auditStatus != %s',
	PhabricatorAuditStatusConstants::RESIGNED);
	}
	break;
	case self::AUDIT_STATUS_ANY:
	break;
	default:
	$valid = array(
	self::AUDIT_STATUS_ANY,
	self::AUDIT_STATUS_OPEN,
	self::AUDIT_STATUS_CONCERN,
	self::AUDIT_STATUS_ACCEPTED,
	self::AUDIT_STATUS_PARTIAL,
	);
	throw new Exception(
	pht(
	"Unknown audit status '%s'! Valid statuses are: %s.",
	$status,
	implode(', ', $valid)));
	}
	}

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}

	protected function didFilterResults(array $filtered) {
	if ($this->identifierMap) {
	foreach ($this->identifierMap as $name => $commit) {
	if (isset($filtered[$commit->getPHID()])) {
	unset($this->identifierMap[$name]);
	}
	}
	}
	}

	protected function buildJoinClause(AphrontDatabaseConnection $conn_r) {
	$joins = array();
	$audit_request = new PhabricatorRepositoryAuditRequest();

	if ($this->shouldJoinAudits()) {
	$joins[] = qsprintf(
	$conn_r,
	'%Q %T audit ON commit.phid = audit.commitPHID',
	($this->rowsMustHaveAudits() ? 'JOIN' : 'LEFT JOIN'),
	$audit_request->getTableName());
	}

	if ($this->auditAwaitingUser) {
	// Join the request table on the awaiting user's requests, so we can
	// filter out package and project requests which the user has resigned
	// from.
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T awaiting ON audit.commitPHID = awaiting.commitPHID AND
	awaiting.auditorPHID = %s',
	$audit_request->getTableName(),
	$this->auditAwaitingUser->getPHID());
	}

	if ($joins) {
	return implode(' ', $joins);
	} else {
	return '';
	}
	}

	protected function buildGroupClause(AphrontDatabaseConnection $conn_r) {
	$should_group = $this->shouldJoinAudits();

	// TODO: Currently, the audit table is missing a unique key, so we may
	// require a GROUP BY if we perform this join. See T1768. This can be
	// removed once the table has the key.
	if ($this->auditAwaitingUser) {
	$should_group = true;
	}

	if ($should_group) {
	return 'GROUP BY commit.id';
	} else {
	return '';
	}
	}

	public function getQueryApplicationClass() {
	return 'PhabricatorDiffusionApplication';
	}

	}
	diff --git a/src/applications/maniphest/conduit/ManiphestUpdateConduitAPIMethod.php b/src/applications/maniphest/conduit/ManiphestUpdateConduitAPIMethod.php
	index ad659af259..d4adee9570 100644
	--- a/src/applications/maniphest/conduit/ManiphestUpdateConduitAPIMethod.php
	+++ b/src/applications/maniphest/conduit/ManiphestUpdateConduitAPIMethod.php
	@@ -1,69 +1,69 @@
	<?php

	final class ManiphestUpdateConduitAPIMethod extends ManiphestConduitAPIMethod {

	public function getAPIMethodName() {
	return 'maniphest.update';
	}

	public function getMethodDescription() {
	return pht('Update an existing Maniphest task.');
	}

	protected function defineErrorTypes() {
	return array(
	'ERR-BAD-TASK' => pht('No such Maniphest task exists.'),
	'ERR-INVALID-PARAMETER' => pht('Missing or malformed parameter.'),
	'ERR-NO-EFFECT' => pht('Update has no effect.'),
	);
	}

	protected function defineParamTypes() {
	return $this->getTaskFields($is_new = false);
	}

	protected function defineReturnType() {
	return 'nonempty dict';
	}

	protected function execute(ConduitAPIRequest $request) {
	$id = $request->getValue('id');
	$phid = $request->getValue('phid');

	if (($id && $phid) \|\| (!$id && !$phid)) {
	throw new Exception(
	pht(
	"Specify exactly one of '%s' and '%s'.",
	'id',
	'phid'));
	}

	- $query = id (new ManiphestTaskQuery())
	+ $query = id(new ManiphestTaskQuery())
	->setViewer($request->getUser())
	->needSubscriberPHIDs(true)
	->needProjectPHIDs(true);
	if ($id) {
	$query->withIDs(array($id));
	} else {
	$query->withPHIDs(array($phid));
	}
	$task = $query->executeOne();

	$params = $request->getAllParameters();
	unset($params['id']);
	unset($params['phid']);

	if (call_user_func_array('coalesce', $params) === null) {
	throw new ConduitException('ERR-NO-EFFECT');
	}

	if (!$task) {
	throw new ConduitException('ERR-BAD-TASK');
	}

	$task = $this->applyRequest($task, $request, $is_new = false);

	return $this->buildTaskInfoDictionary($task);
	}

	}
	diff --git a/src/applications/phame/controller/blog/PhameBlogListController.php b/src/applications/phame/controller/blog/PhameBlogListController.php
	index 6240c129dd..9d0253d89c 100644
	--- a/src/applications/phame/controller/blog/PhameBlogListController.php
	+++ b/src/applications/phame/controller/blog/PhameBlogListController.php
	@@ -1,87 +1,87 @@
	<?php

	final class PhameBlogListController extends PhameController {

	public function handleRequest(AphrontRequest $request) {
	$user = $request->getUser();

	$nav = $this->renderSideNavFilterView(null);
	$filter = $request->getURIData('filter');
	$filter = $nav->selectFilter('blog/'.$filter, 'blog/user');

	$query = id(new PhameBlogQuery())
	->setViewer($user);

	switch ($filter) {
	case 'blog/all':
	$title = pht('All Blogs');
	$nodata = pht('No blogs have been created.');
	break;
	case 'blog/user':
	$title = pht('Joinable Blogs');
	$nodata = pht('There are no blogs you can contribute to.');
	$query->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_JOIN,
	));
	break;
	default:
	throw new Exception(pht("Unknown filter '%s'!", $filter));
	}

	$pager = id(new PHUIPagerView())
	->setURI($request->getRequestURI(), 'offset')
	->setOffset($request->getInt('offset'));

	$blogs = $query->executeWithOffsetPager($pager);

	$blog_list = $this->renderBlogList($blogs, $user, $nodata);
	$blog_list->setPager($pager);

	- $box = id (new PHUIObjectBoxView())
	+ $box = id(new PHUIObjectBoxView())
	->setHeaderText($title)
	->setObjectList($blog_list);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb($title, $this->getApplicationURI());

	$nav->appendChild(
	array(
	$crumbs,
	$box,
	));

	return $this->buildApplicationPage(
	$nav,
	array(
	'title' => $title,
	));
	}

	private function renderBlogList(
	array $blogs,
	PhabricatorUser $viewer,
	$nodata) {

	$view = new PHUIObjectItemListView();
	$view->setNoDataString($nodata);
	$view->setUser($viewer);
	foreach ($blogs as $blog) {

	$id = $blog->getID();
	$item = id(new PHUIObjectItemView())
	->setUser($viewer)
	->setObject($blog)
	->setHeader($blog->getName())
	->setStatusIcon('fa-star')
	->setHref($this->getApplicationURI("/blog/view/{$id}/"))
	->addAttribute($blog->getSkin())
	->addAttribute($blog->getDomain());

	$view->addItem($item);
	}

	return $view;
	}

	}
	diff --git a/src/applications/ponder/controller/PonderQuestionEditController.php b/src/applications/ponder/controller/PonderQuestionEditController.php
	index 23e15625a2..cf8b5f9de1 100644
	--- a/src/applications/ponder/controller/PonderQuestionEditController.php
	+++ b/src/applications/ponder/controller/PonderQuestionEditController.php
	@@ -1,178 +1,178 @@
	<?php

	final class PonderQuestionEditController extends PonderController {

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getViewer();
	$id = $request->getURIData('id');

	if ($id) {
	$question = id(new PonderQuestionQuery())
	->setViewer($viewer)
	->withIDs(array($id))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$question) {
	return new Aphront404Response();
	}
	$v_projects = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$question->getPHID(),
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	$v_projects = array_reverse($v_projects);
	} else {
	$question = PonderQuestion::initializeNewQuestion($viewer);
	$v_projects = array();
	}

	$v_title = $question->getTitle();
	$v_content = $question->getContent();
	$v_view = $question->getViewPolicy();
	$v_edit = $question->getEditPolicy();
	$v_space = $question->getSpacePHID();

	$errors = array();
	$e_title = true;
	if ($request->isFormPost()) {
	$v_title = $request->getStr('title');
	$v_content = $request->getStr('content');
	$v_projects = $request->getArr('projects');
	$v_view = $request->getStr('viewPolicy');
	$v_edit = $request->getStr('editPolicy');
	$v_space = $request->getStr('spacePHID');

	$len = phutil_utf8_strlen($v_title);
	if ($len < 1) {
	$errors[] = pht('Title must not be empty.');
	$e_title = pht('Required');
	} else if ($len > 255) {
	$errors[] = pht('Title is too long.');
	$e_title = pht('Too Long');
	}

	if (!$errors) {
	$template = id(new PonderQuestionTransaction());
	$xactions = array();

	$xactions[] = id(clone $template)
	->setTransactionType(PonderQuestionTransaction::TYPE_TITLE)
	->setNewValue($v_title);

	$xactions[] = id(clone $template)
	->setTransactionType(PonderQuestionTransaction::TYPE_CONTENT)
	->setNewValue($v_content);

	$xactions[] = id(clone $template)
	->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
	->setNewValue($v_view);

	$xactions[] = id(clone $template)
	->setTransactionType(PhabricatorTransactions::TYPE_EDIT_POLICY)
	->setNewValue($v_edit);

	$xactions[] = id(clone $template)
	->setTransactionType(PhabricatorTransactions::TYPE_SPACE)
	->setNewValue($v_space);

	$proj_edge_type = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;
	$xactions[] = id(new PonderQuestionTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $proj_edge_type)
	->setNewValue(array('=' => array_fuse($v_projects)));

	$editor = id(new PonderQuestionEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true);

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

	return id(new AphrontRedirectResponse())
	->setURI('/Q'.$question->getID());
	}
	}

	$policies = id(new PhabricatorPolicyQuery())
	->setViewer($viewer)
	->setObject($question)
	->execute();

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Question'))
	->setName('title')
	->setValue($v_title)
	->setError($e_title))
	->appendChild(
	id(new PhabricatorRemarkupControl())
	->setUser($viewer)
	->setName('content')
	->setID('content')
	->setValue($v_content)
	->setLabel(pht('Description'))
	->setUser($viewer))
	->appendControl(
	id(new AphrontFormPolicyControl())
	->setName('viewPolicy')
	->setPolicyObject($question)
	->setSpacePHID($v_space)
	->setPolicies($policies)
	->setValue($v_view)
	->setCapability(PhabricatorPolicyCapability::CAN_VIEW))
	->appendControl(
	id(new AphrontFormPolicyControl())
	->setName('editPolicy')
	->setPolicyObject($question)
	->setPolicies($policies)
	->setValue($v_edit)
	->setCapability(PhabricatorPolicyCapability::CAN_EDIT));

	$form->appendControl(
	id(new AphrontFormTokenizerControl())
	->setLabel(pht('Projects'))
	->setName('projects')
	->setValue($v_projects)
	->setDatasource(new PhabricatorProjectDatasource()));

	- $form ->appendChild(
	+ $form->appendChild(
	id(new AphrontFormSubmitControl())
	->addCancelButton($this->getApplicationURI())
	->setValue(pht('Ask Away!')));

	$preview = id(new PHUIRemarkupPreviewPanel())
	->setHeader(pht('Question Preview'))
	->setControlID('content')
	->setPreviewURI($this->getApplicationURI('preview/'));

	$form_box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Ask New Question'))
	->setFormErrors($errors)
	->setForm($form);

	$crumbs = $this->buildApplicationCrumbs();

	$id = $question->getID();
	if ($id) {
	$crumbs->addTextCrumb("Q{$id}", "/Q{$id}");
	$crumbs->addTextCrumb(pht('Edit'));
	} else {
	$crumbs->addTextCrumb(pht('Ask Question'));
	}

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$form_box,
	$preview,
	),
	array(
	'title' => pht('Ask New Question'),
	));
	}

	}
	diff --git a/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php b/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php
	index f5c936539e..896c52276f 100644
	--- a/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php
	+++ b/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php
	@@ -1,382 +1,382 @@
	<?php

	abstract class PhabricatorObjectRemarkupRule extends PhutilRemarkupRule {

	const KEY_RULE_OBJECT = 'rule.object';
	const KEY_MENTIONED_OBJECTS = 'rule.object.mentioned';

	abstract protected function getObjectNamePrefix();
	abstract protected function loadObjects(array $ids);

	public function getPriority() {
	return 450.0;
	}

	protected function getObjectNamePrefixBeginsWithWordCharacter() {
	$prefix = $this->getObjectNamePrefix();
	return preg_match('/^\w/', $prefix);
	}

	protected function getObjectIDPattern() {
	return '[1-9]\d*';
	}

	protected function shouldMarkupObject(array $params) {
	return true;
	}

	protected function loadHandles(array $objects) {
	$phids = mpull($objects, 'getPHID');

	$viewer = $this->getEngine()->getConfig('viewer');
	$handles = $viewer->loadHandles($phids);
	$handles = iterator_to_array($handles);

	$result = array();
	foreach ($objects as $id => $object) {
	$result[$id] = $handles[$object->getPHID()];
	}
	return $result;
	}

	protected function getObjectHref(
	$object,
	PhabricatorObjectHandle $handle,
	$id) {

	$uri = $handle->getURI();

	if ($this->getEngine()->getConfig('uri.full')) {
	$uri = PhabricatorEnv::getURI($uri);
	}

	return $uri;
	}

	- protected function renderObjectRefForAnyMedia (
	+ protected function renderObjectRefForAnyMedia(
	$object,
	PhabricatorObjectHandle $handle,
	$anchor,
	$id) {

	$href = $this->getObjectHref($object, $handle, $id);
	$text = $this->getObjectNamePrefix().$id;

	if ($anchor) {
	$href = $href.'#'.$anchor;
	$text = $text.'#'.$anchor;
	}

	if ($this->getEngine()->isTextMode()) {
	return PhabricatorEnv::getProductionURI($href);
	} else if ($this->getEngine()->isHTMLMailMode()) {
	$href = PhabricatorEnv::getProductionURI($href);
	return $this->renderObjectTagForMail($text, $href, $handle);
	}

	return $this->renderObjectRef($object, $handle, $anchor, $id);

	}

	protected function renderObjectRef(
	$object,
	PhabricatorObjectHandle $handle,
	$anchor,
	$id) {

	$href = $this->getObjectHref($object, $handle, $id);
	$text = $this->getObjectNamePrefix().$id;
	$status_closed = PhabricatorObjectHandle::STATUS_CLOSED;

	if ($anchor) {
	$href = $href.'#'.$anchor;
	$text = $text.'#'.$anchor;
	}

	$attr = array(
	'phid' => $handle->getPHID(),
	'closed' => ($handle->getStatus() == $status_closed),
	);

	return $this->renderHovertag($text, $href, $attr);
	}

	protected function renderObjectEmbedForAnyMedia(
	$object,
	PhabricatorObjectHandle $handle,
	$options) {

	$name = $handle->getFullName();
	$href = $handle->getURI();

	if ($this->getEngine()->isTextMode()) {
	return $name.' <'.PhabricatorEnv::getProductionURI($href).'>';
	} else if ($this->getEngine()->isHTMLMailMode()) {
	$href = PhabricatorEnv::getProductionURI($href);
	return $this->renderObjectTagForMail($name, $href, $handle);
	}

	return $this->renderObjectEmbed($object, $handle, $options);
	}

	protected function renderObjectEmbed(
	$object,
	PhabricatorObjectHandle $handle,
	$options) {

	$name = $handle->getFullName();
	$href = $handle->getURI();
	$status_closed = PhabricatorObjectHandle::STATUS_CLOSED;
	$attr = array(
	'phid' => $handle->getPHID(),
	'closed' => ($handle->getStatus() == $status_closed),
	);

	return $this->renderHovertag($name, $href, $attr);
	}

	protected function renderObjectTagForMail(
	$text,
	$href,
	PhabricatorObjectHandle $handle) {

	$status_closed = PhabricatorObjectHandle::STATUS_CLOSED;
	$strikethrough = $handle->getStatus() == $status_closed ?
	'text-decoration: line-through;' :
	'text-decoration: none;';

	return phutil_tag(
	'a',
	array(
	'href' => $href,
	'style' => 'background-color: #e7e7e7;
	border-color: #e7e7e7;
	border-radius: 3px;
	padding: 0 4px;
	font-weight: bold;
	color: black;'
	.$strikethrough,
	),
	$text);
	}

	protected function renderHovertag($name, $href, array $attr = array()) {
	return id(new PHUITagView())
	->setName($name)
	->setHref($href)
	->setType(PHUITagView::TYPE_OBJECT)
	->setPHID(idx($attr, 'phid'))
	->setClosed(idx($attr, 'closed'))
	->render();
	}

	public function apply($text) {
	$text = preg_replace_callback(
	$this->getObjectEmbedPattern(),
	array($this, 'markupObjectEmbed'),
	$text);

	$text = preg_replace_callback(
	$this->getObjectReferencePattern(),
	array($this, 'markupObjectReference'),
	$text);

	return $text;
	}

	private function getObjectEmbedPattern() {
	$prefix = $this->getObjectNamePrefix();
	$prefix = preg_quote($prefix);
	$id = $this->getObjectIDPattern();

	return '(\B{'.$prefix.'('.$id.')([,\s](?:[^}\\\\]\|\\\\.)*)?}\B)u';
	}

	private function getObjectReferencePattern() {
	$prefix = $this->getObjectNamePrefix();
	$prefix = preg_quote($prefix);

	$id = $this->getObjectIDPattern();

	// If the prefix starts with a word character (like "D"), we want to
	// require a word boundary so that we don't match "XD1" as "D1". If the
	// prefix does not start with a word character, we want to require no word
	// boundary for the same reasons. Test if the prefix starts with a word
	// character.
	if ($this->getObjectNamePrefixBeginsWithWordCharacter()) {
	$boundary = '\\b';
	} else {
	$boundary = '\\B';
	}

	// The "(?<![#-])" prevents us from linking "#abcdef" or similar, and
	// "ABC-T1" (see T5714).

	// The "\b" allows us to link "(abcdef)" or similar without linking things
	// in the middle of words.

	return '((?<![#-])'.$boundary.$prefix.'('.$id.')(?:#([-\w\d]+))?(?!\w))u';
	}


	/**
	* Extract matched object references from a block of text.
	*
	* This is intended to make it easy to write unit tests for object remarkup
	* rules. Production code is not normally expected to call this method.
	*
	* @param string Text to match rules against.
	* @return wild Matches, suitable for writing unit tests against.
	*/
	public function extractReferences($text) {
	$embed_matches = null;
	preg_match_all(
	$this->getObjectEmbedPattern(),
	$text,
	$embed_matches,
	PREG_OFFSET_CAPTURE \| PREG_SET_ORDER);

	$ref_matches = null;
	preg_match_all(
	$this->getObjectReferencePattern(),
	$text,
	$ref_matches,
	PREG_OFFSET_CAPTURE \| PREG_SET_ORDER);

	$results = array();
	$sets = array(
	'embed' => $embed_matches,
	'ref' => $ref_matches,
	);
	foreach ($sets as $type => $matches) {
	$formatted = array();
	foreach ($matches as $match) {
	$format = array(
	'offset' => $match[1][1],
	'id' => $match[1][0],
	);
	if (isset($match[2][0])) {
	$format['tail'] = $match[2][0];
	}
	$formatted[] = $format;
	}
	$results[$type] = $formatted;
	}

	return $results;
	}

	public function markupObjectEmbed(array $matches) {
	if (!$this->isFlatText($matches[0])) {
	return $matches[0];
	}

	return $this->markupObject(array(
	'type' => 'embed',
	'id' => $matches[1],
	'options' => idx($matches, 2),
	'original' => $matches[0],
	));
	}

	public function markupObjectReference(array $matches) {
	if (!$this->isFlatText($matches[0])) {
	return $matches[0];
	}

	return $this->markupObject(array(
	'type' => 'ref',
	'id' => $matches[1],
	'anchor' => idx($matches, 2),
	'original' => $matches[0],
	));
	}

	private function markupObject(array $params) {
	if (!$this->shouldMarkupObject($params)) {
	return $params['original'];
	}

	$regex = trim(
	PhabricatorEnv::getEnvConfig('remarkup.ignored-object-names'));
	if ($regex && preg_match($regex, $params['original'])) {
	return $params['original'];
	}

	$engine = $this->getEngine();
	$token = $engine->storeText('x');

	$metadata_key = self::KEY_RULE_OBJECT.'.'.$this->getObjectNamePrefix();
	$metadata = $engine->getTextMetadata($metadata_key, array());

	$metadata[] = array(
	'token' => $token,
	) + $params;

	$engine->setTextMetadata($metadata_key, $metadata);

	return $token;
	}

	public function didMarkupText() {
	$engine = $this->getEngine();
	$metadata_key = self::KEY_RULE_OBJECT.'.'.$this->getObjectNamePrefix();
	$metadata = $engine->getTextMetadata($metadata_key, array());

	if (!$metadata) {
	return;
	}


	$ids = ipull($metadata, 'id');
	$objects = $this->loadObjects($ids);

	// For objects that are invalid or which the user can't see, just render
	// the original text.

	// TODO: We should probably distinguish between these cases and render a
	// "you can't see this" state for nonvisible objects.

	foreach ($metadata as $key => $spec) {
	if (empty($objects[$spec['id']])) {
	$engine->overwriteStoredText(
	$spec['token'],
	$spec['original']);
	unset($metadata[$key]);
	}
	}

	$phids = $engine->getTextMetadata(self::KEY_MENTIONED_OBJECTS, array());
	foreach ($objects as $object) {
	$phids[$object->getPHID()] = $object->getPHID();
	}
	$engine->setTextMetadata(self::KEY_MENTIONED_OBJECTS, $phids);

	$handles = $this->loadHandles($objects);
	foreach ($metadata as $key => $spec) {
	$handle = $handles[$spec['id']];
	$object = $objects[$spec['id']];
	switch ($spec['type']) {
	case 'ref':

	$view = $this->renderObjectRefForAnyMedia(
	$object,
	$handle,
	$spec['anchor'],
	$spec['id']);
	break;
	case 'embed':
	$spec['options'] = $this->assertFlatText($spec['options']);
	$view = $this->renderObjectEmbedForAnyMedia(
	$object,
	$handle,
	$spec['options']);
	break;
	}
	$engine->overwriteStoredText($spec['token'], $view);
	}

	$engine->setTextMetadata($metadata_key, array());
	}

	}
	diff --git a/src/view/phui/calendar/PHUICalendarMonthView.php b/src/view/phui/calendar/PHUICalendarMonthView.php
	index 06d15bbcc9..0308f542e5 100644
	--- a/src/view/phui/calendar/PHUICalendarMonthView.php
	+++ b/src/view/phui/calendar/PHUICalendarMonthView.php
	@@ -1,598 +1,598 @@
	<?php

	final class PHUICalendarMonthView extends AphrontView {
	private $rangeStart;
	private $rangeEnd;

	private $day;
	private $month;
	private $year;
	private $events = array();
	private $browseURI;
	private $image;
	private $error;

	public function setBrowseURI($browse_uri) {
	$this->browseURI = $browse_uri;
	return $this;
	}
	private function getBrowseURI() {
	return $this->browseURI;
	}

	public function addEvent(AphrontCalendarEventView $event) {
	$this->events[] = $event;
	return $this;
	}

	public function setImage($uri) {
	$this->image = $uri;
	return $this;
	}

	public function setInfoView(PHUIInfoView $error) {
	$this->error = $error;
	return $this;
	}

	public function __construct(
	$range_start,
	$range_end,
	$month,
	$year,
	$day = null) {

	$this->rangeStart = $range_start;
	$this->rangeEnd = $range_end;

	$this->day = $day;
	$this->month = $month;
	$this->year = $year;
	}

	public function render() {
	if (empty($this->user)) {
	throw new PhutilInvalidStateException('setUser');
	}

	$events = msort($this->events, 'getEpochStart');
	$days = $this->getDatesInMonth();

	$cell_lists = array();

	require_celerity_resource('phui-calendar-month-css');

	foreach ($days as $day) {
	$day_number = $day->format('j');

	$class = 'phui-calendar-month-day';
	$weekday = $day->format('w');

	$day->setTime(0, 0, 0);
	$day_start_epoch = $day->format('U');
	$day_end_epoch = id(clone $day)->modify('+1 day')->format('U');

	$list_events = array();
	$all_day_events = array();

	foreach ($events as $event) {
	if ($event->getEpochStart() >= $day_end_epoch) {
	break;
	}
	if ($event->getEpochStart() < $day_end_epoch &&
	$event->getEpochEnd() > $day_start_epoch) {
	if ($event->getIsAllDay()) {
	$all_day_events[] = $event;
	} else {
	$list_events[] = $event;
	}
	}
	}

	$max_daily = 15;
	$counter = 0;

	$list = new PHUICalendarListView();
	$list->setUser($this->user);
	foreach ($all_day_events as $item) {
	if ($counter <= $max_daily) {
	$list->addEvent($item);
	}
	$counter++;
	}
	foreach ($list_events as $item) {
	if ($counter <= $max_daily) {
	$list->addEvent($item);
	}
	$counter++;
	}

	$uri = $this->getBrowseURI();
	$uri = $uri.$day->format('Y').'/'.
	$day->format('m').'/'.
	$day->format('d').'/';

	$cell_lists[] = array(
	'list' => $list,
	'date' => $day,
	'uri' => $uri,
	'count' => count($all_day_events) + count($list_events),
	'class' => $class,
	);
	}

	$rows = array();
	$cell_lists_by_week = array_chunk($cell_lists, 7);

	foreach ($cell_lists_by_week as $week_of_cell_lists) {
	$cells = array();
	$max_count = $this->getMaxDailyEventsForWeek($week_of_cell_lists);

	foreach ($week_of_cell_lists as $cell_list) {
	$cells[] = $this->getEventListCell($cell_list, $max_count);
	}
	$rows[] = phutil_tag('tr', array(), $cells);

	$cells = array();
	foreach ($week_of_cell_lists as $cell_list) {
	$cells[] = $this->getDayNumberCell($cell_list);
	}
	$rows[] = phutil_tag('tr', array(), $cells);
	}

	$header = $this->getDayNamesHeader();

	$table = phutil_tag(
	'table',
	array('class' => 'phui-calendar-view'),
	array(
	$header,
	$rows,
	));

	$warnings = $this->getQueryRangeWarning();

	$box = id(new PHUIObjectBoxView())
	->setHeader($this->renderCalendarHeader($this->getDateTime()))
	->appendChild($table)
	->setFormErrors($warnings);
	if ($this->error) {
	$box->setInfoView($this->error);

	}

	return $box;
	}

	private function getMaxDailyEventsForWeek($week_of_cell_lists) {
	$max_count = 0;

	foreach ($week_of_cell_lists as $cell_list) {
	if ($cell_list['count'] > $max_count) {
	$max_count = $cell_list['count'];
	}
	}

	return $max_count;
	}

	private function getEventListCell($event_list, $max_count = 0) {
	$list = $event_list['list'];
	$class = $event_list['class'];
	$uri = $event_list['uri'];
	$count = $event_list['count'];

	$viewer_is_invited = $list->getIsViewerInvitedOnList();

	$event_count_badge = $this->getEventCountBadge($count, $viewer_is_invited);
	$cell_day_secret_link = $this->getHiddenDayLink($uri, $max_count, 125);

	$cell_data_div = phutil_tag(
	'div',
	array(
	'class' => 'phui-calendar-month-cell-div',
	),
	array(
	$cell_day_secret_link,
	$event_count_badge,
	$list,
	));

	return phutil_tag(
	'td',
	array(
	'class' => 'phui-calendar-month-event-list '.$class,
	),
	$cell_data_div);
	}

	private function getDayNumberCell($event_list) {
	$class = $event_list['class'];
	$date = $event_list['date'];
	$cell_day_secret_link = null;
	$week_number = null;

	if ($date) {
	$uri = $event_list['uri'];
	$cell_day_secret_link = $this->getHiddenDayLink($uri, 0, 25);

	$cell_day = phutil_tag(
	'a',
	array(
	'class' => 'phui-calendar-date-number',
	'href' => $uri,
	),
	$date->format('j'));

	if ($date->format('w') == 1) {
	$week_number = phutil_tag(
	'a',
	array(
	'class' => 'phui-calendar-week-number',
	'href' => $uri,
	),
	$date->format('W'));
	}
	} else {
	$cell_day = null;
	}

	if ($date && $date->format('j') == $this->day &&
	$date->format('m') == $this->month) {
	$today_class = 'phui-calendar-today-slot phui-calendar-today';
	} else {
	$today_class = 'phui-calendar-today-slot';
	}

	if ($this->isDateInCurrentWeek($date)) {
	$today_class .= ' phui-calendar-this-week';
	}

	$last_week_day = 6;
	if ($date->format('w') == $last_week_day) {
	$today_class .= ' last-weekday';
	}

	- $today_slot = phutil_tag (
	+ $today_slot = phutil_tag(
	'div',
	array(
	'class' => $today_class,
	),
	null);

	$cell_div = phutil_tag(
	'div',
	array(
	'class' => 'phui-calendar-month-cell-div',
	),
	array(
	$cell_day_secret_link,
	$week_number,
	$cell_day,
	$today_slot,
	));

	return phutil_tag(
	'td',
	array(
	'class' => 'phui-calendar-date-number-container '.$class,
	),
	$cell_div);
	}

	private function isDateInCurrentWeek($date) {
	list($week_start_date, $week_end_date) = $this->getThisWeekRange();

	if ($date->format('U') < $week_end_date->format('U') &&
	$date->format('U') >= $week_start_date->format('U')) {
	return true;
	}
	return false;
	}

	private function getEventCountBadge($count, $viewer_is_invited) {
	$class = 'phui-calendar-month-count-badge';

	if ($viewer_is_invited) {
	$class = $class.' viewer-invited-day-badge';
	}

	$event_count = null;
	if ($count > 0) {
	$event_count = phutil_tag(
	'div',
	array(
	'class' => $class,
	),
	$count);
	}

	return phutil_tag(
	'div',
	array(
	'class' => 'phui-calendar-month-event-count',
	),
	$event_count);
	}

	private function getHiddenDayLink($uri, $count, $max_height) {
	// approximately the height of the tallest cell
	$height = 18 * $count + 5;
	$height = ($height > $max_height) ? $height : $max_height;
	$height_style = 'height: '.$height.'px';
	return phutil_tag(
	'a',
	array(
	'class' => 'phui-calendar-month-secret-link',
	'style' => $height_style,
	'href' => $uri,
	),
	null);
	}

	private function getDayNamesHeader() {
	list($week_start, $week_end) = $this->getWeekStartAndEnd();

	$weekday_names = array(
	$this->getDayHeader(pht('Sun'), pht('Sunday'), true),
	$this->getDayHeader(pht('Mon'), pht('Monday')),
	$this->getDayHeader(pht('Tue'), pht('Tuesday')),
	$this->getDayHeader(pht('Wed'), pht('Wednesday')),
	$this->getDayHeader(pht('Thu'), pht('Thursday')),
	$this->getDayHeader(pht('Fri'), pht('Friday')),
	$this->getDayHeader(pht('Sat'), pht('Saturday'), true),
	);

	$sorted_weekday_names = array();

	for ($i = $week_start; $i < ($week_start + 7); $i++) {
	$sorted_weekday_names[] = $weekday_names[$i % 7];
	}

	return phutil_tag(
	'tr',
	array('class' => 'phui-calendar-day-of-week-header'),
	$sorted_weekday_names);
	}

	private function getDayHeader($short, $long, $is_weekend = false) {
	$class = null;
	if ($is_weekend) {
	$class = 'weekend-day-header';
	}
	$day = array();
	$day[] = phutil_tag(
	'span',
	array(
	'class' => 'long-weekday-name',
	),
	$long);
	$day[] = phutil_tag(
	'span',
	array(
	'class' => 'short-weekday-name',
	),
	$short);
	return phutil_tag(
	'th',
	array(
	'class' => $class,
	),
	$day);
	}

	private function renderCalendarHeader(DateTime $date) {
	$button_bar = null;

	// check for a browseURI, which means we need "fancy" prev / next UI
	$uri = $this->getBrowseURI();
	if ($uri) {
	list($prev_year, $prev_month) = $this->getPrevYearAndMonth();
	$prev_uri = $uri.$prev_year.'/'.$prev_month.'/';

	list($next_year, $next_month) = $this->getNextYearAndMonth();
	$next_uri = $uri.$next_year.'/'.$next_month.'/';

	$button_bar = new PHUIButtonBarView();

	$left_icon = id(new PHUIIconView())
	->setIconFont('fa-chevron-left bluegrey');
	$left = id(new PHUIButtonView())
	->setTag('a')
	->setColor(PHUIButtonView::GREY)
	->setHref($prev_uri)
	->setTitle(pht('Previous Month'))
	->setIcon($left_icon);

	$right_icon = id(new PHUIIconView())
	->setIconFont('fa-chevron-right bluegrey');
	$right = id(new PHUIButtonView())
	->setTag('a')
	->setColor(PHUIButtonView::GREY)
	->setHref($next_uri)
	->setTitle(pht('Next Month'))
	->setIcon($right_icon);

	$button_bar->addButton($left);
	$button_bar->addButton($right);

	}

	$header = id(new PHUIHeaderView())
	->setHeader($date->format('F Y'));

	if ($button_bar) {
	$header->setButtonBar($button_bar);
	}

	if ($this->image) {
	$header->setImage($this->image);
	}

	return $header;
	}

	private function getQueryRangeWarning() {
	$errors = array();

	$range_start_epoch = null;
	$range_end_epoch = null;

	if ($this->rangeStart) {
	$range_start_epoch = $this->rangeStart->getEpoch();
	}
	if ($this->rangeEnd) {
	$range_end_epoch = $this->rangeEnd->getEpoch();
	}

	$month_start = $this->getDateTime();
	$month_end = id(clone $month_start)->modify('+1 month');

	$month_start = $month_start->format('U');
	$month_end = $month_end->format('U') - 1;

	if (($range_start_epoch != null &&
	$range_start_epoch < $month_end &&
	$range_start_epoch > $month_start) \|\|
	($range_end_epoch != null &&
	$range_end_epoch < $month_end &&
	$range_end_epoch > $month_start)) {
	$errors[] = pht('Part of the month is out of range');
	}

	if (($range_end_epoch != null &&
	$range_end_epoch < $month_start) \|\|
	($range_start_epoch != null &&
	$range_start_epoch > $month_end)) {
	$errors[] = pht('Month is out of query range');
	}

	return $errors;
	}

	private function getNextYearAndMonth() {
	$next = $this->getDateTime();
	$next->modify('+1 month');
	return array(
	$next->format('Y'),
	$next->format('m'),
	);
	}

	private function getPrevYearAndMonth() {
	$prev = $this->getDateTime();
	$prev->modify('-1 month');
	return array(
	$prev->format('Y'),
	$prev->format('m'),
	);
	}

	/**
	* Return a DateTime object representing the first moment in each day in the
	* month, according to the user's locale.
	*
	* @return list List of DateTimes, one for each day.
	*/
	private function getDatesInMonth() {
	$user = $this->user;

	$timezone = new DateTimeZone($user->getTimezoneIdentifier());

	$month = $this->month;
	$year = $this->year;

	list($next_year, $next_month) = $this->getNextYearAndMonth();

	$end_date = new DateTime("{$next_year}-{$next_month}-01", $timezone);

	list($start_of_week, $end_of_week) = $this->getWeekStartAndEnd();

	$days_in_month = id(clone $end_date)->modify('-1 day')->format('d');

	$first_month_day_date = new DateTime("{$year}-{$month}-01", $timezone);
	$last_month_day_date = id(clone $end_date)->modify('-1 day');

	$first_weekday_of_month = $first_month_day_date->format('w');
	$last_weekday_of_month = $last_month_day_date->format('w');

	$day_date = id(clone $first_month_day_date);

	$num_days_display = $days_in_month;
	if ($start_of_week !== $first_weekday_of_month) {
	$interim_start_num = ($first_weekday_of_month + 7 - $start_of_week) % 7;
	$num_days_display += $interim_start_num;

	$day_date->modify('-'.$interim_start_num.' days');
	}
	if ($end_of_week !== $last_weekday_of_month) {
	$interim_end_day_num = ($end_of_week - $last_weekday_of_month + 7) % 7;
	$num_days_display += $interim_end_day_num;
	$end_date->modify('+'.$interim_end_day_num.' days');
	}

	$days = array();

	for ($day = 1; $day <= $num_days_display; $day++) {
	$day_epoch = $day_date->format('U');
	$end_epoch = $end_date->format('U');
	if ($day_epoch >= $end_epoch) {
	break;
	} else {
	$days[] = clone $day_date;
	}
	$day_date->modify('+1 day');
	}

	return $days;
	}

	private function getTodayMidnight() {
	$viewer = $this->getUser();
	$today = new DateTime('@'.time());
	$today->setTimeZone($viewer->getTimeZone());
	$today->setTime(0, 0, 0);

	return $today;
	}

	private function getThisWeekRange() {
	list($week_start, $week_end) = $this->getWeekStartAndEnd();

	$today = $this->getTodayMidnight();
	$date_weekday = $today->format('w');

	$days_from_week_start = ($date_weekday + 7 - $week_start) % 7;
	$days_to_week_end = 7 - $days_from_week_start;

	$modify = '-'.$days_from_week_start.' days';
	$week_start_date = id(clone $today)->modify($modify);

	$modify = '+'.$days_to_week_end.' days';
	$week_end_date = id(clone $today)->modify($modify);

	return array($week_start_date, $week_end_date);
	}

	private function getWeekStartAndEnd() {
	$preferences = $this->user->loadPreferences();
	$pref_week_start = PhabricatorUserPreferences::PREFERENCE_WEEK_START_DAY;

	$week_start = $preferences->getPreference($pref_week_start, 0);
	$week_end = ($week_start + 6) % 7;

	return array($week_start, $week_end);
	}

	private function getDateTime() {
	$user = $this->user;
	$timezone = new DateTimeZone($user->getTimezoneIdentifier());

	$month = $this->month;
	$year = $this->year;

	$date = new DateTime("{$year}-{$month}-01 ", $timezone);

	return $date;
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 3, 1:30 PM (2 h, 57 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 165818
Default Alt Text: (92 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions