No OneTemporary
Actions

Size

147 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/console/plugin/DarkConsoleEventPlugin.php b/src/applications/console/plugin/DarkConsoleEventPlugin.php
	index 070227c12d..182e220659 100644
	--- a/src/applications/console/plugin/DarkConsoleEventPlugin.php
	+++ b/src/applications/console/plugin/DarkConsoleEventPlugin.php
	@@ -1,95 +1,95 @@
	<?php

	final class DarkConsoleEventPlugin extends DarkConsolePlugin {

	public function getName() {
	return pht('Events');
	}

	public function getDescription() {
	- return pht('Information about Phabricator events and event listeners.');
	+ return pht('Information about events and event listeners.');
	}

	public function generateData() {
	$listeners = PhutilEventEngine::getInstance()->getAllListeners();
	foreach ($listeners as $key => $listener) {
	$listeners[$key] = array(
	'id' => $listener->getListenerID(),
	'class' => get_class($listener),
	);
	}

	$events = DarkConsoleEventPluginAPI::getEvents();
	foreach ($events as $key => $event) {
	$events[$key] = array(
	'type' => $event->getType(),
	'stopped' => $event->isStopped(),
	);
	}

	return array(
	'listeners' => $listeners,
	'events' => $events,
	);
	}

	public function renderPanel() {
	$data = $this->getData();

	$out = array();

	$out[] = phutil_tag(
	'div',
	array('class' => 'dark-console-panel-header'),
	phutil_tag('h1', array(), pht('Registered Event Listeners')));

	$rows = array();
	foreach ($data['listeners'] as $listener) {
	$rows[] = array($listener['id'], $listener['class']);
	}

	$table = new AphrontTableView($rows);
	$table->setHeaders(
	array(
	pht('Internal ID'),
	pht('Listener Class'),
	));
	$table->setColumnClasses(
	array(
	'',
	'wide',
	));

	$out[] = $table->render();

	$out[] = phutil_tag(
	'div',
	array('class' => 'dark-console-panel-header'),
	phutil_tag('h1', array(), pht('Event Log')));

	$rows = array();
	foreach ($data['events'] as $event) {
	$rows[] = array(
	$event['type'],
	$event['stopped'] ? pht('STOPPED') : null,
	);
	}

	$table = new AphrontTableView($rows);
	$table->setColumnClasses(
	array(
	'wide',
	));
	$table->setHeaders(
	array(
	pht('Event Type'),
	pht('Stopped'),
	));

	$out[] = $table->render();


	return phutil_implode_html("\n", $out);
	}

	}
	diff --git a/src/applications/daemon/application/PhabricatorDaemonsApplication.php b/src/applications/daemon/application/PhabricatorDaemonsApplication.php
	index 08e81d5d7e..3aa6b2f086 100644
	--- a/src/applications/daemon/application/PhabricatorDaemonsApplication.php
	+++ b/src/applications/daemon/application/PhabricatorDaemonsApplication.php
	@@ -1,61 +1,61 @@
	<?php

	final class PhabricatorDaemonsApplication extends PhabricatorApplication {

	public function getName() {
	return pht('Daemons');
	}

	public function getShortDescription() {
	- return pht('Manage Phabricator Daemons');
	+ return pht('Manage Daemons');
	}

	public function getBaseURI() {
	return '/daemon/';
	}

	public function getTitleGlyph() {
	return "\xE2\x98\xAF";
	}

	public function getIcon() {
	return 'fa-pied-piper-alt';
	}

	public function getApplicationGroup() {
	return self::GROUP_ADMIN;
	}

	public function canUninstall() {
	return false;
	}

	public function getEventListeners() {
	return array(
	new PhabricatorDaemonEventListener(),
	);
	}

	public function getRoutes() {
	return array(
	'/daemon/' => array(
	'' => 'PhabricatorDaemonConsoleController',
	'task/(?P<id>[1-9]\d*)/' => 'PhabricatorWorkerTaskDetailController',
	'log/' => array(
	'' => 'PhabricatorDaemonLogListController',
	'(?P<id>[1-9]\d*)/' => 'PhabricatorDaemonLogViewController',
	),
	'bulk/' => array(
	'(?:query/(?P<queryKey>[^/]+)/)?' =>
	'PhabricatorDaemonBulkJobListController',
	'monitor/(?P<id>\d+)/' =>
	'PhabricatorDaemonBulkJobMonitorController',
	'view/(?P<id>\d+)/' =>
	'PhabricatorDaemonBulkJobViewController',

	),
	),
	);
	}

	}
	diff --git a/src/applications/daemon/management/PhabricatorDaemonManagementWorkflow.php b/src/applications/daemon/management/PhabricatorDaemonManagementWorkflow.php
	index b9645323c2..853a797448 100644
	--- a/src/applications/daemon/management/PhabricatorDaemonManagementWorkflow.php
	+++ b/src/applications/daemon/management/PhabricatorDaemonManagementWorkflow.php
	@@ -1,611 +1,611 @@
	<?php

	abstract class PhabricatorDaemonManagementWorkflow
	extends PhabricatorManagementWorkflow {

	private $runDaemonsAsUser = null;

	final protected function loadAvailableDaemonClasses() {
	return id(new PhutilSymbolLoader())
	->setAncestorClass('PhutilDaemon')
	->setConcreteOnly(true)
	->selectSymbolsWithoutLoading();
	}

	final protected function getLogDirectory() {
	$path = PhabricatorEnv::getEnvConfig('phd.log-directory');
	return $this->getControlDirectory($path);
	}

	private function getControlDirectory($path) {
	if (!Filesystem::pathExists($path)) {
	list($err) = exec_manual('mkdir -p %s', $path);
	if ($err) {
	throw new Exception(
	pht(
	"%s requires the directory '%s' to exist, but it does not exist ".
	"and could not be created. Create this directory or update ".
	"'%s' in your configuration to point to an existing ".
	"directory.",
	'phd',
	$path,
	'phd.log-directory'));
	}
	}
	return $path;
	}

	private function findDaemonClass($substring) {
	$symbols = $this->loadAvailableDaemonClasses();

	$symbols = ipull($symbols, 'name');
	$match = array();
	foreach ($symbols as $symbol) {
	if (stripos($symbol, $substring) !== false) {
	if (strtolower($symbol) == strtolower($substring)) {
	$match = array($symbol);
	break;
	} else {
	$match[] = $symbol;
	}
	}
	}

	if (count($match) == 0) {
	throw new PhutilArgumentUsageException(
	pht(
	"No daemons match '%s'! Use '%s' for a list of available daemons.",
	$substring,
	'phd list'));
	} else if (count($match) > 1) {
	throw new PhutilArgumentUsageException(
	pht(
	"Specify a daemon unambiguously. Multiple daemons match '%s': %s.",
	$substring,
	implode(', ', $match)));
	}

	return head($match);
	}

	final protected function launchDaemons(
	array $daemons,
	$debug,
	$run_as_current_user = false) {

	// Convert any shorthand classnames like "taskmaster" into proper class
	// names.
	foreach ($daemons as $key => $daemon) {
	$class = $this->findDaemonClass($daemon['class']);
	$daemons[$key]['class'] = $class;
	}

	$console = PhutilConsole::getConsole();

	if (!$run_as_current_user) {
	// Check if the script is started as the correct user
	$phd_user = PhabricatorEnv::getEnvConfig('phd.user');
	$current_user = posix_getpwuid(posix_geteuid());
	$current_user = $current_user['name'];
	if ($phd_user && $phd_user != $current_user) {
	if ($debug) {
	throw new PhutilArgumentUsageException(
	pht(
	"You are trying to run a daemon as a nonstandard user, ".
	"and `%s` was not able to `%s` to the correct user. \n".
	- 'Phabricator is configured to run daemons as "%s", '.
	+ 'The daemons are configured to run as "%s", '.
	'but the current user is "%s". '."\n".
	'Use `%s` to run as a different user, pass `%s` to ignore this '.
	'warning, or edit `%s` to change the configuration.',
	'phd',
	'sudo',
	$phd_user,
	$current_user,
	'sudo',
	'--as-current-user',
	'phd.user'));
	} else {
	$this->runDaemonsAsUser = $phd_user;
	$console->writeOut(pht('Starting daemons as %s', $phd_user)."\n");
	}
	}
	}

	$this->printLaunchingDaemons($daemons, $debug);

	$trace = PhutilArgumentParser::isTraceModeEnabled();

	$flags = array();
	if ($trace) {
	$flags[] = '--trace';
	}

	if ($debug) {
	$flags[] = '--verbose';
	}

	$instance = $this->getInstance();
	if ($instance) {
	$flags[] = '-l';
	$flags[] = $instance;
	}

	$config = array();

	if (!$debug) {
	$config['daemonize'] = true;
	}

	if (!$debug) {
	$config['log'] = $this->getLogDirectory().'/daemons.log';
	}

	$config['daemons'] = $daemons;

	$command = csprintf('./phd-daemon %Ls', $flags);

	$phabricator_root = dirname(phutil_get_library_root('phabricator'));
	$daemon_script_dir = $phabricator_root.'/scripts/daemon/';

	if ($debug) {
	// Don't terminate when the user sends ^C; it will be sent to the
	// subprocess which will terminate normally.
	pcntl_signal(
	SIGINT,
	array(__CLASS__, 'ignoreSignal'));

	- echo "\n phabricator/scripts/daemon/ \$ {$command}\n\n";
	+ echo "\n scripts/daemon/ \$ {$command}\n\n";

	$tempfile = new TempFile('daemon.config');
	Filesystem::writeFile($tempfile, json_encode($config));

	phutil_passthru(
	'(cd %s && exec %C < %s)',
	$daemon_script_dir,
	$command,
	$tempfile);
	} else {
	try {
	$this->executeDaemonLaunchCommand(
	$command,
	$daemon_script_dir,
	$config,
	$this->runDaemonsAsUser);
	} catch (Exception $ex) {
	throw new PhutilArgumentUsageException(
	pht(
	'Daemons are configured to run as user "%s" in configuration '.
	'option `%s`, but the current user is "%s" and `phd` was unable '.
	'to switch to the correct user with `sudo`. Command output:'.
	"\n\n".
	'%s',
	$phd_user,
	'phd.user',
	$current_user,
	$ex->getMessage()));
	}
	}
	}

	private function executeDaemonLaunchCommand(
	$command,
	$daemon_script_dir,
	array $config,
	$run_as_user = null) {

	$is_sudo = false;
	if ($run_as_user) {
	// If anything else besides sudo should be
	// supported then insert it here (runuser, su, ...)
	$command = csprintf(
	'sudo -En -u %s -- %C',
	$run_as_user,
	$command);
	$is_sudo = true;
	}
	$future = new ExecFuture('exec %C', $command);
	// Play games to keep 'ps' looking reasonable.
	$future->setCWD($daemon_script_dir);
	$future->write(json_encode($config));
	list($stdout, $stderr) = $future->resolvex();

	if ($is_sudo) {
	// On OSX, `sudo -n` exits 0 when the user does not have permission to
	// switch accounts without a password. This is not consistent with
	// sudo on Linux, and seems buggy/broken. Check for this by string
	// matching the output.
	if (preg_match('/sudo: a password is required/', $stderr)) {
	throw new Exception(
	pht(
	'%s exited with a zero exit code, but emitted output '.
	'consistent with failure under OSX.',
	'sudo'));
	}
	}
	}

	public static function ignoreSignal($signo) {
	return;
	}

	public static function requireExtensions() {
	self::mustHaveExtension('pcntl');
	self::mustHaveExtension('posix');
	}

	private static function mustHaveExtension($ext) {
	if (!extension_loaded($ext)) {
	echo pht(
	"ERROR: The PHP extension '%s' is not installed. You must ".
	"install it to run daemons on this machine.\n",
	$ext);
	exit(1);
	}

	$extension = new ReflectionExtension($ext);
	foreach ($extension->getFunctions() as $function) {
	$function = $function->name;
	if (!function_exists($function)) {
	echo pht(
	"ERROR: The PHP function %s is disabled. You must ".
	"enable it to run daemons on this machine.\n",
	$function.'()');
	exit(1);
	}
	}
	}


	/* -( Commands )----------------------------------------------------------- */


	final protected function executeStartCommand(array $options) {
	PhutilTypeSpec::checkMap(
	$options,
	array(
	'keep-leases' => 'optional bool',
	'force' => 'optional bool',
	'reserve' => 'optional float',
	));

	$console = PhutilConsole::getConsole();

	if (!idx($options, 'force')) {
	$process_refs = $this->getOverseerProcessRefs();
	if ($process_refs) {
	$this->logWarn(
	pht('RUNNING DAEMONS'),
	pht('Daemons are already running:'));

	fprintf(STDERR, '%s', "\n");
	foreach ($process_refs as $process_ref) {
	fprintf(
	STDERR,
	'%s',
	tsprintf(
	" %s %s\n",
	$process_ref->getPID(),
	$process_ref->getCommand()));
	}
	fprintf(STDERR, '%s', "\n");

	$this->logFail(
	pht('RUNNING DAEMONS'),
	pht(
	'Use "phd stop" to stop daemons, "phd restart" to restart '.
	'daemons, or "phd start --force" to ignore running processes.'));

	exit(1);
	}
	}

	if (idx($options, 'keep-leases')) {
	$console->writeErr("%s\n", pht('Not touching active task queue leases.'));
	} else {
	$console->writeErr("%s\n", pht('Freeing active task leases...'));
	$count = $this->freeActiveLeases();
	$console->writeErr(
	"%s\n",
	pht('Freed %s task lease(s).', new PhutilNumber($count)));
	}

	$daemons = array(
	array(
	'class' => 'PhabricatorRepositoryPullLocalDaemon',
	'label' => 'pull',
	),
	array(
	'class' => 'PhabricatorTriggerDaemon',
	'label' => 'trigger',
	),
	array(
	'class' => 'PhabricatorFactDaemon',
	'label' => 'fact',
	),
	array(
	'class' => 'PhabricatorTaskmasterDaemon',
	'label' => 'task',
	'pool' => PhabricatorEnv::getEnvConfig('phd.taskmasters'),
	'reserve' => idx($options, 'reserve', 0),
	),
	);

	$this->launchDaemons($daemons, $is_debug = false);

	$console->writeErr("%s\n", pht('Done.'));
	return 0;
	}

	final protected function executeStopCommand(array $options) {
	$grace_period = idx($options, 'graceful', 15);
	$force = idx($options, 'force');

	$query = id(new PhutilProcessQuery())
	->withIsOverseer(true);

	$instance = $this->getInstance();
	if ($instance !== null && !$force) {
	$query->withInstances(array($instance));
	}

	try {
	$process_refs = $query->execute();
	} catch (Exception $ex) {
	// See T13321. If this fails for some reason, just continue for now so
	// that daemon management still works. In the long run, we don't expect
	// this to fail, but I don't want to break this workflow while we iron
	// bugs out.

	// See T12827. Particularly, this is likely to fail on Solaris.

	phlog($ex);

	$process_refs = array();
	}

	if (!$process_refs) {
	if ($instance !== null && !$force) {
	$this->logInfo(
	pht('NO DAEMONS'),
	pht(
	'There are no running daemons for the current instance ("%s"). '.
	'Use "--force" to stop daemons for all instances.',
	$instance));
	} else {
	$this->logInfo(
	pht('NO DAEMONS'),
	pht('There are no running daemons.'));
	}

	return 0;
	}

	$process_refs = mpull($process_refs, null, 'getPID');

	$stop_pids = array_keys($process_refs);
	$live_pids = $this->sendStopSignals($stop_pids, $grace_period);

	$stop_pids = array_fuse($stop_pids);
	$live_pids = array_fuse($live_pids);

	$dead_pids = array_diff_key($stop_pids, $live_pids);

	foreach ($dead_pids as $dead_pid) {
	$dead_ref = $process_refs[$dead_pid];
	$this->logOkay(
	pht('STOP'),
	pht(
	'Stopped PID %d ("%s")',
	$dead_pid,
	$dead_ref->getCommand()));
	}

	foreach ($live_pids as $live_pid) {
	$live_ref = $process_refs[$live_pid];
	$this->logFail(
	pht('SURVIVED'),
	pht(
	'Unable to stop PID %d ("%s").',
	$live_pid,
	$live_ref->getCommand()));
	}

	if ($live_pids) {
	$this->logWarn(
	pht('SURVIVORS'),
	pht(
	'Unable to stop all daemon processes. You may need to run this '.
	'command as root with "sudo".'));
	}

	return 0;
	}

	final protected function executeReloadCommand(array $pids) {
	$process_refs = $this->getOverseerProcessRefs();

	if (!$process_refs) {
	$this->logInfo(
	pht('NO DAEMONS'),
	pht('There are no running daemon processes to reload.'));

	return 0;
	}

	foreach ($process_refs as $process_ref) {
	$pid = $process_ref->getPID();

	$this->logInfo(
	pht('RELOAD'),
	pht('Reloading process %d...', $pid));

	posix_kill($pid, SIGHUP);
	}

	return 0;
	}

	private function sendStopSignals($pids, $grace_period) {
	// If we're doing a graceful shutdown, try SIGINT first.
	if ($grace_period) {
	$pids = $this->sendSignal($pids, SIGINT, $grace_period);
	}

	// If we still have daemons, SIGTERM them.
	if ($pids) {
	$pids = $this->sendSignal($pids, SIGTERM, 15);
	}

	// If the overseer is still alive, SIGKILL it.
	if ($pids) {
	$pids = $this->sendSignal($pids, SIGKILL, 0);
	}

	return $pids;
	}

	private function sendSignal(array $pids, $signo, $wait) {
	$console = PhutilConsole::getConsole();

	$pids = array_fuse($pids);

	foreach ($pids as $key => $pid) {
	if (!$pid) {
	// NOTE: We must have a PID to signal a daemon, since sending a signal
	// to PID 0 kills this process.
	unset($pids[$key]);
	continue;
	}

	switch ($signo) {
	case SIGINT:
	$message = pht('Interrupting process %d...', $pid);
	break;
	case SIGTERM:
	$message = pht('Terminating process %d...', $pid);
	break;
	case SIGKILL:
	$message = pht('Killing process %d...', $pid);
	break;
	}

	$console->writeOut("%s\n", $message);
	posix_kill($pid, $signo);
	}

	if ($wait) {
	$start = PhabricatorTime::getNow();
	do {
	foreach ($pids as $key => $pid) {
	if (!PhabricatorDaemonReference::isProcessRunning($pid)) {
	$console->writeOut(pht('Process %d exited.', $pid)."\n");
	unset($pids[$key]);
	}
	}
	if (empty($pids)) {
	break;
	}
	usleep(100000);
	} while (PhabricatorTime::getNow() < $start + $wait);
	}

	return $pids;
	}

	private function freeActiveLeases() {
	$task_table = id(new PhabricatorWorkerActiveTask());
	$conn_w = $task_table->establishConnection('w');
	queryfx(
	$conn_w,
	'UPDATE %T SET leaseExpires = UNIX_TIMESTAMP()
	WHERE leaseExpires > UNIX_TIMESTAMP()',
	$task_table->getTableName());
	return $conn_w->getAffectedRows();
	}


	private function printLaunchingDaemons(array $daemons, $debug) {
	$console = PhutilConsole::getConsole();

	if ($debug) {
	$console->writeOut(pht('Launching daemons (in debug mode):'));
	} else {
	$console->writeOut(pht('Launching daemons:'));
	}

	$log_dir = $this->getLogDirectory().'/daemons.log';
	$console->writeOut(
	"\n%s\n\n",
	pht('(Logs will appear in "%s".)', $log_dir));

	foreach ($daemons as $daemon) {
	$pool_size = pht('(Pool: %s)', idx($daemon, 'pool', 1));

	$console->writeOut(
	" %s %s\n",
	$pool_size,
	$daemon['class'],
	implode(' ', idx($daemon, 'argv', array())));
	}
	$console->writeOut("\n");
	}

	protected function getAutoscaleReserveArgument() {
	return array(
	'name' => 'autoscale-reserve',
	'param' => 'ratio',
	'help' => pht(
	'Specify a proportion of machine memory which must be free '.
	'before autoscale pools will grow. For example, a value of 0.25 '.
	'means that pools will not grow unless the machine has at least '.
	'25%%%% of its RAM free.'),
	);
	}

	private function selectDaemonPIDs(array $daemons, array $pids) {
	$console = PhutilConsole::getConsole();

	$running_pids = array_fuse(mpull($daemons, 'getPID'));
	if (!$pids) {
	$select_pids = $running_pids;
	} else {
	// We were given a PID or set of PIDs to kill.
	$select_pids = array();
	foreach ($pids as $key => $pid) {
	if (!preg_match('/^\d+$/', $pid)) {
	$console->writeErr(pht("PID '%s' is not a valid PID.", $pid)."\n");
	continue;
	} else if (empty($running_pids[$pid])) {
	$console->writeErr(
	"%s\n",
	pht(
	- 'PID "%d" is not a known Phabricator daemon PID.',
	+ 'PID "%d" is not a known daemon PID.',
	$pid));
	continue;
	} else {
	$select_pids[$pid] = $pid;
	}
	}
	}

	return $select_pids;
	}

	protected function getOverseerProcessRefs() {
	$query = id(new PhutilProcessQuery())
	->withIsOverseer(true);

	$instance = PhabricatorEnv::getEnvConfig('cluster.instance');
	if ($instance !== null) {
	$query->withInstances(array($instance));
	}

	return $query->execute();
	}

	protected function getInstance() {
	return PhabricatorEnv::getEnvConfig('cluster.instance');
	}


	}
	diff --git a/src/applications/dashboard/paneltype/PhabricatorDashboardQueryPanelType.php b/src/applications/dashboard/paneltype/PhabricatorDashboardQueryPanelType.php
	index 2174f793a4..c8cfe4fd2e 100644
	--- a/src/applications/dashboard/paneltype/PhabricatorDashboardQueryPanelType.php
	+++ b/src/applications/dashboard/paneltype/PhabricatorDashboardQueryPanelType.php
	@@ -1,234 +1,234 @@
	<?php

	final class PhabricatorDashboardQueryPanelType
	extends PhabricatorDashboardPanelType {

	public function getPanelTypeKey() {
	return 'query';
	}

	public function getPanelTypeName() {
	return pht('Query Panel');
	}

	public function getIcon() {
	return 'fa-search';
	}

	public function getPanelTypeDescription() {
	return pht(
	'Show results of a search query, like the most recently filed tasks or '.
	'revisions you need to review.');
	}

	protected function newEditEngineFields(PhabricatorDashboardPanel $panel) {
	$application_field =
	id(new PhabricatorDashboardQueryPanelApplicationEditField())
	->setKey('class')
	->setLabel(pht('Search For'))
	->setTransactionType(
	PhabricatorDashboardQueryPanelApplicationTransaction::TRANSACTIONTYPE)
	->setValue($panel->getProperty('class', ''));

	$application_id = $application_field->getControlID();

	$query_field =
	id(new PhabricatorDashboardQueryPanelQueryEditField())
	->setKey('key')
	->setLabel(pht('Query'))
	->setApplicationControlID($application_id)
	->setTransactionType(
	PhabricatorDashboardQueryPanelQueryTransaction::TRANSACTIONTYPE)
	->setValue($panel->getProperty('key', ''));

	$limit_field = id(new PhabricatorIntEditField())
	->setKey('limit')
	->setLabel(pht('Limit'))
	->setTransactionType(
	PhabricatorDashboardQueryPanelLimitTransaction::TRANSACTIONTYPE)
	->setValue($panel->getProperty('limit'));

	return array(
	$application_field,
	$query_field,
	$limit_field,
	);
	}

	public function renderPanelContent(
	PhabricatorUser $viewer,
	PhabricatorDashboardPanel $panel,
	PhabricatorDashboardPanelRenderingEngine $engine) {

	$engine = $this->getSearchEngine($panel);

	$engine->setViewer($viewer);
	$engine->setContext(PhabricatorApplicationSearchEngine::CONTEXT_PANEL);

	$key = $panel->getProperty('key');
	if ($engine->isBuiltinQuery($key)) {
	$saved = $engine->buildSavedQueryFromBuiltin($key);
	} else {
	$saved = id(new PhabricatorSavedQueryQuery())
	->setViewer($viewer)
	->withEngineClassNames(array(get_class($engine)))
	->withQueryKeys(array($key))
	->executeOne();
	}

	if (!$saved) {
	throw new Exception(
	pht(
	'Query "%s" is unknown to application search engine "%s"!',
	$key,
	get_class($engine)));
	}

	$query = $engine->buildQueryFromSavedQuery($saved);
	$pager = $engine->newPagerForSavedQuery($saved);

	if ($panel->getProperty('limit')) {
	$limit = (int)$panel->getProperty('limit');
	if ($pager->getPageSize() !== 0xFFFF) {
	$pager->setPageSize($limit);
	}
	}

	$query->setReturnPartialResultsOnOverheat(true);

	$results = $engine->executeQuery($query, $pager);
	$results_view = $engine->renderResults($results, $saved);

	$is_overheated = $query->getIsOverheated();
	$overheated_view = null;
	if ($is_overheated) {
	$content = $results_view->getContent();

	$overheated_message =
	PhabricatorApplicationSearchController::newOverheatedError(
	(bool)$results);

	$overheated_warning = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setTitle(pht('Query Overheated'))
	->setErrors(
	array(
	$overheated_message,
	));

	$overheated_box = id(new PHUIBoxView())
	->addClass('mmt mmb')
	->appendChild($overheated_warning);

	$content = array($content, $overheated_box);
	$results_view->setContent($content);
	}

	// TODO: A small number of queries, including "Notifications" and "Search",
	// use an offset pager which has a slightly different API. Some day, we
	// should unify these.
	if ($pager instanceof PHUIPagerView) {
	$has_more = $pager->getHasMorePages();
	} else {
	$has_more = $pager->getHasMoreResults();
	}

	if ($has_more) {
	$item_list = $results_view->getObjectList();

	$more_href = $engine->getQueryResultsPageURI($key);
	if ($item_list) {
	$item_list->newTailButton()
	->setHref($more_href);
	} else {
	// For search engines that do not return an object list, add a fake
	// one to the end so we can render a "View All Results" button that
	// looks like it does in normal applications. At time of writing,
	// several major applications like Maniphest (which has group headers)
	// and Feed (which uses custom rendering) don't return simple lists.

	$content = $results_view->getContent();

	$more_list = id(new PHUIObjectItemListView())
	->setAllowEmptyList(true);

	$more_list->newTailButton()
	->setHref($more_href);

	$content = array($content, $more_list);
	$results_view->setContent($content);
	}
	}

	return $results_view;
	}

	public function adjustPanelHeader(
	PhabricatorUser $viewer,
	PhabricatorDashboardPanel $panel,
	PhabricatorDashboardPanelRenderingEngine $engine,
	PHUIHeaderView $header) {

	$search_engine = $this->getSearchEngine($panel);
	$key = $panel->getProperty('key');
	$href = $search_engine->getQueryResultsPageURI($key);

	$icon = id(new PHUIIconView())
	->setIcon('fa-search');

	$button = id(new PHUIButtonView())
	->setTag('a')
	->setText(pht('View All'))
	->setIcon($icon)
	->setHref($href)
	->setColor(PHUIButtonView::GREY);

	$header->addActionLink($button);

	return $header;
	}

	private function getSearchEngine(PhabricatorDashboardPanel $panel) {
	$class = $panel->getProperty('class');
	$engine = PhabricatorApplicationSearchEngine::getEngineByClassName($class);
	if (!$engine) {
	throw new Exception(
	pht(
	- 'The application search engine "%s" is not known to Phabricator!',
	+ 'The application search engine "%s" is unknown.',
	$class));
	}

	if (!$engine->canUseInPanelContext()) {
	throw new Exception(
	pht(
	'Application search engines of class "%s" can not be used to build '.
	'dashboard panels.',
	$class));
	}

	return $engine;
	}

	public function newHeaderEditActions(
	PhabricatorDashboardPanel $panel,
	PhabricatorUser $viewer,
	$context_phid) {
	$actions = array();

	$engine = $this->getSearchEngine($panel);

	$customize_uri = $engine->getCustomizeURI(
	$panel->getProperty('key'),
	$panel->getPHID(),
	$context_phid);

	$actions[] = id(new PhabricatorActionView())
	->setIcon('fa-pencil-square-o')
	->setName(pht('Customize Query'))
	->setWorkflow(true)
	->setHref($customize_uri);

	return $actions;
	}

	}
	diff --git a/src/applications/differential/parser/DifferentialChangesetParser.php b/src/applications/differential/parser/DifferentialChangesetParser.php
	index ad62b2a1ef..5b39269bdd 100644
	--- a/src/applications/differential/parser/DifferentialChangesetParser.php
	+++ b/src/applications/differential/parser/DifferentialChangesetParser.php
	@@ -1,1975 +1,1975 @@
	<?php

	final class DifferentialChangesetParser extends Phobject {

	const HIGHLIGHT_BYTE_LIMIT = 262144;

	protected $visible = array();
	protected $new = array();
	protected $old = array();
	protected $intra = array();
	protected $depthOnlyLines = array();
	protected $newRender = null;
	protected $oldRender = null;

	protected $filename = null;
	protected $hunkStartLines = array();

	protected $comments = array();
	protected $specialAttributes = array();

	protected $changeset;

	protected $renderCacheKey = null;

	private $handles = array();
	private $user;

	private $leftSideChangesetID;
	private $leftSideAttachesToNewFile;

	private $rightSideChangesetID;
	private $rightSideAttachesToNewFile;

	private $originalLeft;
	private $originalRight;

	private $renderingReference;
	private $isSubparser;

	private $isTopLevel;

	private $coverage;
	private $markupEngine;
	private $highlightErrors;
	private $disableCache;
	private $renderer;
	private $highlightingDisabled;
	private $showEditAndReplyLinks = true;
	private $canMarkDone;
	private $objectOwnerPHID;
	private $offsetMode;

	private $rangeStart;
	private $rangeEnd;
	private $mask;
	private $linesOfContext = 8;

	private $highlightEngine;
	private $viewer;

	private $viewState;
	private $availableDocumentEngines;

	public function setRange($start, $end) {
	$this->rangeStart = $start;
	$this->rangeEnd = $end;
	return $this;
	}

	public function setMask(array $mask) {
	$this->mask = $mask;
	return $this;
	}

	public function renderChangeset() {
	return $this->render($this->rangeStart, $this->rangeEnd, $this->mask);
	}

	public function setShowEditAndReplyLinks($bool) {
	$this->showEditAndReplyLinks = $bool;
	return $this;
	}

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

	public function setViewState(PhabricatorChangesetViewState $view_state) {
	$this->viewState = $view_state;
	return $this;
	}

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

	public function setRenderer(DifferentialChangesetRenderer $renderer) {
	$this->renderer = $renderer;
	return $this;
	}

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

	public function setDisableCache($disable_cache) {
	$this->disableCache = $disable_cache;
	return $this;
	}

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

	public function setCanMarkDone($can_mark_done) {
	$this->canMarkDone = $can_mark_done;
	return $this;
	}

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

	public function setObjectOwnerPHID($phid) {
	$this->objectOwnerPHID = $phid;
	return $this;
	}

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

	public function setOffsetMode($offset_mode) {
	$this->offsetMode = $offset_mode;
	return $this;
	}

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

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

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

	private function newRenderer() {
	$viewer = $this->getViewer();
	$viewstate = $this->getViewstate();

	$renderer_key = $viewstate->getRendererKey();

	if ($renderer_key === null) {
	$is_unified = $viewer->compareUserSetting(
	PhabricatorUnifiedDiffsSetting::SETTINGKEY,
	PhabricatorUnifiedDiffsSetting::VALUE_ALWAYS_UNIFIED);

	if ($is_unified) {
	$renderer_key = '1up';
	} else {
	$renderer_key = $viewstate->getDefaultDeviceRendererKey();
	}
	}

	switch ($renderer_key) {
	case '1up':
	$renderer = new DifferentialChangesetOneUpRenderer();
	break;
	default:
	$renderer = new DifferentialChangesetTwoUpRenderer();
	break;
	}

	return $renderer;
	}

	const CACHE_VERSION = 14;
	const CACHE_MAX_SIZE = 8e6;

	const ATTR_GENERATED = 'attr:generated';
	const ATTR_DELETED = 'attr:deleted';
	const ATTR_UNCHANGED = 'attr:unchanged';
	const ATTR_MOVEAWAY = 'attr:moveaway';

	public function setOldLines(array $lines) {
	$this->old = $lines;
	return $this;
	}

	public function setNewLines(array $lines) {
	$this->new = $lines;
	return $this;
	}

	public function setSpecialAttributes(array $attributes) {
	$this->specialAttributes = $attributes;
	return $this;
	}

	public function setIntraLineDiffs(array $diffs) {
	$this->intra = $diffs;
	return $this;
	}

	public function setDepthOnlyLines(array $lines) {
	$this->depthOnlyLines = $lines;
	return $this;
	}

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

	public function setVisibleLinesMask(array $mask) {
	$this->visible = $mask;
	return $this;
	}

	public function setLinesOfContext($lines_of_context) {
	$this->linesOfContext = $lines_of_context;
	return $this;
	}

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


	/**
	* Configure which Changeset comments added to the right side of the visible
	* diff will be attached to. The ID must be the ID of a real Differential
	* Changeset.
	*
	* The complexity here is that we may show an arbitrary side of an arbitrary
	* changeset as either the left or right part of a diff. This method allows
	* the left and right halves of the displayed diff to be correctly mapped to
	* storage changesets.
	*
	* @param id The Differential Changeset ID that comments added to the right
	* side of the visible diff should be attached to.
	* @param bool If true, attach new comments to the right side of the storage
	* changeset. Note that this may be false, if the left side of
	* some storage changeset is being shown as the right side of
	* a display diff.
	* @return this
	*/
	public function setRightSideCommentMapping($id, $is_new) {
	$this->rightSideChangesetID = $id;
	$this->rightSideAttachesToNewFile = $is_new;
	return $this;
	}

	/**
	* See setRightSideCommentMapping(), but this sets information for the left
	* side of the display diff.
	*/
	public function setLeftSideCommentMapping($id, $is_new) {
	$this->leftSideChangesetID = $id;
	$this->leftSideAttachesToNewFile = $is_new;
	return $this;
	}

	public function setOriginals(
	DifferentialChangeset $left,
	DifferentialChangeset $right) {

	$this->originalLeft = $left;
	$this->originalRight = $right;
	return $this;
	}

	public function diffOriginals() {
	$engine = new PhabricatorDifferenceEngine();
	$changeset = $engine->generateChangesetFromFileContent(
	implode('', mpull($this->originalLeft->getHunks(), 'getChanges')),
	implode('', mpull($this->originalRight->getHunks(), 'getChanges')));

	$parser = new DifferentialHunkParser();

	return $parser->parseHunksForHighlightMasks(
	$changeset->getHunks(),
	$this->originalLeft->getHunks(),
	$this->originalRight->getHunks());
	}

	/**
	* Set a key for identifying this changeset in the render cache. If set, the
	* parser will attempt to use the changeset render cache, which can improve
	* performance for frequently-viewed changesets.
	*
	* By default, there is no render cache key and parsers do not use the cache.
	* This is appropriate for rarely-viewed changesets.
	*
	* @param string Key for identifying this changeset in the render cache.
	* @return this
	*/
	public function setRenderCacheKey($key) {
	$this->renderCacheKey = $key;
	return $this;
	}

	private function getRenderCacheKey() {
	return $this->renderCacheKey;
	}

	public function setChangeset(DifferentialChangeset $changeset) {
	$this->changeset = $changeset;

	$this->setFilename($changeset->getFilename());

	return $this;
	}

	public function setRenderingReference($ref) {
	$this->renderingReference = $ref;
	return $this;
	}

	private function getRenderingReference() {
	return $this->renderingReference;
	}

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

	public function setFilename($filename) {
	$this->filename = $filename;
	return $this;
	}

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

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

	public function setCoverage($coverage) {
	$this->coverage = $coverage;
	return $this;
	}
	private function getCoverage() {
	return $this->coverage;
	}

	public function parseInlineComment(
	PhabricatorInlineComment $comment) {

	// Parse only comments which are actually visible.
	if ($this->isCommentVisibleOnRenderedDiff($comment)) {
	$this->comments[] = $comment;
	}
	return $this;
	}

	private function loadCache() {
	$render_cache_key = $this->getRenderCacheKey();
	if (!$render_cache_key) {
	return false;
	}

	$data = null;

	$changeset = new DifferentialChangeset();
	$conn_r = $changeset->establishConnection('r');
	$data = queryfx_one(
	$conn_r,
	'SELECT * FROM %T WHERE cacheIndex = %s',
	DifferentialChangeset::TABLE_CACHE,
	PhabricatorHash::digestForIndex($render_cache_key));

	if (!$data) {
	return false;
	}

	if ($data['cache'][0] == '{') {
	// This is likely an old-style JSON cache which we will not be able to
	// deserialize.
	return false;
	}

	$data = unserialize($data['cache']);
	if (!is_array($data) \|\| !$data) {
	return false;
	}

	foreach (self::getCacheableProperties() as $cache_key) {
	if (!array_key_exists($cache_key, $data)) {
	// If we're missing a cache key, assume we're looking at an old cache
	// and ignore it.
	return false;
	}
	}

	if ($data['cacheVersion'] !== self::CACHE_VERSION) {
	return false;
	}

	// Someone displays contents of a partially cached shielded file.
	if (!isset($data['newRender']) && (!$this->isTopLevel \|\| $this->comments)) {
	return false;
	}

	unset($data['cacheVersion'], $data['cacheHost']);
	$cache_prop = array_select_keys($data, self::getCacheableProperties());
	foreach ($cache_prop as $cache_key => $v) {
	$this->$cache_key = $v;
	}

	return true;
	}

	protected static function getCacheableProperties() {
	return array(
	'visible',
	'new',
	'old',
	'intra',
	'depthOnlyLines',
	'newRender',
	'oldRender',
	'specialAttributes',
	'hunkStartLines',
	'cacheVersion',
	'cacheHost',
	'highlightingDisabled',
	);
	}

	public function saveCache() {
	if (PhabricatorEnv::isReadOnly()) {
	return false;
	}

	if ($this->highlightErrors) {
	return false;
	}

	$render_cache_key = $this->getRenderCacheKey();
	if (!$render_cache_key) {
	return false;
	}

	$cache = array();
	foreach (self::getCacheableProperties() as $cache_key) {
	switch ($cache_key) {
	case 'cacheVersion':
	$cache[$cache_key] = self::CACHE_VERSION;
	break;
	case 'cacheHost':
	$cache[$cache_key] = php_uname('n');
	break;
	default:
	$cache[$cache_key] = $this->$cache_key;
	break;
	}
	}
	$cache = serialize($cache);

	// We don't want to waste too much space by a single changeset.
	if (strlen($cache) > self::CACHE_MAX_SIZE) {
	return;
	}

	$changeset = new DifferentialChangeset();
	$conn_w = $changeset->establishConnection('w');

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	try {
	queryfx(
	$conn_w,
	'INSERT INTO %T (cacheIndex, cache, dateCreated) VALUES (%s, %B, %d)
	ON DUPLICATE KEY UPDATE cache = VALUES(cache)',
	DifferentialChangeset::TABLE_CACHE,
	PhabricatorHash::digestForIndex($render_cache_key),
	$cache,
	PhabricatorTime::getNow());
	} catch (AphrontQueryException $ex) {
	// Ignore these exceptions. A common cause is that the cache is
	// larger than 'max_allowed_packet', in which case we're better off
	// not writing it.

	// TODO: It would be nice to tailor this more narrowly.
	}
	unset($unguarded);
	}

	private function markGenerated($new_corpus_block = '') {
	$generated_guess = (strpos($new_corpus_block, '@'.'generated') !== false);

	if (!$generated_guess) {
	$generated_path_regexps = PhabricatorEnv::getEnvConfig(
	'differential.generated-paths');
	foreach ($generated_path_regexps as $regexp) {
	if (preg_match($regexp, $this->changeset->getFilename())) {
	$generated_guess = true;
	break;
	}
	}
	}

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_DIFFERENTIAL_WILLMARKGENERATED,
	array(
	'corpus' => $new_corpus_block,
	'is_generated' => $generated_guess,
	)
	);
	PhutilEventEngine::dispatchEvent($event);

	$generated = $event->getValue('is_generated');

	$attribute = $this->changeset->isGeneratedChangeset();
	if ($attribute) {
	$generated = true;
	}

	$this->specialAttributes[self::ATTR_GENERATED] = $generated;
	}

	public function isGenerated() {
	return idx($this->specialAttributes, self::ATTR_GENERATED, false);
	}

	public function isDeleted() {
	return idx($this->specialAttributes, self::ATTR_DELETED, false);
	}

	public function isUnchanged() {
	return idx($this->specialAttributes, self::ATTR_UNCHANGED, false);
	}

	public function isMoveAway() {
	return idx($this->specialAttributes, self::ATTR_MOVEAWAY, false);
	}

	private function applyIntraline(&$render, $intra, $corpus) {

	foreach ($render as $key => $text) {
	$result = $text;

	if (isset($intra[$key])) {
	$result = PhabricatorDifferenceEngine::applyIntralineDiff(
	$result,
	$intra[$key]);
	}

	$result = $this->adjustRenderedLineForDisplay($result);

	$render[$key] = $result;
	}
	}

	private function getHighlightFuture($corpus) {
	$language = $this->getViewState()->getHighlightLanguage();

	if (!$language) {
	$language = $this->highlightEngine->getLanguageFromFilename(
	$this->filename);

	if (($language != 'txt') &&
	(strlen($corpus) > self::HIGHLIGHT_BYTE_LIMIT)) {
	$this->highlightingDisabled = true;
	$language = 'txt';
	}
	}

	return $this->highlightEngine->getHighlightFuture(
	$language,
	$corpus);
	}

	protected function processHighlightedSource($data, $result) {

	$result_lines = phutil_split_lines($result);
	foreach ($data as $key => $info) {
	if (!$info) {
	unset($result_lines[$key]);
	}
	}
	return $result_lines;
	}

	private function tryCacheStuff() {
	$changeset = $this->getChangeset();
	if (!$changeset->hasSourceTextBody()) {

	// TODO: This isn't really correct (the change is not "generated"), the
	// intent is just to not render a text body for Subversion directory
	// changes, etc.
	$this->markGenerated();

	return;
	}

	$viewstate = $this->getViewState();

	$skip_cache = false;

	if ($this->disableCache) {
	$skip_cache = true;
	}

	$character_encoding = $viewstate->getCharacterEncoding();
	if ($character_encoding !== null) {
	$skip_cache = true;
	}

	$highlight_language = $viewstate->getHighlightLanguage();
	if ($highlight_language !== null) {
	$skip_cache = true;
	}

	if ($skip_cache \|\| !$this->loadCache()) {
	$this->process();
	if (!$skip_cache) {
	$this->saveCache();
	}
	}
	}

	private function process() {
	$changeset = $this->changeset;

	$hunk_parser = new DifferentialHunkParser();
	$hunk_parser->parseHunksForLineData($changeset->getHunks());

	$this->realignDiff($changeset, $hunk_parser);

	$hunk_parser->reparseHunksForSpecialAttributes();

	$unchanged = false;
	if (!$hunk_parser->getHasAnyChanges()) {
	$filetype = $this->changeset->getFileType();
	if ($filetype == DifferentialChangeType::FILE_TEXT \|\|
	$filetype == DifferentialChangeType::FILE_SYMLINK) {
	$unchanged = true;
	}
	}

	$moveaway = false;
	$changetype = $this->changeset->getChangeType();
	if ($changetype == DifferentialChangeType::TYPE_MOVE_AWAY) {
	$moveaway = true;
	}

	$this->setSpecialAttributes(array(
	self::ATTR_UNCHANGED => $unchanged,
	self::ATTR_DELETED => $hunk_parser->getIsDeleted(),
	self::ATTR_MOVEAWAY => $moveaway,
	));

	$lines_context = $this->getLinesOfContext();

	$hunk_parser->generateIntraLineDiffs();
	$hunk_parser->generateVisibleLinesMask($lines_context);

	$this->setOldLines($hunk_parser->getOldLines());
	$this->setNewLines($hunk_parser->getNewLines());
	$this->setIntraLineDiffs($hunk_parser->getIntraLineDiffs());
	$this->setDepthOnlyLines($hunk_parser->getDepthOnlyLines());
	$this->setVisibleLinesMask($hunk_parser->getVisibleLinesMask());
	$this->hunkStartLines = $hunk_parser->getHunkStartLines(
	$changeset->getHunks());

	$new_corpus = $hunk_parser->getNewCorpus();
	$new_corpus_block = implode('', $new_corpus);
	$this->markGenerated($new_corpus_block);

	if ($this->isTopLevel &&
	!$this->comments &&
	($this->isGenerated() \|\|
	$this->isUnchanged() \|\|
	$this->isDeleted())) {
	return;
	}

	$old_corpus = $hunk_parser->getOldCorpus();
	$old_corpus_block = implode('', $old_corpus);
	$old_future = $this->getHighlightFuture($old_corpus_block);
	$new_future = $this->getHighlightFuture($new_corpus_block);
	$futures = array(
	'old' => $old_future,
	'new' => $new_future,
	);
	$corpus_blocks = array(
	'old' => $old_corpus_block,
	'new' => $new_corpus_block,
	);

	$this->highlightErrors = false;
	foreach (new FutureIterator($futures) as $key => $future) {
	try {
	try {
	$highlighted = $future->resolve();
	} catch (PhutilSyntaxHighlighterException $ex) {
	$this->highlightErrors = true;
	$highlighted = id(new PhutilDefaultSyntaxHighlighter())
	->getHighlightFuture($corpus_blocks[$key])
	->resolve();
	}
	switch ($key) {
	case 'old':
	$this->oldRender = $this->processHighlightedSource(
	$this->old,
	$highlighted);
	break;
	case 'new':
	$this->newRender = $this->processHighlightedSource(
	$this->new,
	$highlighted);
	break;
	}
	} catch (Exception $ex) {
	phlog($ex);
	throw $ex;
	}
	}

	$this->applyIntraline(
	$this->oldRender,
	ipull($this->intra, 0),
	$old_corpus);
	$this->applyIntraline(
	$this->newRender,
	ipull($this->intra, 1),
	$new_corpus);
	}

	private function shouldRenderPropertyChangeHeader($changeset) {
	if (!$this->isTopLevel) {
	// We render properties only at top level; otherwise we get multiple
	// copies of them when a user clicks "Show More".
	return false;
	}

	return true;
	}

	public function render(
	$range_start = null,
	$range_len = null,
	$mask_force = array()) {

	$viewer = $this->getViewer();

	$renderer = $this->getRenderer();
	if (!$renderer) {
	$renderer = $this->newRenderer();
	$this->setRenderer($renderer);
	}

	// "Top level" renders are initial requests for the whole file, versus
	// requests for a specific range generated by clicking "show more". We
	// generate property changes and "shield" UI elements only for toplevel
	// requests.
	$this->isTopLevel = (($range_start === null) && ($range_len === null));
	$this->highlightEngine = PhabricatorSyntaxHighlighter::newEngine();

	$viewstate = $this->getViewState();

	$encoding = null;

	$character_encoding = $viewstate->getCharacterEncoding();
	if ($character_encoding) {
	// We are forcing this changeset to be interpreted with a specific
	// character encoding, so force all the hunks into that encoding and
	// propagate it to the renderer.
	$encoding = $character_encoding;
	foreach ($this->changeset->getHunks() as $hunk) {
	$hunk->forceEncoding($character_encoding);
	}
	} else {
	// We're just using the default, so tell the renderer what that is
	// (by reading the encoding from the first hunk).
	foreach ($this->changeset->getHunks() as $hunk) {
	$encoding = $hunk->getDataEncoding();
	break;
	}
	}

	$this->tryCacheStuff();

	// If we're rendering in an offset mode, treat the range numbers as line
	// numbers instead of rendering offsets.
	$offset_mode = $this->getOffsetMode();
	if ($offset_mode) {
	if ($offset_mode == 'new') {
	$offset_map = $this->new;
	} else {
	$offset_map = $this->old;
	}

	// NOTE: Inline comments use zero-based lengths. For example, a comment
	// that starts and ends on line 123 has length 0. Rendering considers
	// this range to have length 1. Probably both should agree, but that
	// ship likely sailed long ago. Tweak things here to get the two systems
	// to agree. See PHI985, where this affected mail rendering of inline
	// comments left on the final line of a file.

	$range_end = $this->getOffset($offset_map, $range_start + $range_len);
	$range_start = $this->getOffset($offset_map, $range_start);
	$range_len = ($range_end - $range_start) + 1;
	}

	$render_pch = $this->shouldRenderPropertyChangeHeader($this->changeset);

	$rows = max(
	count($this->old),
	count($this->new));

	$renderer = $this->getRenderer()
	->setUser($this->getViewer())
	->setChangeset($this->changeset)
	->setRenderPropertyChangeHeader($render_pch)
	->setIsTopLevel($this->isTopLevel)
	->setOldRender($this->oldRender)
	->setNewRender($this->newRender)
	->setHunkStartLines($this->hunkStartLines)
	->setOldChangesetID($this->leftSideChangesetID)
	->setNewChangesetID($this->rightSideChangesetID)
	->setOldAttachesToNewFile($this->leftSideAttachesToNewFile)
	->setNewAttachesToNewFile($this->rightSideAttachesToNewFile)
	->setCodeCoverage($this->getCoverage())
	->setRenderingReference($this->getRenderingReference())
	->setHandles($this->handles)
	->setOldLines($this->old)
	->setNewLines($this->new)
	->setOriginalCharacterEncoding($encoding)
	->setShowEditAndReplyLinks($this->getShowEditAndReplyLinks())
	->setCanMarkDone($this->getCanMarkDone())
	->setObjectOwnerPHID($this->getObjectOwnerPHID())
	->setHighlightingDisabled($this->highlightingDisabled)
	->setDepthOnlyLines($this->getDepthOnlyLines());

	if ($this->markupEngine) {
	$renderer->setMarkupEngine($this->markupEngine);
	}

	list($engine, $old_ref, $new_ref) = $this->newDocumentEngine();
	if ($engine) {
	$engine_blocks = $engine->newEngineBlocks(
	$old_ref,
	$new_ref);
	} else {
	$engine_blocks = null;
	}

	$has_document_engine = ($engine_blocks !== null);

	// Remove empty comments that don't have any unsaved draft data.
	PhabricatorInlineComment::loadAndAttachVersionedDrafts(
	$viewer,
	$this->comments);
	foreach ($this->comments as $key => $comment) {
	if ($comment->isVoidComment($viewer)) {
	unset($this->comments[$key]);
	}
	}

	// See T13515. Sometimes, we collapse file content by default: for
	// example, if the file is marked as containing generated code.

	// If a file has inline comments, that normally means we never collapse
	// it. However, if the viewer has already collapsed all of the inlines,
	// it's fine to collapse the file.

	$expanded_comments = array();
	foreach ($this->comments as $comment) {
	if ($comment->isHidden()) {
	continue;
	}
	$expanded_comments[] = $comment;
	}

	$collapsed_count = (count($this->comments) - count($expanded_comments));

	$shield_raw = null;
	$shield_text = null;
	$shield_type = null;
	if ($this->isTopLevel && !$expanded_comments && !$has_document_engine) {
	if ($this->isGenerated()) {
	$shield_text = pht(
	'This file contains generated code, which does not normally '.
	'need to be reviewed.');
	} else if ($this->isMoveAway()) {
	// We put an empty shield on these files. Normally, they do not have
	// any diff content anyway. However, if they come through `arc`, they
	// may have content. We don't want to show it (it's not useful) and
	// we bailed out of fully processing it earlier anyway.

	// We could show a message like "this file was moved", but we show
	// that as a change header anyway, so it would be redundant. Instead,
	// just render an empty shield to skip rendering the diff body.
	$shield_raw = '';
	} else if ($this->isUnchanged()) {
	$type = 'text';
	if (!$rows) {
	// NOTE: Normally, diffs which don't change files do not include
	// file content (for example, if you "chmod +x" a file and then
	// run "git show", the file content is not available). Similarly,
	// if you move a file from A to B without changing it, diffs normally
	// do not show the file content. In some cases `arc` is able to
	// synthetically generate content for these diffs, but for raw diffs
	// we'll never have it so we need to be prepared to not render a link.
	$type = 'none';
	}

	$shield_type = $type;

	$type_add = DifferentialChangeType::TYPE_ADD;
	if ($this->changeset->getChangeType() == $type_add) {
	// Although the generic message is sort of accurate in a technical
	// sense, this more-tailored message is less confusing.
	$shield_text = pht('This is an empty file.');
	} else {
	$shield_text = pht('The contents of this file were not changed.');
	}
	} else if ($this->isDeleted()) {
	$shield_text = pht('This file was completely deleted.');
	} else if ($this->changeset->getAffectedLineCount() > 2500) {
	$shield_text = pht(
	'This file has a very large number of changes (%s lines).',
	new PhutilNumber($this->changeset->getAffectedLineCount()));
	}
	}

	$shield = null;
	if ($shield_raw !== null) {
	$shield = $shield_raw;
	} else if ($shield_text !== null) {
	if ($shield_type === null) {
	$shield_type = 'default';
	}

	// If we have inlines and the shield would normally show the whole file,
	// downgrade it to show only text around the inlines.
	if ($collapsed_count) {
	if ($shield_type === 'text') {
	$shield_type = 'default';
	}

	$shield_text = array(
	$shield_text,
	' ',
	pht(
	'This file has %d collapsed inline comment(s).',
	new PhutilNumber($collapsed_count)),
	);
	}

	$shield = $renderer->renderShield($shield_text, $shield_type);
	}

	if ($shield !== null) {
	return $renderer->renderChangesetTable($shield);
	}

	// This request should render the "undershield" headers if it's a top-level
	// request which made it this far (indicating the changeset has no shield)
	// or it's a request with no mask information (indicating it's the request
	// that removes the rendering shield). Possibly, this second class of
	// request might need to be made more explicit.
	$is_undershield = (empty($mask_force) \|\| $this->isTopLevel);
	$renderer->setIsUndershield($is_undershield);

	$old_comments = array();
	$new_comments = array();
	$old_mask = array();
	$new_mask = array();
	$feedback_mask = array();
	$lines_context = $this->getLinesOfContext();

	if ($this->comments) {
	// If there are any comments which appear in sections of the file which
	// we don't have, we're going to move them backwards to the closest
	// earlier line. Two cases where this may happen are:
	//
	// - Porting ghost comments forward into a file which was mostly
	// deleted.
	// - Porting ghost comments forward from a full-context diff to a
	// partial-context diff.

	list($old_backmap, $new_backmap) = $this->buildLineBackmaps();

	foreach ($this->comments as $comment) {
	$new_side = $this->isCommentOnRightSideWhenDisplayed($comment);

	$line = $comment->getLineNumber();

	// See T13524. Lint inlines from Harbormaster may not have a line
	// number.
	if ($line === null) {
	$back_line = null;
	} else if ($new_side) {
	$back_line = idx($new_backmap, $line);
	} else {
	$back_line = idx($old_backmap, $line);
	}

	if ($back_line != $line) {
	// TODO: This should probably be cleaner, but just be simple and
	// obvious for now.
	$ghost = $comment->getIsGhost();
	if ($ghost) {
	$moved = pht(
	'This comment originally appeared on line %s, but that line '.
	'does not exist in this version of the diff. It has been '.
	'moved backward to the nearest line.',
	new PhutilNumber($line));
	$ghost['reason'] = $ghost['reason']."\n\n".$moved;
	$comment->setIsGhost($ghost);
	}

	$comment->setLineNumber($back_line);
	$comment->setLineLength(0);
	}

	$start = max($comment->getLineNumber() - $lines_context, 0);
	$end = $comment->getLineNumber() +
	$comment->getLineLength() +
	$lines_context;
	for ($ii = $start; $ii <= $end; $ii++) {
	if ($new_side) {
	$new_mask[$ii] = true;
	} else {
	$old_mask[$ii] = true;
	}
	}
	}

	foreach ($this->old as $ii => $old) {
	if (isset($old['line']) && isset($old_mask[$old['line']])) {
	$feedback_mask[$ii] = true;
	}
	}

	foreach ($this->new as $ii => $new) {
	if (isset($new['line']) && isset($new_mask[$new['line']])) {
	$feedback_mask[$ii] = true;
	}
	}

	$this->comments = id(new PHUIDiffInlineThreader())
	->reorderAndThreadCommments($this->comments);

	$old_max_display = 1;
	foreach ($this->old as $old) {
	if (isset($old['line'])) {
	$old_max_display = $old['line'];
	}
	}

	$new_max_display = 1;
	foreach ($this->new as $new) {
	if (isset($new['line'])) {
	$new_max_display = $new['line'];
	}
	}

	foreach ($this->comments as $comment) {
	$display_line = $comment->getLineNumber() + $comment->getLineLength();
	$display_line = max(1, $display_line);

	if ($this->isCommentOnRightSideWhenDisplayed($comment)) {
	$display_line = min($new_max_display, $display_line);
	$new_comments[$display_line][] = $comment;
	} else {
	$display_line = min($old_max_display, $display_line);
	$old_comments[$display_line][] = $comment;
	}
	}
	}

	$renderer
	->setOldComments($old_comments)
	->setNewComments($new_comments);

	if ($engine_blocks !== null) {
	$reference = $this->getRenderingReference();
	$parts = explode('/', $reference);
	if (count($parts) == 2) {
	list($id, $vs) = $parts;
	} else {
	$id = $parts[0];
	$vs = 0;
	}

	// If we don't have an explicit "vs" changeset, it's the left side of
	// the "id" changeset.
	if (!$vs) {
	$vs = $id;
	}

	if ($mask_force) {
	$engine_blocks->setRevealedIndexes(array_keys($mask_force));
	}

	if ($range_start !== null \|\| $range_len !== null) {
	$range_min = $range_start;

	if ($range_len === null) {
	$range_max = null;
	} else {
	$range_max = (int)$range_start + (int)$range_len;
	}

	$engine_blocks->setRange($range_min, $range_max);
	}

	$renderer
	->setDocumentEngine($engine)
	->setDocumentEngineBlocks($engine_blocks);

	return $renderer->renderDocumentEngineBlocks(
	$engine_blocks,
	(string)$id,
	(string)$vs);
	}

	// If we've made it here with a type of file we don't know how to render,
	// bail out with a default empty rendering. Normally, we'd expect a
	// document engine to catch these changes before we make it this far.
	switch ($this->changeset->getFileType()) {
	case DifferentialChangeType::FILE_DIRECTORY:
	case DifferentialChangeType::FILE_BINARY:
	case DifferentialChangeType::FILE_IMAGE:
	$output = $renderer->renderChangesetTable(null);
	return $output;
	}

	if ($this->originalLeft && $this->originalRight) {
	list($highlight_old, $highlight_new) = $this->diffOriginals();
	$highlight_old = array_flip($highlight_old);
	$highlight_new = array_flip($highlight_new);
	$renderer
	->setHighlightOld($highlight_old)
	->setHighlightNew($highlight_new);
	}
	$renderer
	->setOriginalOld($this->originalLeft)
	->setOriginalNew($this->originalRight);

	if ($range_start === null) {
	$range_start = 0;
	}
	if ($range_len === null) {
	$range_len = $rows;
	}
	$range_len = min($range_len, $rows - $range_start);

	list($gaps, $mask) = $this->calculateGapsAndMask(
	$mask_force,
	$feedback_mask,
	$range_start,
	$range_len);

	$renderer
	->setGaps($gaps)
	->setMask($mask);

	$html = $renderer->renderTextChange(
	$range_start,
	$range_len,
	$rows);

	return $renderer->renderChangesetTable($html);
	}

	/**
	* This function calculates a lot of stuff we need to know to display
	* the diff:
	*
	* Gaps - compute gaps in the visible display diff, where we will render
	* "Show more context" spacers. If a gap is smaller than the context size,
	* we just display it. Otherwise, we record it into $gaps and will render a
	* "show more context" element instead of diff text below. A given $gap
	* is a tuple of $gap_line_number_start and $gap_length.
	*
	* Mask - compute the actual lines that need to be shown (because they
	* are near changes lines, near inline comments, or the request has
	* explicitly asked for them, i.e. resulting from the user clicking
	* "show more"). The $mask returned is a sparsely populated dictionary
	* of $visible_line_number => true.
	*
	* @return array($gaps, $mask)
	*/
	private function calculateGapsAndMask(
	$mask_force,
	$feedback_mask,
	$range_start,
	$range_len) {

	$lines_context = $this->getLinesOfContext();

	$gaps = array();
	$gap_start = 0;
	$in_gap = false;
	$base_mask = $this->visible + $mask_force + $feedback_mask;
	$base_mask[$range_start + $range_len] = true;
	for ($ii = $range_start; $ii <= $range_start + $range_len; $ii++) {
	if (isset($base_mask[$ii])) {
	if ($in_gap) {
	$gap_length = $ii - $gap_start;
	if ($gap_length <= $lines_context) {
	for ($jj = $gap_start; $jj <= $gap_start + $gap_length; $jj++) {
	$base_mask[$jj] = true;
	}
	} else {
	$gaps[] = array($gap_start, $gap_length);
	}
	$in_gap = false;
	}
	} else {
	if (!$in_gap) {
	$gap_start = $ii;
	$in_gap = true;
	}
	}
	}
	$gaps = array_reverse($gaps);
	$mask = $base_mask;

	return array($gaps, $mask);
	}

	/**
	* Determine if an inline comment will appear on the rendered diff,
	* taking into consideration which halves of which changesets will actually
	* be shown.
	*
	* @param PhabricatorInlineComment Comment to test for visibility.
	* @return bool True if the comment is visible on the rendered diff.
	*/
	private function isCommentVisibleOnRenderedDiff(
	PhabricatorInlineComment $comment) {

	$changeset_id = $comment->getChangesetID();
	$is_new = $comment->getIsNewFile();

	if ($changeset_id == $this->rightSideChangesetID &&
	$is_new == $this->rightSideAttachesToNewFile) {
	return true;
	}

	if ($changeset_id == $this->leftSideChangesetID &&
	$is_new == $this->leftSideAttachesToNewFile) {
	return true;
	}

	return false;
	}


	/**
	* Determine if a comment will appear on the right side of the display diff.
	* Note that the comment must appear somewhere on the rendered changeset, as
	* per isCommentVisibleOnRenderedDiff().
	*
	* @param PhabricatorInlineComment Comment to test for display
	* location.
	* @return bool True for right, false for left.
	*/
	private function isCommentOnRightSideWhenDisplayed(
	PhabricatorInlineComment $comment) {

	if (!$this->isCommentVisibleOnRenderedDiff($comment)) {
	throw new Exception(pht('Comment is not visible on changeset!'));
	}

	$changeset_id = $comment->getChangesetID();
	$is_new = $comment->getIsNewFile();

	if ($changeset_id == $this->rightSideChangesetID &&
	$is_new == $this->rightSideAttachesToNewFile) {
	return true;
	}

	return false;
	}

	/**
	* Parse the 'range' specification that this class and the client-side JS
	* emit to indicate that a user clicked "Show more..." on a diff. Generally,
	* use is something like this:
	*
	* $spec = $request->getStr('range');
	* $parsed = DifferentialChangesetParser::parseRangeSpecification($spec);
	* list($start, $end, $mask) = $parsed;
	* $parser->render($start, $end, $mask);
	*
	* @param string Range specification, indicating the range of the diff that
	* should be rendered.
	* @return tuple List of <start, end, mask> suitable for passing to
	* @{method:render}.
	*/
	public static function parseRangeSpecification($spec) {
	$range_s = null;
	$range_e = null;
	$mask = array();

	if ($spec) {
	$match = null;
	if (preg_match('@^(\d+)-(\d+)(?:/(\d+)-(\d+))?$@', $spec, $match)) {
	$range_s = (int)$match[1];
	$range_e = (int)$match[2];
	if (count($match) > 3) {
	$start = (int)$match[3];
	$len = (int)$match[4];
	for ($ii = $start; $ii < $start + $len; $ii++) {
	$mask[$ii] = true;
	}
	}
	}
	}

	return array($range_s, $range_e, $mask);
	}

	/**
	* Render "modified coverage" information; test coverage on modified lines.
	* This synthesizes diff information with unit test information into a useful
	* indicator of how well tested a change is.
	*/
	public function renderModifiedCoverage() {
	$na = phutil_tag('em', array(), '-');

	$coverage = $this->getCoverage();
	if (!$coverage) {
	return $na;
	}

	$covered = 0;
	$not_covered = 0;

	foreach ($this->new as $k => $new) {
	if ($new === null) {
	continue;
	}

	if (!$new['line']) {
	continue;
	}

	if (!$new['type']) {
	continue;
	}

	if (empty($coverage[$new['line'] - 1])) {
	continue;
	}

	switch ($coverage[$new['line'] - 1]) {
	case 'C':
	$covered++;
	break;
	case 'U':
	$not_covered++;
	break;
	}
	}

	if (!$covered && !$not_covered) {
	return $na;
	}

	return sprintf('%d%%', 100 * ($covered / ($covered + $not_covered)));
	}

	/**
	* Build maps from lines comments appear on to actual lines.
	*/
	private function buildLineBackmaps() {
	$old_back = array();
	$new_back = array();
	foreach ($this->old as $ii => $old) {
	if ($old === null) {
	continue;
	}
	$old_back[$old['line']] = $old['line'];
	}
	foreach ($this->new as $ii => $new) {
	if ($new === null) {
	continue;
	}
	$new_back[$new['line']] = $new['line'];
	}

	$max_old_line = 0;
	$max_new_line = 0;
	foreach ($this->comments as $comment) {
	if ($this->isCommentOnRightSideWhenDisplayed($comment)) {
	$max_new_line = max($max_new_line, $comment->getLineNumber());
	} else {
	$max_old_line = max($max_old_line, $comment->getLineNumber());
	}
	}

	$cursor = 1;
	for ($ii = 1; $ii <= $max_old_line; $ii++) {
	if (empty($old_back[$ii])) {
	$old_back[$ii] = $cursor;
	} else {
	$cursor = $old_back[$ii];
	}
	}

	$cursor = 1;
	for ($ii = 1; $ii <= $max_new_line; $ii++) {
	if (empty($new_back[$ii])) {
	$new_back[$ii] = $cursor;
	} else {
	$cursor = $new_back[$ii];
	}
	}

	return array($old_back, $new_back);
	}

	private function getOffset(array $map, $line) {
	if (!$map) {
	return null;
	}

	$line = (int)$line;
	foreach ($map as $key => $spec) {
	if ($spec && isset($spec['line'])) {
	if ((int)$spec['line'] >= $line) {
	return $key;
	}
	}
	}

	return $key;
	}

	private function realignDiff(
	DifferentialChangeset $changeset,
	DifferentialHunkParser $hunk_parser) {
	// Normalizing and realigning the diff depends on rediffing the files, and
	// we currently need complete representations of both files to do anything
	// reasonable. If we only have parts of the files, skip realignment.

	// We have more than one hunk, so we're definitely missing part of the file.
	$hunks = $changeset->getHunks();
	if (count($hunks) !== 1) {
	return null;
	}

	// The first hunk doesn't start at the beginning of the file, so we're
	// missing some context.
	$first_hunk = head($hunks);
	if ($first_hunk->getOldOffset() != 1 \|\| $first_hunk->getNewOffset() != 1) {
	return null;
	}

	$old_file = $changeset->makeOldFile();
	$new_file = $changeset->makeNewFile();
	if ($old_file === $new_file) {
	// If the old and new files are exactly identical, the synthetic
	// diff below will give us nonsense and whitespace modes are
	// irrelevant anyway. This occurs when you, e.g., copy a file onto
	// itself in Subversion (see T271).
	return null;
	}


	$engine = id(new PhabricatorDifferenceEngine())
	->setNormalize(true);

	$normalized_changeset = $engine->generateChangesetFromFileContent(
	$old_file,
	$new_file);

	$type_parser = new DifferentialHunkParser();
	$type_parser->parseHunksForLineData($normalized_changeset->getHunks());

	$hunk_parser->setNormalized(true);
	$hunk_parser->setOldLineTypeMap($type_parser->getOldLineTypeMap());
	$hunk_parser->setNewLineTypeMap($type_parser->getNewLineTypeMap());
	}

	private function adjustRenderedLineForDisplay($line) {
	// IMPORTANT: We're using "str_replace()" against raw HTML here, which can
	// easily become unsafe. The input HTML has already had syntax highlighting
	// and intraline diff highlighting applied, so it's full of "<span />" tags.

	static $search;
	static $replace;
	if ($search === null) {
	$rules = $this->newSuspiciousCharacterRules();

	$map = array();
	foreach ($rules as $key => $spec) {
	$tag = phutil_tag(
	'span',
	array(
	'data-copy-text' => $key,
	'class' => $spec['class'],
	'title' => $spec['title'],
	),
	$spec['replacement']);
	$map[$key] = phutil_string_cast($tag);
	}

	$search = array_keys($map);
	$replace = array_values($map);
	}

	$is_html = false;
	if ($line instanceof PhutilSafeHTML) {
	$is_html = true;
	$line = hsprintf('%s', $line);
	}

	$line = phutil_string_cast($line);

	// TODO: This should be flexible, eventually.
	$tab_width = 2;

	$line = self::replaceTabsWithSpaces($line, $tab_width);
	$line = str_replace($search, $replace, $line);

	if ($is_html) {
	$line = phutil_safe_html($line);
	}

	return $line;
	}

	private function newSuspiciousCharacterRules() {
	// The "title" attributes are cached in the database, so they're
	// intentionally not wrapped in "pht(...)".

	$rules = array(
	"\xE2\x80\x8B" => array(
	'title' => 'ZWS',
	'class' => 'suspicious-character',
	'replacement' => '!',
	),
	"\xC2\xA0" => array(
	'title' => 'NBSP',
	'class' => 'suspicious-character',
	'replacement' => '!',
	),
	"\x7F" => array(
	'title' => 'DEL (0x7F)',
	'class' => 'suspicious-character',
	'replacement' => "\xE2\x90\xA1",
	),
	);

	// Unicode defines special pictures for the control characters in the
	// range between "0x00" and "0x1F".

	$control = array(
	'NULL',
	'SOH',
	'STX',
	'ETX',
	'EOT',
	'ENQ',
	'ACK',
	'BEL',
	'BS',
	null, // "\t" Tab
	null, // "\n" New Line
	'VT',
	'FF',
	null, // "\r" Carriage Return,
	'SO',
	'SI',
	'DLE',
	'DC1',
	'DC2',
	'DC3',
	'DC4',
	'NAK',
	'SYN',
	'ETB',
	'CAN',
	'EM',
	'SUB',
	'ESC',
	'FS',
	'GS',
	'RS',
	'US',
	);

	foreach ($control as $idx => $label) {
	if ($label === null) {
	continue;
	}

	$rules[chr($idx)] = array(
	'title' => sprintf('%s (0x%02X)', $label, $idx),
	'class' => 'suspicious-character',
	'replacement' => "\xE2\x90".chr(0x80 + $idx),
	);
	}

	return $rules;
	}

	public static function replaceTabsWithSpaces($line, $tab_width) {
	static $tags = array();
	if (empty($tags[$tab_width])) {
	for ($ii = 1; $ii <= $tab_width; $ii++) {
	$tag = phutil_tag(
	'span',
	array(
	'data-copy-text' => "\t",
	),
	str_repeat(' ', $ii));
	$tag = phutil_string_cast($tag);
	$tags[$ii] = $tag;
	}
	}

	// Expand all prefix tabs until we encounter any non-tab character. This
	// is cheap and often immediately produces the correct result with no
	// further work (and, particularly, no need to handle any unicode cases).

	$len = strlen($line);

	$head = 0;
	for ($head = 0; $head < $len; $head++) {
	$char = $line[$head];
	if ($char !== "\t") {
	break;
	}
	}

	if ($head) {
	if (empty($tags[$tab_width * $head])) {
	$tags[$tab_width * $head] = str_repeat($tags[$tab_width], $head);
	}
	$prefix = $tags[$tab_width * $head];
	$line = substr($line, $head);
	} else {
	$prefix = '';
	}

	// If we have no remaining tabs elsewhere in the string after taking care
	// of all the prefix tabs, we're done.
	if (strpos($line, "\t") === false) {
	return $prefix.$line;
	}

	$len = strlen($line);

	// If the line is particularly long, don't try to do anything special with
	// it. Use a faster approximation of the correct tabstop expansion instead.
	// This usually still arrives at the right result.
	if ($len > 256) {
	return $prefix.str_replace("\t", $tags[$tab_width], $line);
	}

	$in_tag = false;
	$pos = 0;

	// See PHI1210. If the line only has single-byte characters, we don't need
	// to vectorize it and can avoid an expensive UTF8 call.

	$fast_path = preg_match('/^[\x01-\x7F]*\z/', $line);
	if ($fast_path) {
	$replace = array();
	for ($ii = 0; $ii < $len; $ii++) {
	$char = $line[$ii];
	if ($char === '>') {
	$in_tag = false;
	continue;
	}

	if ($in_tag) {
	continue;
	}

	if ($char === '<') {
	$in_tag = true;
	continue;
	}

	if ($char === "\t") {
	$count = $tab_width - ($pos % $tab_width);
	$pos += $count;
	$replace[$ii] = $tags[$count];
	continue;
	}

	$pos++;
	}

	if ($replace) {
	// Apply replacements starting at the end of the string so they
	// don't mess up the offsets for following replacements.
	$replace = array_reverse($replace, true);

	foreach ($replace as $replace_pos => $replacement) {
	$line = substr_replace($line, $replacement, $replace_pos, 1);
	}
	}
	} else {
	$line = phutil_utf8v_combined($line);
	foreach ($line as $key => $char) {
	if ($char === '>') {
	$in_tag = false;
	continue;
	}

	if ($in_tag) {
	continue;
	}

	if ($char === '<') {
	$in_tag = true;
	continue;
	}

	if ($char === "\t") {
	$count = $tab_width - ($pos % $tab_width);
	$pos += $count;
	$line[$key] = $tags[$count];
	continue;
	}

	$pos++;
	}

	$line = implode('', $line);
	}

	return $prefix.$line;
	}

	private function newDocumentEngine() {
	$changeset = $this->changeset;
	$viewer = $this->getViewer();

	list($old_file, $new_file) = $this->loadFileObjectsForChangeset();

	$no_old = !$changeset->hasOldState();
	$no_new = !$changeset->hasNewState();

	if ($no_old) {
	$old_ref = null;
	} else {
	$old_ref = id(new PhabricatorDocumentRef())
	->setName($changeset->getOldFile());
	if ($old_file) {
	$old_ref->setFile($old_file);
	} else {
	$old_data = $this->getRawDocumentEngineData($this->old);
	$old_ref->setData($old_data);
	}
	}

	if ($no_new) {
	$new_ref = null;
	} else {
	$new_ref = id(new PhabricatorDocumentRef())
	->setName($changeset->getFilename());
	if ($new_file) {
	$new_ref->setFile($new_file);
	} else {
	$new_data = $this->getRawDocumentEngineData($this->new);
	$new_ref->setData($new_data);
	}
	}

	$old_engines = null;
	if ($old_ref) {
	$old_engines = PhabricatorDocumentEngine::getEnginesForRef(
	$viewer,
	$old_ref);
	}

	$new_engines = null;
	if ($new_ref) {
	$new_engines = PhabricatorDocumentEngine::getEnginesForRef(
	$viewer,
	$new_ref);
	}

	if ($new_engines !== null && $old_engines !== null) {
	$shared_engines = array_intersect_key($new_engines, $old_engines);
	$default_engine = head_key($new_engines);
	} else if ($new_engines !== null) {
	$shared_engines = $new_engines;
	$default_engine = head_key($shared_engines);
	} else if ($old_engines !== null) {
	$shared_engines = $old_engines;
	$default_engine = head_key($shared_engines);
	} else {
	return null;
	}

	foreach ($shared_engines as $key => $shared_engine) {
	if (!$shared_engine->canDiffDocuments($old_ref, $new_ref)) {
	unset($shared_engines[$key]);
	}
	}

	$this->availableDocumentEngines = $shared_engines;

	$viewstate = $this->getViewState();

	$engine_key = $viewstate->getDocumentEngineKey();
	- if (strlen($engine_key)) {
	+ if (phutil_nonempty_string($engine_key)) {
	if (isset($shared_engines[$engine_key])) {
	$document_engine = $shared_engines[$engine_key];
	} else {
	$document_engine = null;
	}
	} else {
	// If we aren't rendering with a specific engine, only use a default
	// engine if the best engine for the new file is a shared engine which
	// can diff files. If we're less picky (for example, by accepting any
	// shared engine) we can end up with silly behavior (like ".json" files
	// rendering as Jupyter documents).

	if (isset($shared_engines[$default_engine])) {
	$document_engine = $shared_engines[$default_engine];
	} else {
	$document_engine = null;
	}
	}

	if ($document_engine) {
	return array(
	$document_engine,
	$old_ref,
	$new_ref);
	}

	return null;
	}

	private function loadFileObjectsForChangeset() {
	$changeset = $this->changeset;
	$viewer = $this->getViewer();

	$old_phid = $changeset->getOldFileObjectPHID();
	$new_phid = $changeset->getNewFileObjectPHID();

	$old_file = null;
	$new_file = null;

	if ($old_phid \|\| $new_phid) {
	$file_phids = array();
	if ($old_phid) {
	$file_phids[] = $old_phid;
	}
	if ($new_phid) {
	$file_phids[] = $new_phid;
	}

	$files = id(new PhabricatorFileQuery())
	->setViewer($viewer)
	->withPHIDs($file_phids)
	->execute();
	$files = mpull($files, null, 'getPHID');

	if ($old_phid) {
	$old_file = idx($files, $old_phid);
	if (!$old_file) {
	throw new Exception(
	pht(
	'Failed to load file data for changeset ("%s").',
	$old_phid));
	}
	$changeset->attachOldFileObject($old_file);
	}

	if ($new_phid) {
	$new_file = idx($files, $new_phid);
	if (!$new_file) {
	throw new Exception(
	pht(
	'Failed to load file data for changeset ("%s").',
	$new_phid));
	}
	$changeset->attachNewFileObject($new_file);
	}
	}

	return array($old_file, $new_file);
	}

	public function newChangesetResponse() {
	// NOTE: This has to happen first because it has side effects. Yuck.
	$rendered_changeset = $this->renderChangeset();

	$renderer = $this->getRenderer();
	$renderer_key = $renderer->getRendererKey();

	$viewstate = $this->getViewState();

	$undo_templates = $renderer->renderUndoTemplates();
	foreach ($undo_templates as $key => $undo_template) {
	$undo_templates[$key] = hsprintf('%s', $undo_template);
	}

	$document_engine = $renderer->getDocumentEngine();
	if ($document_engine) {
	$document_engine_key = $document_engine->getDocumentEngineKey();
	} else {
	$document_engine_key = null;
	}

	$available_keys = array();
	$engines = $this->availableDocumentEngines;
	if (!$engines) {
	$engines = array();
	}

	$available_keys = mpull($engines, 'getDocumentEngineKey');

	// TODO: Always include "source" as a usable engine to default to
	// the buitin rendering. This is kind of a hack and does not actually
	// use the source engine. The source engine isn't a diff engine, so
	// selecting it causes us to fall through and render with builtin
	// behavior. For now, overall behavir is reasonable.

	$available_keys[] = PhabricatorSourceDocumentEngine::ENGINEKEY;
	$available_keys = array_fuse($available_keys);
	$available_keys = array_values($available_keys);

	$state = array(
	'undoTemplates' => $undo_templates,
	'rendererKey' => $renderer_key,
	'highlight' => $viewstate->getHighlightLanguage(),
	'characterEncoding' => $viewstate->getCharacterEncoding(),
	'requestDocumentEngineKey' => $viewstate->getDocumentEngineKey(),
	'responseDocumentEngineKey' => $document_engine_key,
	'availableDocumentEngineKeys' => $available_keys,
	'isHidden' => $viewstate->getHidden(),
	);

	return id(new PhabricatorChangesetResponse())
	->setRenderedChangeset($rendered_changeset)
	->setChangesetState($state);
	}

	private function getRawDocumentEngineData(array $lines) {
	$text = array();

	foreach ($lines as $line) {
	if ($line === null) {
	continue;
	}

	// If this is a "No newline at end of file." annotation, don't hand it
	// off to the DocumentEngine.
	if ($line['type'] === '\\') {
	continue;
	}

	$text[] = $line['text'];
	}

	return implode('', $text);
	}

	}
	diff --git a/src/applications/differential/render/DifferentialChangesetTestRenderer.php b/src/applications/differential/render/DifferentialChangesetTestRenderer.php
	index 56b96dcbca..b4b2122e59 100644
	--- a/src/applications/differential/render/DifferentialChangesetTestRenderer.php
	+++ b/src/applications/differential/render/DifferentialChangesetTestRenderer.php
	@@ -1,137 +1,137 @@
	<?php

	abstract class DifferentialChangesetTestRenderer
	extends DifferentialChangesetRenderer {

	protected function renderChangeTypeHeader($force) {
	$changeset = $this->getChangeset();

	$old = nonempty($changeset->getOldFile(), '-');
	$current = nonempty($changeset->getFilename(), '-');
	$away = nonempty(implode(', ', $changeset->getAwayPaths()), '-');

	$ctype = $changeset->getChangeType();
	$ftype = $changeset->getFileType();
	$force = ($force ? '(forced)' : '(unforced)');

	return "CTYPE {$ctype} {$ftype} {$force}\n".
	"{$old}\n".
	"{$current}\n".
	"{$away}\n";
	}

	protected function renderUndershieldHeader() {
	return null;
	}

	public function renderShield($message, $force = 'default') {
	return "SHIELD ({$force}) {$message}\n";
	}

	protected function renderPropertyChangeHeader() {
	$changeset = $this->getChangeset();
	list($old, $new) = $this->getChangesetProperties($changeset);

	foreach (array_keys($old) as $key) {
	if ($old[$key] === idx($new, $key)) {
	unset($old[$key]);
	unset($new[$key]);
	}
	}

	if (!$old && !$new) {
	return null;
	}

	$props = '';
	foreach ($old as $key => $value) {
	$props .= "P - {$key} {$value}~\n";
	}
	foreach ($new as $key => $value) {
	$props .= "P + {$key} {$value}~\n";
	}

	return "PROPERTIES\n".$props;
	}

	public function renderTextChange(
	$range_start,
	$range_len,
	$rows) {

	$out = array();

	$any_old = false;
	$any_new = false;
	$primitives = $this->buildPrimitives($range_start, $range_len);
	foreach ($primitives as $p) {
	$type = $p['type'];
	switch ($type) {
	case 'old':
	case 'new':
	if ($type == 'old') {
	$any_old = true;
	}
	if ($type == 'new') {
	$any_new = true;
	}
	$num = nonempty($p['line'], '-');
	- $render = $p['render'];
	+ $render = (string)$p['render'];
	$htype = nonempty($p['htype'], '.');

	// TODO: This should probably happen earlier, whenever we deal with
	// \r and \t normalization?
	$render = str_replace(
	array(
	"\r",
	"\n",
	),
	array(
	'\\r',
	'\\n',
	),
	$render);

	$render = str_replace(
	array(
	'<span class="bright">',
	'</span>',
	'<span class="depth-out">',
	'<span class="depth-in">',
	),
	array(
	'{(',
	')}',
	'{<',
	'{>',
	),
	$render);

	$render = html_entity_decode($render, ENT_QUOTES);

	$t = ($type == 'old') ? 'O' : 'N';

	$out[] = "{$t} {$num} {$htype} {$render}~";
	break;
	case 'no-context':
	$out[] = 'X <MISSING-CONTEXT>';
	break;
	default:
	$out[] = $type;
	break;
	}
	}

	if (!$any_old) {
	$out[] = 'O X <EMPTY>';
	}

	if (!$any_new) {
	$out[] = 'N X <EMPTY>';
	}

	$out = implode("\n", $out)."\n";
	return phutil_safe_html($out);
	}

	}
	diff --git a/src/applications/differential/storage/DifferentialDiff.php b/src/applications/differential/storage/DifferentialDiff.php
	index 78025e44ec..dfa6d1f791 100644
	--- a/src/applications/differential/storage/DifferentialDiff.php
	+++ b/src/applications/differential/storage/DifferentialDiff.php
	@@ -1,834 +1,834 @@
	<?php

	final class DifferentialDiff
	extends DifferentialDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorExtendedPolicyInterface,
	HarbormasterBuildableInterface,
	HarbormasterCircleCIBuildableInterface,
	HarbormasterBuildkiteBuildableInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorDestructibleInterface,
	PhabricatorConduitResultInterface {

	protected $revisionID;
	protected $authorPHID;
	protected $repositoryPHID;
	protected $commitPHID;

	protected $sourceMachine;
	protected $sourcePath;

	protected $sourceControlSystem;
	protected $sourceControlBaseRevision;
	protected $sourceControlPath;

	protected $lintStatus;
	protected $unitStatus;

	protected $lineCount;

	protected $branch;
	protected $bookmark;

	protected $creationMethod;
	protected $repositoryUUID;

	protected $description;

	protected $viewPolicy;

	private $unsavedChangesets = array();
	private $changesets = self::ATTACHABLE;
	private $revision = self::ATTACHABLE;
	private $properties = self::ATTACHABLE;
	private $buildable = self::ATTACHABLE;

	private $unitMessages = self::ATTACHABLE;

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'revisionID' => 'id?',
	'authorPHID' => 'phid?',
	'repositoryPHID' => 'phid?',
	'sourceMachine' => 'text255?',
	'sourcePath' => 'text255?',
	'sourceControlSystem' => 'text64?',
	'sourceControlBaseRevision' => 'text255?',
	'sourceControlPath' => 'text255?',
	'lintStatus' => 'uint32',
	'unitStatus' => 'uint32',
	'lineCount' => 'uint32',
	'branch' => 'text255?',
	'bookmark' => 'text255?',
	'repositoryUUID' => 'text64?',
	'commitPHID' => 'phid?',

	// T6203/NULLABILITY
	// These should be non-null; all diffs should have a creation method
	// and the description should just be empty.
	'creationMethod' => 'text255?',
	'description' => 'text255?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'revisionID' => array(
	'columns' => array('revisionID'),
	),
	'key_commit' => array(
	'columns' => array('commitPHID'),
	),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	DifferentialDiffPHIDType::TYPECONST);
	}

	public function addUnsavedChangeset(DifferentialChangeset $changeset) {
	if ($this->changesets === null) {
	$this->changesets = array();
	}
	$this->unsavedChangesets[] = $changeset;
	$this->changesets[] = $changeset;
	return $this;
	}

	public function attachChangesets(array $changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');
	$this->changesets = $changesets;
	return $this;
	}

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

	public function loadChangesets() {
	if (!$this->getID()) {
	return array();
	}
	$changesets = id(new DifferentialChangeset())->loadAllWhere(
	'diffID = %d',
	$this->getID());

	foreach ($changesets as $changeset) {
	$changeset->attachDiff($this);
	}

	return $changesets;
	}

	public function save() {
	$this->openTransaction();
	$ret = parent::save();
	foreach ($this->unsavedChangesets as $changeset) {
	$changeset->setDiffID($this->getID());
	$changeset->save();
	}
	$this->saveTransaction();
	return $ret;
	}

	public static function initializeNewDiff(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorDifferentialApplication'))
	->executeOne();
	$view_policy = $app->getPolicy(
	DifferentialDefaultViewCapability::CAPABILITY);

	$diff = id(new DifferentialDiff())
	->setViewPolicy($view_policy);

	return $diff;
	}

	public static function newFromRawChanges(
	PhabricatorUser $actor,
	array $changes) {

	assert_instances_of($changes, 'ArcanistDiffChange');

	$diff = self::initializeNewDiff($actor);
	return self::buildChangesetsFromRawChanges($diff, $changes);
	}

	public static function newEphemeralFromRawChanges(array $changes) {
	assert_instances_of($changes, 'ArcanistDiffChange');

	$diff = id(new DifferentialDiff())->makeEphemeral();
	return self::buildChangesetsFromRawChanges($diff, $changes);
	}

	private static function buildChangesetsFromRawChanges(
	DifferentialDiff $diff,
	array $changes) {

	// There may not be any changes; initialize the changesets list so that
	// we don't throw later when accessing it.
	$diff->attachChangesets(array());

	$lines = 0;
	foreach ($changes as $change) {
	if ($change->getType() == ArcanistDiffChangeType::TYPE_MESSAGE) {
	// If a user pastes a diff into Differential which includes a commit
	// message (e.g., they ran `git show` to generate it), discard that
	// change when constructing a DifferentialDiff.
	continue;
	}

	$changeset = new DifferentialChangeset();
	$add_lines = 0;
	$del_lines = 0;
	$first_line = PHP_INT_MAX;
	$hunks = $change->getHunks();
	if ($hunks) {
	foreach ($hunks as $hunk) {
	$dhunk = new DifferentialHunk();
	$dhunk->setOldOffset($hunk->getOldOffset());
	$dhunk->setOldLen($hunk->getOldLength());
	$dhunk->setNewOffset($hunk->getNewOffset());
	$dhunk->setNewLen($hunk->getNewLength());
	$dhunk->setChanges($hunk->getCorpus());
	$changeset->addUnsavedHunk($dhunk);
	$add_lines += $hunk->getAddLines();
	$del_lines += $hunk->getDelLines();
	$added_lines = $hunk->getChangedLines('new');
	if ($added_lines) {
	$first_line = min($first_line, head_key($added_lines));
	}
	}
	$lines += $add_lines + $del_lines;
	} else {
	// This happens when you add empty files.
	$changeset->attachHunks(array());
	}

	$metadata = $change->getAllMetadata();
	if ($first_line != PHP_INT_MAX) {
	$metadata['line:first'] = $first_line;
	}

	$changeset->setOldFile($change->getOldPath());
	$changeset->setFilename($change->getCurrentPath());
	$changeset->setChangeType($change->getType());

	$changeset->setFileType($change->getFileType());
	$changeset->setMetadata($metadata);
	$changeset->setOldProperties($change->getOldProperties());
	$changeset->setNewProperties($change->getNewProperties());
	$changeset->setAwayPaths($change->getAwayPaths());
	$changeset->setAddLines($add_lines);
	$changeset->setDelLines($del_lines);

	$diff->addUnsavedChangeset($changeset);
	}
	$diff->setLineCount($lines);

	$changesets = $diff->getChangesets();

	// TODO: This is "safe", but it would be better to propagate a real user
	// down the stack.
	$viewer = PhabricatorUser::getOmnipotentUser();

	id(new DifferentialChangesetEngine())
	->setViewer($viewer)
	->rebuildChangesets($changesets);

	return $diff;
	}

	public function getDiffDict() {
	$dict = array(
	'id' => $this->getID(),
	'revisionID' => $this->getRevisionID(),
	'dateCreated' => $this->getDateCreated(),
	'dateModified' => $this->getDateModified(),
	'sourceControlBaseRevision' => $this->getSourceControlBaseRevision(),
	'sourceControlPath' => $this->getSourceControlPath(),
	'sourceControlSystem' => $this->getSourceControlSystem(),
	'branch' => $this->getBranch(),
	'bookmark' => $this->getBookmark(),
	'creationMethod' => $this->getCreationMethod(),
	'description' => $this->getDescription(),
	'unitStatus' => $this->getUnitStatus(),
	'lintStatus' => $this->getLintStatus(),
	'changes' => array(),
	);

	$dict['changes'] = $this->buildChangesList();

	return $dict + $this->getDiffAuthorshipDict();
	}

	public function getDiffAuthorshipDict() {
	$dict = array('properties' => array());

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	foreach ($properties as $property) {
	$dict['properties'][$property->getName()] = $property->getData();

	if ($property->getName() == 'local:commits') {
	foreach ($property->getData() as $commit) {
	$dict['authorName'] = $commit['author'];
	$dict['authorEmail'] = idx($commit, 'authorEmail');
	break;
	}
	}
	}

	return $dict;
	}

	public function buildChangesList() {
	$changes = array();
	foreach ($this->getChangesets() as $changeset) {
	$hunks = array();
	foreach ($changeset->getHunks() as $hunk) {
	$hunks[] = array(
	'oldOffset' => $hunk->getOldOffset(),
	'newOffset' => $hunk->getNewOffset(),
	'oldLength' => $hunk->getOldLen(),
	'newLength' => $hunk->getNewLen(),
	'addLines' => null,
	'delLines' => null,
	'isMissingOldNewline' => null,
	'isMissingNewNewline' => null,
	'corpus' => $hunk->getChanges(),
	);
	}
	$change = array(
	'id' => $changeset->getID(),
	'metadata' => $changeset->getMetadata(),
	'oldPath' => $changeset->getOldFile(),
	'currentPath' => $changeset->getFilename(),
	'awayPaths' => $changeset->getAwayPaths(),
	'oldProperties' => $changeset->getOldProperties(),
	'newProperties' => $changeset->getNewProperties(),
	'type' => $changeset->getChangeType(),
	'fileType' => $changeset->getFileType(),
	'commitHash' => null,
	'addLines' => $changeset->getAddLines(),
	'delLines' => $changeset->getDelLines(),
	'hunks' => $hunks,
	);
	$changes[] = $change;
	}
	return $changes;
	}

	public function hasRevision() {
	return $this->revision !== self::ATTACHABLE;
	}

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

	public function attachRevision(DifferentialRevision $revision = null) {
	$this->revision = $revision;
	return $this;
	}

	public function attachProperty($key, $value) {
	if (!is_array($this->properties)) {
	$this->properties = array();
	}
	$this->properties[$key] = $value;
	return $this;
	}

	public function getProperty($key) {
	return $this->assertAttachedKey($this->properties, $key);
	}

	public function hasDiffProperty($key) {
	$properties = $this->getDiffProperties();
	return array_key_exists($key, $properties);
	}

	public function attachDiffProperties(array $properties) {
	$this->properties = $properties;
	return $this;
	}

	public function getDiffProperties() {
	return $this->assertAttached($this->properties);
	}

	public function attachBuildable(HarbormasterBuildable $buildable = null) {
	$this->buildable = $buildable;
	return $this;
	}

	public function getBuildable() {
	return $this->assertAttached($this->buildable);
	}

	public function getBuildTargetPHIDs() {
	$buildable = $this->getBuildable();

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

	$target_phids = array();
	foreach ($buildable->getBuilds() as $build) {
	foreach ($build->getBuildTargets() as $target) {
	$target_phids[] = $target->getPHID();
	}
	}

	return $target_phids;
	}

	public function loadCoverageMap(PhabricatorUser $viewer) {
	$target_phids = $this->getBuildTargetPHIDs();
	if (!$target_phids) {
	return array();
	}

	$unit = id(new HarbormasterBuildUnitMessageQuery())
	->setViewer($viewer)
	->withBuildTargetPHIDs($target_phids)
	->execute();

	$map = array();
	foreach ($unit as $message) {
	$coverage = $message->getProperty('coverage', array());
	foreach ($coverage as $path => $coverage_data) {
	$map[$path][] = $coverage_data;
	}
	}

	foreach ($map as $path => $coverage_items) {
	$map[$path] = ArcanistUnitTestResult::mergeCoverage($coverage_items);
	}

	return $map;
	}

	public function getURI() {
	$id = $this->getID();
	return "/differential/diff/{$id}/";
	}


	public function attachUnitMessages(array $unit_messages) {
	$this->unitMessages = $unit_messages;
	return $this;
	}


	public function getUnitMessages() {
	return $this->assertAttached($this->unitMessages);
	}


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


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

	public function getPolicy($capability) {
	if ($this->hasRevision()) {
	return PhabricatorPolicies::getMostOpenPolicy();
	}

	return $this->viewPolicy;
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	if ($this->hasRevision()) {
	return $this->getRevision()->hasAutomaticCapability($capability, $viewer);
	}

	return ($this->getAuthorPHID() == $viewer->getPHID());
	}

	public function describeAutomaticCapability($capability) {
	if ($this->hasRevision()) {
	return pht(
	'This diff is attached to a revision, and inherits its policies.');
	}

	return pht('The author of a diff can see it.');
	}


	/* -( PhabricatorExtendedPolicyInterface )--------------------------------- */


	public function getExtendedPolicy($capability, PhabricatorUser $viewer) {
	$extended = array();

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	if ($this->hasRevision()) {
	$extended[] = array(
	$this->getRevision(),
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	} else if ($this->getRepositoryPHID()) {
	$extended[] = array(
	$this->getRepositoryPHID(),
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}
	break;
	}

	return $extended;
	}


	/* -( HarbormasterBuildableInterface )------------------------------------- */


	public function getHarbormasterBuildableDisplayPHID() {
	$container_phid = $this->getHarbormasterContainerPHID();
	if ($container_phid) {
	return $container_phid;
	}

	return $this->getHarbormasterBuildablePHID();
	}

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

	public function getHarbormasterContainerPHID() {
	if ($this->getRevisionID()) {
	$revision = id(new DifferentialRevision())->load($this->getRevisionID());
	if ($revision) {
	return $revision->getPHID();
	}
	}

	return null;
	}

	public function getBuildVariables() {
	$results = array();

	$results['buildable.diff'] = $this->getID();
	if ($this->revisionID) {
	$revision = $this->getRevision();
	$results['buildable.revision'] = $revision->getID();
	$repo = $revision->getRepository();

	if ($repo) {
	$results['repository.callsign'] = $repo->getCallsign();
	$results['repository.phid'] = $repo->getPHID();
	$results['repository.vcs'] = $repo->getVersionControlSystem();
	$results['repository.uri'] = $repo->getPublicCloneURI();

	$results['repository.staging.uri'] = $repo->getStagingURI();
	$results['repository.staging.ref'] = $this->getStagingRef();
	}
	}

	return $results;
	}

	public function getAvailableBuildVariables() {
	return array(
	'buildable.diff' =>
	pht('The differential diff ID, if applicable.'),
	'buildable.revision' =>
	pht('The differential revision ID, if applicable.'),
	'repository.callsign' =>
	- pht('The callsign of the repository in Phabricator.'),
	+ pht('The callsign of the repository.'),
	'repository.phid' =>
	- pht('The PHID of the repository in Phabricator.'),
	+ pht('The PHID of the repository.'),
	'repository.vcs' =>
	pht('The version control system, either "svn", "hg" or "git".'),
	'repository.uri' =>
	pht('The URI to clone or checkout the repository from.'),
	'repository.staging.uri' =>
	pht('The URI of the staging repository.'),
	'repository.staging.ref' =>
	pht('The ref name for this change in the staging repository.'),
	);
	}

	public function newBuildableEngine() {
	return new DifferentialBuildableEngine();
	}


	/* -( HarbormasterCircleCIBuildableInterface )----------------------------- */


	public function getCircleCIGitHubRepositoryURI() {
	$diff_phid = $this->getPHID();
	$repository_phid = $this->getRepositoryPHID();
	if (!$repository_phid) {
	throw new Exception(
	pht(
	'This diff ("%s") is not associated with a repository. A diff '.
	'must belong to a tracked repository to be built by CircleCI.',
	$diff_phid));
	}

	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(array($repository_phid))
	->executeOne();
	if (!$repository) {
	throw new Exception(
	pht(
	'This diff ("%s") is associated with a repository ("%s") which '.
	'could not be loaded.',
	$diff_phid,
	$repository_phid));
	}

	$staging_uri = $repository->getStagingURI();
	if (!$staging_uri) {
	throw new Exception(
	pht(
	'This diff ("%s") is associated with a repository ("%s") that '.
	'does not have a Staging Area configured. You must configure a '.
	'Staging Area to use CircleCI integration.',
	$diff_phid,
	$repository_phid));
	}

	$path = HarbormasterCircleCIBuildStepImplementation::getGitHubPath(
	$staging_uri);
	if (!$path) {
	throw new Exception(
	pht(
	'This diff ("%s") is associated with a repository ("%s") that '.
	'does not have a Staging Area ("%s") that is hosted on GitHub. '.
	'CircleCI can only build from GitHub, so the Staging Area for '.
	'the repository must be hosted there.',
	$diff_phid,
	$repository_phid,
	$staging_uri));
	}

	return $staging_uri;
	}

	public function getCircleCIBuildIdentifierType() {
	return 'tag';
	}

	public function getCircleCIBuildIdentifier() {
	$ref = $this->getStagingRef();
	$ref = preg_replace('(^refs/tags/)', '', $ref);
	return $ref;
	}


	/* -( HarbormasterBuildkiteBuildableInterface )---------------------------- */

	public function getBuildkiteBranch() {
	$ref = $this->getStagingRef();

	// NOTE: Circa late January 2017, Buildkite fails with the error message
	// "Tags have been disabled for this project" if we pass the "refs/tags/"
	// prefix via the API and the project doesn't have GitHub tag builds
	// enabled, even if GitHub builds are disabled. The tag builds fine
	// without this prefix.
	$ref = preg_replace('(^refs/tags/)', '', $ref);

	return $ref;
	}

	public function getBuildkiteCommit() {
	return 'HEAD';
	}


	public function getStagingRef() {
	// TODO: We're just hoping to get lucky. Instead, `arc` should store
	// where it sent changes and we should only provide staging details
	// if we reasonably believe they are accurate.
	return 'refs/tags/phabricator/diff/'.$this->getID();
	}

	public function loadTargetBranch() {
	// TODO: This is sketchy, but just eat the query cost until this can get
	// cleaned up.

	// For now, we're only returning a target if there's exactly one and it's
	// a branch, since we don't support landing to more esoteric targets like
	// tags yet.

	$property = id(new DifferentialDiffProperty())->loadOneWhere(
	'diffID = %d AND name = %s',
	$this->getID(),
	'arc:onto');
	if (!$property) {
	return null;
	}

	$data = $property->getData();

	if (!$data) {
	return null;
	}

	if (!is_array($data)) {
	return null;
	}

	if (count($data) != 1) {
	return null;
	}

	$onto = head($data);
	if (!is_array($onto)) {
	return null;
	}

	$type = idx($onto, 'type');
	if ($type != 'branch') {
	return null;
	}

	return idx($onto, 'name');
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new DifferentialDiffEditor();
	}

	public function getApplicationTransactionTemplate() {
	return new DifferentialDiffTransaction();
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$viewer = $engine->getViewer();

	$this->openTransaction();
	$this->delete();

	foreach ($this->loadChangesets() as $changeset) {
	$engine->destroyObject($changeset);
	}

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	foreach ($properties as $prop) {
	$prop->delete();
	}

	$viewstate_query = id(new DifferentialViewStateQuery())
	->setViewer($viewer)
	->withObjectPHIDs(array($this->getPHID()));
	$viewstates = new PhabricatorQueryIterator($viewstate_query);
	foreach ($viewstates as $viewstate) {
	$viewstate->delete();
	}

	$this->saveTransaction();
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('revisionPHID')
	->setType('phid')
	->setDescription(pht('Associated revision PHID.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('authorPHID')
	->setType('phid')
	->setDescription(pht('Revision author PHID.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('repositoryPHID')
	->setType('phid')
	->setDescription(pht('Associated repository PHID.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('refs')
	->setType('map<string, wild>')
	->setDescription(pht('List of related VCS references.')),
	);
	}

	public function getFieldValuesForConduit() {
	$refs = array();

	$branch = $this->getBranch();
	if (strlen($branch)) {
	$refs[] = array(
	'type' => 'branch',
	'name' => $branch,
	);
	}

	$onto = $this->loadTargetBranch();
	if (strlen($onto)) {
	$refs[] = array(
	'type' => 'onto',
	'name' => $onto,
	);
	}

	$base = $this->getSourceControlBaseRevision();
	if (strlen($base)) {
	$refs[] = array(
	'type' => 'base',
	'identifier' => $base,
	);
	}

	$bookmark = $this->getBookmark();
	if (strlen($bookmark)) {
	$refs[] = array(
	'type' => 'bookmark',
	'name' => $bookmark,
	);
	}

	$revision_phid = null;
	if ($this->getRevisionID()) {
	$revision_phid = $this->getRevision()->getPHID();
	}

	return array(
	'revisionPHID' => $revision_phid,
	'authorPHID' => $this->getAuthorPHID(),
	'repositoryPHID' => $this->getRepositoryPHID(),
	'refs' => $refs,
	);
	}

	public function getConduitSearchAttachments() {
	return array(
	id(new DifferentialCommitsSearchEngineAttachment())
	->setAttachmentKey('commits'),
	);
	}

	}
	diff --git a/src/applications/diffusion/management/DiffusionRepositoryURIsManagementPanel.php b/src/applications/diffusion/management/DiffusionRepositoryURIsManagementPanel.php
	index a795c955a7..c4ce110c5d 100644
	--- a/src/applications/diffusion/management/DiffusionRepositoryURIsManagementPanel.php
	+++ b/src/applications/diffusion/management/DiffusionRepositoryURIsManagementPanel.php
	@@ -1,160 +1,160 @@
	<?php

	final class DiffusionRepositoryURIsManagementPanel
	extends DiffusionRepositoryManagementPanel {

	const PANELKEY = 'uris';

	public function getManagementPanelLabel() {
	return pht('URIs');
	}

	public function getManagementPanelIcon() {
	return 'fa-globe';
	}

	public function getManagementPanelOrder() {
	return 400;
	}

	public function buildManagementPanelCurtain() {
	$repository = $this->getRepository();
	$viewer = $this->getViewer();
	$action_list = $this->newActionList();

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$repository,
	PhabricatorPolicyCapability::CAN_EDIT);

	$doc_href = PhabricatorEnv::getDoclink('Diffusion User Guide: URIs');
	$add_href = $repository->getPathURI('uri/edit/');

	$action_list->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-plus')
	->setHref($add_href)
	->setDisabled(!$can_edit)
	->setName(pht('Add New URI')));

	$action_list->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-book')
	->setHref($doc_href)
	->setName(pht('URI Documentation')));

	return $this->newCurtainView()
	->setActionList($action_list);
	}

	public function buildManagementPanelContent() {
	$repository = $this->getRepository();
	$viewer = $this->getViewer();
	$uris = $repository->getURIs();

	Javelin::initBehavior('phabricator-tooltips');
	$rows = array();
	foreach ($uris as $uri) {

	$uri_name = $uri->getDisplayURI();
	$uri_name = phutil_tag(
	'a',
	array(
	'href' => $uri->getViewURI(),
	),
	$uri_name);

	if ($uri->getIsDisabled()) {
	$status_icon = 'fa-times grey';
	} else {
	$status_icon = 'fa-check green';
	}

	$uri_status = id(new PHUIIconView())->setIcon($status_icon);

	$io_type = $uri->getEffectiveIOType();
	$io_map = PhabricatorRepositoryURI::getIOTypeMap();
	$io_spec = idx($io_map, $io_type, array());

	$io_icon = idx($io_spec, 'icon');
	$io_color = idx($io_spec, 'color');
	$io_label = idx($io_spec, 'label', $io_type);

	$uri_io = array(
	id(new PHUIIconView())->setIcon("{$io_icon} {$io_color}"),
	' ',
	$io_label,
	);

	$display_type = $uri->getEffectiveDisplayType();
	$display_map = PhabricatorRepositoryURI::getDisplayTypeMap();
	$display_spec = idx($display_map, $display_type, array());

	$display_icon = idx($display_spec, 'icon');
	$display_color = idx($display_spec, 'color');
	$display_label = idx($display_spec, 'label', $display_type);

	$uri_display = array(
	id(new PHUIIconView())->setIcon("{$display_icon} {$display_color}"),
	' ',
	$display_label,
	);

	$rows[] = array(
	$uri_status,
	$uri_name,
	$uri_io,
	$uri_display,
	);
	}

	$table = id(new AphrontTableView($rows))
	->setNoDataString(pht('This repository has no URIs.'))
	->setHeaders(
	array(
	null,
	pht('URI'),
	pht('I/O'),
	pht('Display'),
	))
	->setColumnClasses(
	array(
	null,
	'pri wide',
	null,
	null,
	));

	$is_new = $repository->isNewlyInitialized();

	$messages = array();
	if ($repository->isHosted()) {
	if ($is_new) {
	- $host_message = pht('Phabricator will host this repository.');
	+ $host_message = pht('This repository will be hosted.');
	} else {
	- $host_message = pht('Phabricator is hosting this repository.');
	+ $host_message = pht('This repository is observed.');
	}

	$messages[] = $host_message;
	} else {
	if ($is_new) {
	$observe_message = pht(
	- 'Phabricator will observe a remote repository.');
	+ 'This repository will be observed.');
	} else {
	$observe_message = pht(
	- 'This repository is hosted remotely. Phabricator is observing it.');
	+ 'This remote repository is being observed.');
	}

	$messages[] = $observe_message;
	}

	$info_view = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_NOTICE)
	->setErrors($messages);

	$box = $this->newBox(pht('Repository URIs'), $table);

	return array($info_view, $box);
	}

	}
	diff --git a/src/applications/doorkeeper/worker/DoorkeeperFeedWorker.php b/src/applications/doorkeeper/worker/DoorkeeperFeedWorker.php
	index 404ee348f7..8bbcc0f4fa 100644
	--- a/src/applications/doorkeeper/worker/DoorkeeperFeedWorker.php
	+++ b/src/applications/doorkeeper/worker/DoorkeeperFeedWorker.php
	@@ -1,203 +1,203 @@
	<?php

	/**
	* Publish events (like comments on a revision) to external objects which are
	* linked through Doorkeeper (like a linked JIRA or Asana task).
	*
	* These workers are invoked by feed infrastructure during normal task queue
	* operations. They read feed stories and publish information about them to
	* external systems, generally mirroring comments and updates in Phabricator
	* into remote systems by making API calls.
	*
	* @task publish Publishing Stories
	* @task context Story Context
	* @task internal Internals
	*/
	abstract class DoorkeeperFeedWorker extends FeedPushWorker {

	private $publisher;
	private $feedStory;
	private $storyObject;


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


	/**
	* Actually publish the feed story. Subclasses will generally make API calls
	* to publish some version of the story into external systems.
	*
	* @return void
	* @task publish
	*/
	abstract protected function publishFeedStory();


	/**
	* Enable or disable the worker. Normally, this checks configuration to
	* see if Phabricator is linked to applicable external systems.
	*
	* @return bool True if this worker should try to publish stories.
	* @task publish
	*/
	abstract public function isEnabled();


	/* -( Story Context )------------------------------------------------------ */


	/**
	* Get the @{class:PhabricatorFeedStory} that should be published.
	*
	* @return PhabricatorFeedStory The story to publish.
	* @task context
	*/
	protected function getFeedStory() {
	if (!$this->feedStory) {
	$story = $this->loadFeedStory();
	$this->feedStory = $story;
	}
	return $this->feedStory;
	}


	/**
	* Get the viewer for the act of publishing.
	*
	* NOTE: Publishing currently uses the omnipotent viewer because it depends
	* on loading external accounts. Possibly we should tailor this. See T3732.
	* Using the actor for most operations might make more sense.
	*
	* @return PhabricatorUser Viewer.
	* @task context
	*/
	protected function getViewer() {
	return PhabricatorUser::getOmnipotentUser();
	}


	/**
	* Get the @{class:DoorkeeperFeedStoryPublisher} which handles this object.
	*
	* @return DoorkeeperFeedStoryPublisher Object publisher.
	* @task context
	*/
	protected function getPublisher() {
	return $this->publisher;
	}


	/**
	* Get the primary object the story is about, like a
	* @{class:DifferentialRevision} or @{class:ManiphestTask}.
	*
	* @return object Object which the story is about.
	* @task context
	*/
	protected function getStoryObject() {
	if (!$this->storyObject) {
	$story = $this->getFeedStory();
	try {
	$object = $story->getPrimaryObject();
	} catch (Exception $ex) {
	throw new PhabricatorWorkerPermanentFailureException(
	$ex->getMessage());
	}
	$this->storyObject = $object;
	}
	return $this->storyObject;
	}


	/* -( Internals )---------------------------------------------------------- */


	/**
	* Load the @{class:DoorkeeperFeedStoryPublisher} which corresponds to this
	* object. Publishers provide a common API for pushing object updates into
	* foreign systems.
	*
	* @return DoorkeeperFeedStoryPublisher Publisher for the story's object.
	* @task internal
	*/
	private function loadPublisher() {
	$story = $this->getFeedStory();
	$viewer = $this->getViewer();
	$object = $this->getStoryObject();

	$publishers = id(new PhutilClassMapQuery())
	->setAncestorClass('DoorkeeperFeedStoryPublisher')
	->execute();

	foreach ($publishers as $publisher) {
	if (!$publisher->canPublishStory($story, $object)) {
	continue;
	}

	$publisher
	->setViewer($viewer)
	->setFeedStory($story);

	$object = $publisher->willPublishStory($object);
	$this->storyObject = $object;

	$this->publisher = $publisher;
	break;
	}

	return $this->publisher;
	}


	/* -( Inherited )---------------------------------------------------------- */


	/**
	* Doorkeeper workers set up some context, then call
	* @{method:publishFeedStory}.
	*/
	final protected function doWork() {
	if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
	- $this->log("%s\n", pht('Phabricator is running in silent mode.'));
	+ $this->log("%s\n", pht('This software is running in silent mode.'));
	return;
	}

	if (!$this->isEnabled()) {
	$this->log(
	"%s\n",
	pht("Doorkeeper worker '%s' is not enabled.", get_class($this)));
	return;
	}

	$publisher = $this->loadPublisher();
	if (!$publisher) {
	$this->log("%s\n", pht('Story is about an unsupported object type.'));
	return;
	} else {
	$this->log("%s\n", pht("Using publisher '%s'.", get_class($publisher)));
	}

	$this->publishFeedStory();
	}


	/**
	* By default, Doorkeeper workers perform a small number of retries with
	* exponential backoff. A consideration in this policy is that many of these
	* workers are laden with side effects.
	*/
	public function getMaximumRetryCount() {
	return 4;
	}


	/**
	* See @{method:getMaximumRetryCount} for a description of Doorkeeper
	* retry defaults.
	*/
	public function getWaitBeforeRetry(PhabricatorWorkerTask $task) {
	$count = $task->getFailureCount();
	return (5 * 60) * pow(8, $count);
	}

	}
	diff --git a/src/applications/feed/config/PhabricatorFeedConfigOptions.php b/src/applications/feed/config/PhabricatorFeedConfigOptions.php
	index 29c5a9549b..eac6a097ae 100644
	--- a/src/applications/feed/config/PhabricatorFeedConfigOptions.php
	+++ b/src/applications/feed/config/PhabricatorFeedConfigOptions.php
	@@ -1,42 +1,42 @@
	<?php

	final class PhabricatorFeedConfigOptions
	extends PhabricatorApplicationConfigOptions {

	public function getName() {
	return pht('Feed');
	}

	public function getDescription() {
	return pht('Feed options.');
	}

	public function getIcon() {
	return 'fa-newspaper-o';
	}

	public function getGroup() {
	return 'apps';
	}

	public function getOptions() {
	$hooks_help = $this->deformat(pht(<<<EODOC
	IMPORTANT: Feed hooks are deprecated and have been replaced by Webhooks.

	You can configure Webhooks in Herald. This configuration option will be removed
	-in a future version of Phabricator.
	+in a future version of the software.

	(This legacy option may be configured with a list of URIs; feed stories will
	send to these URIs.)
	EODOC
	));

	return array(
	$this->newOption('feed.http-hooks', 'list<string>', array())
	->setLocked(true)
	->setSummary(pht('Deprecated.'))
	->setDescription($hooks_help),
	);
	}

	}
	diff --git a/src/applications/files/document/PhabricatorDocumentRef.php b/src/applications/files/document/PhabricatorDocumentRef.php
	index 12d9f4f2fd..98dfda8856 100644
	--- a/src/applications/files/document/PhabricatorDocumentRef.php
	+++ b/src/applications/files/document/PhabricatorDocumentRef.php
	@@ -1,202 +1,207 @@
	<?php

	final class PhabricatorDocumentRef
	extends Phobject {

	private $name;
	private $mimeType;
	private $file;
	private $byteLength;
	private $snippet;
	private $symbolMetadata = array();
	private $blameURI;
	private $coverage = array();
	private $data;

	public function setFile(PhabricatorFile $file) {
	$this->file = $file;
	return $this;
	}

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

	public function setMimeType($mime_type) {
	$this->mimeType = $mime_type;
	return $this;
	}

	public function getMimeType() {
	if ($this->mimeType !== null) {
	return $this->mimeType;
	}

	if ($this->file) {
	return $this->file->getMimeType();
	}

	return null;
	}

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

	public function getName() {
	if ($this->name !== null) {
	return $this->name;
	}

	if ($this->file) {
	return $this->file->getName();
	}

	return null;
	}

	public function setByteLength($length) {
	$this->byteLength = $length;
	return $this;
	}

	public function getByteLength() {
	if ($this->byteLength !== null) {
	return $this->byteLength;
	}

	if ($this->data !== null) {
	return strlen($this->data);
	}

	if ($this->file) {
	return (int)$this->file->getByteSize();
	}

	return null;
	}

	public function setData($data) {
	$this->data = $data;
	return $this;
	}

	public function loadData($begin = null, $end = null) {
	if ($this->data !== null) {
	$data = $this->data;

	if ($begin !== null && $end !== null) {
	$data = substr($data, $begin, $end - $begin);
	} else if ($begin !== null) {
	$data = substr($data, $begin);
	} else if ($end !== null) {
	$data = substr($data, 0, $end);
	}

	return $data;
	}

	if ($this->file) {
	$iterator = $this->file->getFileDataIterator($begin, $end);

	$result = '';
	foreach ($iterator as $chunk) {
	$result .= $chunk;
	}
	return $result;
	}

	throw new PhutilMethodNotImplementedException();
	}

	public function hasAnyMimeType(array $candidate_types) {
	$mime_full = $this->getMimeType();
	+
	+ if (!phutil_nonempty_string($mime_full)) {
	+ return false;
	+ }
	+
	$mime_parts = explode(';', $mime_full);

	$mime_type = head($mime_parts);
	$mime_type = $this->normalizeMimeType($mime_type);

	foreach ($candidate_types as $candidate_type) {
	if ($this->normalizeMimeType($candidate_type) === $mime_type) {
	return true;
	}
	}

	return false;
	}

	private function normalizeMimeType($mime_type) {
	$mime_type = trim($mime_type);
	$mime_type = phutil_utf8_strtolower($mime_type);
	return $mime_type;
	}

	public function isProbablyText() {
	$snippet = $this->getSnippet();
	return (strpos($snippet, "\0") === false);
	}

	public function isProbablyJSON() {
	if (!$this->isProbablyText()) {
	return false;
	}

	$snippet = $this->getSnippet();

	// If the file is longer than the snippet, we don't detect the content
	// as JSON. We could use some kind of heuristic here if we wanted, but
	// see PHI749 for a false positive.
	if (strlen($snippet) < $this->getByteLength()) {
	return false;
	}

	// If the snippet is the whole file, just check if the snippet is valid
	// JSON. Note that `phutil_json_decode()` only accepts arrays and objects
	// as JSON, so this won't misfire on files with content like "3".
	try {
	phutil_json_decode($snippet);
	return true;
	} catch (Exception $ex) {
	return false;
	}
	}

	public function getSnippet() {
	if ($this->snippet === null) {
	$this->snippet = $this->loadData(null, (1024 * 1024 * 1));
	}

	return $this->snippet;
	}

	public function setSymbolMetadata(array $metadata) {
	$this->symbolMetadata = $metadata;
	return $this;
	}

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

	public function setBlameURI($blame_uri) {
	$this->blameURI = $blame_uri;
	return $this;
	}

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

	public function addCoverage($coverage) {
	$this->coverage[] = array(
	'data' => $coverage,
	);
	return $this;
	}

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

	}
	diff --git a/src/applications/files/document/PhabricatorJSONDocumentEngine.php b/src/applications/files/document/PhabricatorJSONDocumentEngine.php
	index 42f4469ee6..9797ce3da2 100644
	--- a/src/applications/files/document/PhabricatorJSONDocumentEngine.php
	+++ b/src/applications/files/document/PhabricatorJSONDocumentEngine.php
	@@ -1,77 +1,81 @@
	<?php

	final class PhabricatorJSONDocumentEngine
	extends PhabricatorTextDocumentEngine {

	const ENGINEKEY = 'json';

	public function getViewAsLabel(PhabricatorDocumentRef $ref) {
	return pht('View as JSON');
	}

	protected function getDocumentIconIcon(PhabricatorDocumentRef $ref) {
	return 'fa-database';
	}

	protected function getContentScore(PhabricatorDocumentRef $ref) {
	- if (preg_match('/\.json\z/', $ref->getName())) {
	- return 2000;
	+
	+ $name = $ref->getName();
	+ if ($name !== null) {
	+ if (preg_match('/\.json\z/', $name)) {
	+ return 2000;
	+ }
	}

	if ($ref->isProbablyJSON()) {
	return 1750;
	}

	return 500;
	}

	protected function newDocumentContent(PhabricatorDocumentRef $ref) {
	$raw_data = $this->loadTextData($ref);

	try {
	$data = phutil_json_decode($raw_data);

	// See T13635. "phutil_json_decode()" always turns JSON into a PHP array,
	// and we lose the distinction between "{}" and "[]". This distinction is
	// important when rendering a document.
	$data = json_decode($raw_data, false);
	if (!$data) {
	throw new PhabricatorDocumentEngineParserException(
	pht(
	'Failed to "json_decode(...)" JSON document after successfully '.
	'decoding it with "phutil_json_decode(...).'));
	}

	if (preg_match('/^\s*\[/', $raw_data)) {
	$content = id(new PhutilJSON())->encodeAsList($data);
	} else {
	$content = id(new PhutilJSON())->encodeFormatted($data);
	}

	$message = null;
	$content = PhabricatorSyntaxHighlighter::highlightWithLanguage(
	'json',
	$content);
	} catch (PhutilJSONParserException $ex) {
	$message = $this->newMessage(
	pht(
	'This document is not valid JSON: %s',
	$ex->getMessage()));

	$content = $raw_data;
	} catch (PhabricatorDocumentEngineParserException $ex) {
	$message = $this->newMessage(
	pht(
	'Unable to parse this document as JSON: %s',
	$ex->getMessage()));

	$content = $raw_data;
	}

	return array(
	$message,
	$this->newTextDocumentContent($ref, $content),
	);
	}

	}
	diff --git a/src/applications/files/document/PhabricatorRemarkupDocumentEngine.php b/src/applications/files/document/PhabricatorRemarkupDocumentEngine.php
	index 296b78196f..053640af5f 100644
	--- a/src/applications/files/document/PhabricatorRemarkupDocumentEngine.php
	+++ b/src/applications/files/document/PhabricatorRemarkupDocumentEngine.php
	@@ -1,47 +1,50 @@
	<?php

	final class PhabricatorRemarkupDocumentEngine
	extends PhabricatorDocumentEngine {

	const ENGINEKEY = 'remarkup';

	public function getViewAsLabel(PhabricatorDocumentRef $ref) {
	return pht('View as Remarkup');
	}

	protected function getDocumentIconIcon(PhabricatorDocumentRef $ref) {
	return 'fa-file-text-o';
	}

	protected function getContentScore(PhabricatorDocumentRef $ref) {
	$name = $ref->getName();
	- if (preg_match('/\\.remarkup\z/i', $name)) {
	- return 2000;
	+
	+ if ($name !== null) {
	+ if (preg_match('/\\.remarkup\z/i', $name)) {
	+ return 2000;
	+ }
	}

	return 500;
	}

	protected function canRenderDocumentType(PhabricatorDocumentRef $ref) {
	return $ref->isProbablyText();
	}

	protected function newDocumentContent(PhabricatorDocumentRef $ref) {
	$viewer = $this->getViewer();

	$content = $ref->loadData();
	$content = phutil_utf8ize($content);

	$remarkup = new PHUIRemarkupView($viewer, $content);

	$container = phutil_tag(
	'div',
	array(
	'class' => 'document-engine-remarkup',
	),
	$remarkup);

	return $container;
	}

	}
	diff --git a/src/applications/guides/module/PhabricatorGuideInstallModule.php b/src/applications/guides/module/PhabricatorGuideInstallModule.php
	index 172ff7a17b..2299bce260 100644
	--- a/src/applications/guides/module/PhabricatorGuideInstallModule.php
	+++ b/src/applications/guides/module/PhabricatorGuideInstallModule.php
	@@ -1,179 +1,180 @@
	<?php

	final class PhabricatorGuideInstallModule extends PhabricatorGuideModule {

	public function getModuleKey() {
	return 'install';
	}

	public function getModuleName() {
	- return pht('Install Phabricator');
	+ return pht('Install');
	}

	public function getModulePosition() {
	return 20;
	}

	public function getIsModuleEnabled() {
	if (PhabricatorEnv::getEnvConfig('cluster.instance')) {
	return false;
	}
	return true;
	}

	public function renderModuleStatus(AphrontRequest $request) {
	$viewer = $request->getViewer();

	$guide_items = new PhabricatorGuideListView();

	$title = pht('Resolve Setup Issues');
	$issues_resolved = !PhabricatorSetupCheck::getOpenSetupIssueKeys();
	$href = PhabricatorEnv::getURI('/config/issue/');
	if ($issues_resolved) {
	$icon = 'fa-check';
	$icon_bg = 'bg-green';
	$description = pht(
	"You've resolved (or ignored) all outstanding setup issues.");
	} else {
	$icon = 'fa-warning';
	$icon_bg = 'bg-red';
	$description =
	pht('You have some unresolved setup issues to take care of.');
	}

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);
	$guide_items->addItem($item);

	$configs = id(new PhabricatorAuthProviderConfigQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->execute();

	$title = pht('Login and Registration');
	$href = PhabricatorEnv::getURI('/auth/');
	$have_auth = (bool)$configs;
	if ($have_auth) {
	$icon = 'fa-check';
	$icon_bg = 'bg-green';
	$description = pht(
	"You've configured at least one authentication provider.");
	} else {
	$icon = 'fa-key';
	$icon_bg = 'bg-sky';
	$description = pht(
	'Authentication providers allow users to register accounts and '.
	- 'log in to Phabricator.');
	+ 'log in.');
	}

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);
	$guide_items->addItem($item);


	- $title = pht('Configure Phabricator');
	+ $title = pht('Configure');
	$href = PhabricatorEnv::getURI('/config/');

	// Just load any config value at all; if one exists the install has figured
	// out how to configure things.
	$have_config = (bool)id(new PhabricatorConfigEntry())->loadAllWhere(
	'1 = 1 LIMIT 1');

	if ($have_config) {
	$icon = 'fa-check';
	$icon_bg = 'bg-green';
	$description = pht(
	"You've configured at least one setting from the web interface.");
	} else {
	$icon = 'fa-sliders';
	$icon_bg = 'bg-sky';
	$description = pht(
	- 'Learn how to configure mail and other options in Phabricator.');
	+ 'Learn how to configure mail and other options.');
	}

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);
	$guide_items->addItem($item);


	$title = pht('User Account Settings');
	$href = PhabricatorEnv::getURI('/settings/');
	$preferences = id(new PhabricatorUserPreferencesQuery())
	->setViewer($viewer)
	->withUsers(array($viewer))
	->executeOne();

	$have_settings = ($preferences && $preferences->getPreferences());
	if ($have_settings) {
	$icon = 'fa-check';
	$icon_bg = 'bg-green';
	$description = pht(
	"You've adjusted at least one setting on your account.");
	} else {
	$icon = 'fa-wrench';
	$icon_bg = 'bg-sky';
	$description = pht(
	'Configure account settings for all users, or just yourself');
	}

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);
	$guide_items->addItem($item);


	$title = pht('Notification Server');
	$href = PhabricatorEnv::getURI('/config/edit/notification.servers/');
	$have_notifications = PhabricatorEnv::getEnvConfig('notification.servers');
	if ($have_notifications) {
	$icon = 'fa-check';
	$icon_bg = 'bg-green';
	$description = pht(
	"You've set up a real-time notification server.");
	} else {
	$icon = 'fa-bell';
	$icon_bg = 'bg-sky';
	$description = pht(
	- 'Phabricator can deliver notifications in real-time with WebSockets.');
	+ 'Real-time notifications can be delivered with WebSockets.');
	}

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);

	$guide_items->addItem($item);

	$intro = pht(
	- 'Phabricator has been successfully installed. These next guides will '.
	+ '%s has been successfully installed. These next guides will '.
	'take you through configuration and new user orientation. '.
	'These steps are optional, and you can go through them in any order. '.
	'If you want to get back to this guide later on, you can find it in '.
	- '{icon globe} Applications under {icon map-o} Guides.');
	+ '{icon globe} Applications under {icon map-o} Guides.',
	+ PlatformSymbols::getPlatformServerName());

	$intro = new PHUIRemarkupView($viewer, $intro);

	$intro = id(new PHUIDocumentView())
	->appendChild($intro);

	return array($intro, $guide_items);

	}

	}
	diff --git a/src/applications/guides/module/PhabricatorGuideQuickStartModule.php b/src/applications/guides/module/PhabricatorGuideQuickStartModule.php
	index 65b07ffe2c..3486ce4ba0 100644
	--- a/src/applications/guides/module/PhabricatorGuideQuickStartModule.php
	+++ b/src/applications/guides/module/PhabricatorGuideQuickStartModule.php
	@@ -1,189 +1,187 @@
	<?php

	final class PhabricatorGuideQuickStartModule extends PhabricatorGuideModule {

	public function getModuleKey() {
	return 'quickstart';
	}

	public function getModuleName() {
	return pht('Quick Start');
	}

	public function getModulePosition() {
	return 30;
	}

	public function getIsModuleEnabled() {
	return true;
	}

	public function renderModuleStatus(AphrontRequest $request) {
	$viewer = $request->getViewer();
	$instance = PhabricatorEnv::getEnvConfig('cluster.instance');

	$guide_items = new PhabricatorGuideListView();

	$title = pht('Create a Repository');
	$repository_check = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->execute();
	$href = PhabricatorEnv::getURI('/diffusion/');
	if ($repository_check) {
	$icon = 'fa-check';
	$icon_bg = 'bg-green';
	$description = pht(
	"You've created at least one repository.");
	} else {
	$icon = 'fa-code';
	$icon_bg = 'bg-sky';
	$description =
	pht('If you are here for code review, let\'s set up your first '.
	'repository.');
	}

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);
	$guide_items->addItem($item);


	$title = pht('Create a Project');
	$project_check = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->execute();
	$href = PhabricatorEnv::getURI('/project/');
	if ($project_check) {
	$icon = 'fa-check';
	$icon_bg = 'bg-green';
	$description = pht(
	"You've created at least one project.");
	} else {
	$icon = 'fa-briefcase';
	$icon_bg = 'bg-sky';
	$description =
	pht('Project tags define everything. Create them for teams, tags, '.
	'or actual projects.');
	}

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);
	$guide_items->addItem($item);


	$title = pht('Create a Task');
	$task_check = id(new ManiphestTaskQuery())
	->setViewer($viewer)
	->execute();
	$href = PhabricatorEnv::getURI('/maniphest/');
	if ($task_check) {
	$icon = 'fa-check';
	$icon_bg = 'bg-green';
	$description = pht(
	"You've created at least one task.");
	} else {
	$icon = 'fa-anchor';
	$icon_bg = 'bg-sky';
	$description =
	pht('Create some work for the interns in Maniphest.');
	}

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);
	$guide_items->addItem($item);

	$title = pht('Personalize your Install');
	$wordmark = PhabricatorEnv::getEnvConfig('ui.logo');
	$href = PhabricatorEnv::getURI('/config/edit/ui.logo/');
	if ($wordmark) {
	$icon = 'fa-check';
	$icon_bg = 'bg-green';
	$description = pht(
	'It looks amazing, good work. Home Sweet Home.');
	} else {
	$icon = 'fa-home';
	$icon_bg = 'bg-sky';
	$description =
	pht('Change the name and add your company logo, just to give it a '.
	'little extra polish.');
	}

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);
	$guide_items->addItem($item);

	$title = pht('Explore Applications');
	$href = PhabricatorEnv::getURI('/applications/');
	$icon = 'fa-globe';
	$icon_bg = 'bg-sky';
	$description =
	- pht('See all the applications included in Phabricator.');
	+ pht('See all available applications.');

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);
	$guide_items->addItem($item);

	if (!$instance) {
	$title = pht('Invite Collaborators');
	$people_check = id(new PhabricatorPeopleQuery())
	->setViewer($viewer)
	->execute();
	$people = count($people_check);
	$href = PhabricatorEnv::getURI('/people/invite/send/');
	if ($people > 1) {
	$icon = 'fa-check';
	$icon_bg = 'bg-green';
	$description = pht(
	'Your invitations have been accepted. You will not be alone on '.
	'this journey.');
	} else {
	$icon = 'fa-group';
	$icon_bg = 'bg-sky';
	$description =
	- pht('Invite the rest of your team to get started on Phabricator.');
	+ pht('Invite the rest of your team to get started.');
	}

	$item = id(new PhabricatorGuideItemView())
	->setTitle($title)
	->setHref($href)
	->setIcon($icon)
	->setIconBackground($icon_bg)
	->setDescription($description);
	$guide_items->addItem($item);
	}

	$intro = pht(
	- 'If you\'re new to Phabricator, these optional steps can help you learn '.
	- 'the basics. Conceptually, Phabricator is structured as a graph, and '.
	- 'repositories, tasks, and projects are all independent from each other. '.
	- 'Feel free to set up Phabricator for how you work best, and explore '.
	- 'these features at your own pace.');
	+ 'If you\'re new to this software, these optional steps can help you '.
	+ 'learn the basics. Feel free to set things up for how you work best '.
	+ 'and explore these features at your own pace.');

	$intro = new PHUIRemarkupView($viewer, $intro);
	$intro = id(new PHUIDocumentView())
	->appendChild($intro);

	return array($intro, $guide_items);

	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Mar 14, 12:06 PM (1 d, 3 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71854
Default Alt Text: (147 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions