No OneTemporary
Actions

Size

317 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/resources/sql/autopatches/20140722.appname.php b/resources/sql/autopatches/20140722.appname.php
	index 8c3e5918b2..4e617d5102 100644
	--- a/resources/sql/autopatches/20140722.appname.php
	+++ b/resources/sql/autopatches/20140722.appname.php
	@@ -1,166 +1,140 @@
	<?php

	$applications = array(
	'Audit',
	'Auth',
	'Calendar',
	'ChatLog',
	'Conduit',
	'Config',
	'Conpherence',
	'Countdown',
	'Daemons',
	'Dashboard',
	'Differential',
	'Diffusion',
	'Diviner',
	'Doorkeeper',
	'Drydock',
	'Fact',
	'Feed',
	'Files',
	'Flags',
	'Harbormaster',
	'Help',
	'Herald',
	'Home',
	'Legalpad',
	'Macro',
	'MailingLists',
	'Maniphest',
	'Applications',
	'MetaMTA',
	'Notifications',
	'Nuance',
	'OAuthServer',
	'Owners',
	'Passphrase',
	'Paste',
	'People',
	'Phame',
	'Phlux',
	'Pholio',
	'Phortune',
	'PHPAST',
	'Phragment',
	'Phrequent',
	'Phriction',
	'Policy',
	'Ponder',
	'Project',
	'Releeph',
	'Repositories',
	'Search',
	'Settings',
	'Slowvote',
	'Subscriptions',
	'Support',
	'System',
	'Test',
	'Tokens',
	'Transactions',
	'Typeahead',
	'UIExamples',
	'XHProf',
	);
	$map = array();

	foreach ($applications as $application) {
	$old_name = 'PhabricatorApplication'.$application;
	$new_name = 'Phabricator'.$application.'Application';
	$map[$old_name] = $new_name;
	}


	/* -( User preferences )--------------------------------------------------- */

	-echo pht('Migrating user preferences...')."\n";
	-$table = new PhabricatorUserPreferences();
	-$conn_w = $table->establishConnection('w');
	-$pref_pinned = PhabricatorUserPreferences::PREFERENCE_APP_PINNED;
	-
	-foreach (new LiskMigrationIterator(new PhabricatorUser()) as $user) {
	- $user_preferences = $user->loadPreferences();
	-
	- $old_pinned_apps = $user_preferences->getPreference($pref_pinned);
	- $new_pinned_apps = array();

	- if (!$old_pinned_apps) {
	- continue;
	- }
	-
	- foreach ($old_pinned_apps as $pinned_app) {
	- $new_pinned_apps[] = idx($map, $pinned_app, $pinned_app);
	- }
	-
	- $user_preferences
	- ->setPreference($pref_pinned, $new_pinned_apps);
	-
	- queryfx(
	- $conn_w,
	- 'UPDATE %T SET preferences = %s WHERE id = %d',
	- $user_preferences->getTableName(),
	- json_encode($user_preferences->getPreferences()),
	- $user_preferences->getID());
	-}
	+// This originally migrated pinned applications in user preferences, but was
	+// removed to simplify preference changes after about 22 months.


	/* -( Dashboard installs )------------------------------------------------- */

	echo pht('Migrating dashboard installs...')."\n";
	$table = new PhabricatorDashboardInstall();
	$conn_w = $table->establishConnection('w');

	foreach (new LiskMigrationIterator($table) as $dashboard_install) {
	$application = $dashboard_install->getApplicationClass();

	queryfx(
	$conn_w,
	'UPDATE %T SET applicationClass = %s WHERE id = %d',
	$table->getTableName(),
	idx($map, $application, $application),
	$dashboard_install->getID());
	}


	/* -( Phabricator configuration )------------------------------------------ */

	$config_key = 'phabricator.uninstalled-applications';
	echo pht('Migrating `%s` config...', $config_key)."\n";

	$config = PhabricatorConfigEntry::loadConfigEntry($config_key);
	$old_config = $config->getValue();
	$new_config = array();

	if ($old_config) {
	foreach ($old_config as $application => $uninstalled) {
	$new_config[idx($map, $application, $application)] = $uninstalled;
	}

	$config
	->setIsDeleted(0)
	->setValue($new_config)
	->save();
	}


	/* -( phabricator.application-settings )----------------------------------- */

	$config_key = 'phabricator.application-settings';
	echo pht('Migrating `%s` config...', $config_key)."\n";

	$config = PhabricatorConfigEntry::loadConfigEntry($config_key);
	$old_config = $config->getValue();
	$new_config = array();

	if ($old_config) {
	foreach ($old_config as $application => $settings) {
	$application = preg_replace('/^PHID-APPS-/', '', $application);
	$new_config['PHID-APPS-'.idx($map, $application, $application)] = $settings;
	}

	$config
	->setIsDeleted(0)
	->setValue($new_config)
	->save();
	}
	diff --git a/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php b/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	index 8b321ef73e..9eb50048fb 100644
	--- a/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	+++ b/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	@@ -1,581 +1,580 @@
	<?php

	final class PhabricatorCalendarEventSearchEngine
	extends PhabricatorApplicationSearchEngine {

	private $calendarYear;
	private $calendarMonth;
	private $calendarDay;

	public function getResultTypeDescription() {
	return pht('Calendar Events');
	}

	public function getApplicationClassName() {
	return 'PhabricatorCalendarApplication';
	}

	public function newQuery() {
	return new PhabricatorCalendarEventQuery();
	}

	protected function shouldShowOrderField() {
	return false;
	}

	protected function buildCustomSearchFields() {
	return array(
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Created By'))
	->setKey('creatorPHIDs')
	->setDatasource(new PhabricatorPeopleUserFunctionDatasource()),
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Invited'))
	->setKey('invitedPHIDs')
	->setDatasource(new PhabricatorPeopleUserFunctionDatasource()),
	id(new PhabricatorSearchDateControlField())
	->setLabel(pht('Occurs After'))
	->setKey('rangeStart'),
	id(new PhabricatorSearchDateControlField())
	->setLabel(pht('Occurs Before'))
	->setKey('rangeEnd')
	->setAliases(array('rangeEnd')),
	id(new PhabricatorSearchCheckboxesField())
	->setKey('upcoming')
	->setOptions(array(
	'upcoming' => pht('Show only upcoming events.'),
	)),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Cancelled Events'))
	->setKey('isCancelled')
	->setOptions($this->getCancelledOptions())
	->setDefault('active'),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Display Options'))
	->setKey('display')
	->setOptions($this->getViewOptions())
	->setDefault('month'),
	);
	}

	private function getCancelledOptions() {
	return array(
	'active' => pht('Active Events Only'),
	'cancelled' => pht('Cancelled Events Only'),
	'both' => pht('Both Cancelled and Active Events'),
	);
	}

	private function getViewOptions() {
	return array(
	'month' => pht('Month View'),
	'day' => pht('Day View'),
	'list' => pht('List View'),
	);
	}

	protected function buildQueryFromParameters(array $map) {
	$query = $this->newQuery();
	$viewer = $this->requireViewer();

	if ($map['creatorPHIDs']) {
	$query->withCreatorPHIDs($map['creatorPHIDs']);
	}

	if ($map['invitedPHIDs']) {
	$query->withInvitedPHIDs($map['invitedPHIDs']);
	}

	$range_start = $map['rangeStart'];
	$range_end = $map['rangeEnd'];
	$display = $map['display'];

	if ($map['upcoming'] && $map['upcoming'][0] == 'upcoming') {
	$upcoming = true;
	} else {
	$upcoming = false;
	}

	list($range_start, $range_end) = $this->getQueryDateRange(
	$range_start,
	$range_end,
	$display,
	$upcoming);

	$query->withDateRange($range_start, $range_end);

	switch ($map['isCancelled']) {
	case 'active':
	$query->withIsCancelled(false);
	break;
	case 'cancelled':
	$query->withIsCancelled(true);
	break;
	}

	return $query->setGenerateGhosts(true);
	}

	private function getQueryDateRange(
	$start_date_wild,
	$end_date_wild,
	$display,
	$upcoming) {

	$start_date_value = $this->getSafeDate($start_date_wild);
	$end_date_value = $this->getSafeDate($end_date_wild);

	$viewer = $this->requireViewer();
	$timezone = new DateTimeZone($viewer->getTimezoneIdentifier());
	$min_range = null;
	$max_range = null;

	$min_range = $start_date_value->getEpoch();
	$max_range = $end_date_value->getEpoch();

	if ($display == 'month' \|\| $display == 'day') {
	list($start_year, $start_month, $start_day) =
	$this->getDisplayYearAndMonthAndDay($min_range, $max_range, $display);

	$start_day = new DateTime(
	"{$start_year}-{$start_month}-{$start_day}",
	$timezone);
	$next = clone $start_day;

	if ($display == 'month') {
	$next->modify('+1 month');
	} else if ($display == 'day') {
	$next->modify('+7 day');
	}

	$display_start = $start_day->format('U');
	$display_end = $next->format('U');

	- $preferences = $viewer->loadPreferences();
	- $pref_week_day = PhabricatorUserPreferences::PREFERENCE_WEEK_START_DAY;
	+ $start_of_week = $viewer->getUserSetting(
	+ PhabricatorWeekStartDaySetting::SETTINGKEY);

	- $start_of_week = $preferences->getPreference($pref_week_day, 0);
	$end_of_week = ($start_of_week + 6) % 7;

	$first_of_month = $start_day->format('w');
	$last_of_month = id(clone $next)->modify('-1 day')->format('w');

	if (!$min_range \|\| ($min_range < $display_start)) {
	$min_range = $display_start;

	if ($display == 'month' &&
	$first_of_month !== $start_of_week) {
	$interim_day_num = ($first_of_month + 7 - $start_of_week) % 7;
	$min_range = id(clone $start_day)
	->modify('-'.$interim_day_num.' days')
	->format('U');
	}
	}
	if (!$max_range \|\| ($max_range > $display_end)) {
	$max_range = $display_end;

	if ($display == 'month' &&
	$last_of_month !== $end_of_week) {
	$interim_day_num = ($end_of_week + 7 - $last_of_month) % 7;
	$max_range = id(clone $next)
	->modify('+'.$interim_day_num.' days')
	->format('U');
	}
	}
	}

	if ($upcoming) {
	if ($min_range) {
	$min_range = max(time(), $min_range);
	} else {
	$min_range = time();
	}
	}

	return array($min_range, $max_range);
	}

	protected function getURI($path) {
	return '/calendar/'.$path;
	}

	protected function getBuiltinQueryNames() {
	$names = array(
	'month' => pht('Month View'),
	'day' => pht('Day View'),
	'upcoming' => pht('Upcoming Events'),
	'all' => pht('All Events'),
	);

	return $names;
	}

	public function setCalendarYearAndMonthAndDay($year, $month, $day = null) {
	$this->calendarYear = $year;
	$this->calendarMonth = $month;
	$this->calendarDay = $day;

	return $this;
	}

	public function buildSavedQueryFromBuiltin($query_key) {
	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);

	switch ($query_key) {
	case 'month':
	return $query->setParameter('display', 'month');
	case 'day':
	return $query->setParameter('display', 'day');
	case 'upcoming':
	return $query
	->setParameter('display', 'list')
	->setParameter('upcoming', array(
	0 => 'upcoming',
	));
	case 'all':
	return $query;
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	protected function getRequiredHandlePHIDsForResultList(
	array $objects,
	PhabricatorSavedQuery $query) {
	$phids = array();
	foreach ($objects as $event) {
	$phids[$event->getUserPHID()] = 1;
	}
	return array_keys($phids);
	}

	protected function renderResultList(
	array $events,
	PhabricatorSavedQuery $query,
	array $handles) {

	if ($this->isMonthView($query)) {
	return $this->buildCalendarView($events, $query, $handles);
	} else if ($this->isDayView($query)) {
	return $this->buildCalendarDayView($events, $query, $handles);
	}

	assert_instances_of($events, 'PhabricatorCalendarEvent');
	$viewer = $this->requireViewer();
	$list = new PHUIObjectItemListView();

	foreach ($events as $event) {
	$event_date_info = $this->getEventDateLabel($event);
	$creator_handle = $handles[$event->getUserPHID()];
	$attendees = array();

	foreach ($event->getInvitees() as $invitee) {
	$status_attending = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;
	if ($invitee->getStatus() === $status_attending) {
	$attendees[] = $invitee->getInviteePHID();
	}
	}

	if ($event->getIsGhostEvent()) {
	$title_text = $event->getMonogram()
	.' ('
	.$event->getSequenceIndex()
	.'): '
	.$event->getName();
	} else {
	$title_text = $event->getMonogram().': '.$event->getName();
	}

	$item = id(new PHUIObjectItemView())
	->setUser($viewer)
	->setObject($event)
	->setHeader($title_text)
	->setHref($event->getURI())
	->addAttribute($event_date_info);

	if ($attendees) {
	$attending = pht(
	'Attending: %s',
	$viewer->renderHandleList($attendees)
	->setAsInline(1)
	->render());

	$item->addAttribute($attending);
	}

	if (strlen($event->getDuration()) > 0) {
	$duration = pht(
	'Duration: %s',
	$event->getDuration());

	$item->addIcon('none', $duration);
	}

	$list->addItem($item);
	}

	$result = new PhabricatorApplicationSearchResultView();
	$result->setObjectList($list);
	$result->setNoDataString(pht('No events found.'));

	return $result;
	}

	private function buildCalendarView(
	array $statuses,
	PhabricatorSavedQuery $query,
	array $handles) {

	$viewer = $this->requireViewer();
	$now = time();

	list($start_year, $start_month) =
	$this->getDisplayYearAndMonthAndDay(
	$this->getQueryDateFrom($query)->getEpoch(),
	$this->getQueryDateTo($query)->getEpoch(),
	$query->getParameter('display'));

	$now_year = phabricator_format_local_time($now, $viewer, 'Y');
	$now_month = phabricator_format_local_time($now, $viewer, 'm');
	$now_day = phabricator_format_local_time($now, $viewer, 'j');

	if ($start_month == $now_month && $start_year == $now_year) {
	$month_view = new PHUICalendarMonthView(
	$this->getQueryDateFrom($query),
	$this->getQueryDateTo($query),
	$start_month,
	$start_year,
	$now_day);
	} else {
	$month_view = new PHUICalendarMonthView(
	$this->getQueryDateFrom($query),
	$this->getQueryDateTo($query),
	$start_month,
	$start_year);
	}

	$month_view->setUser($viewer);

	$phids = mpull($statuses, 'getUserPHID');

	foreach ($statuses as $status) {
	$viewer_is_invited = $status->getIsUserInvited($viewer->getPHID());

	$event = new AphrontCalendarEventView();
	$event->setEpochRange($status->getDateFrom(), $status->getDateTo());
	$event->setIsAllDay($status->getIsAllDay());
	$event->setIcon($status->getIcon());

	$name_text = $handles[$status->getUserPHID()]->getName();
	$status_text = $status->getName();
	$event->setUserPHID($status->getUserPHID());
	$event->setDescription(pht('%s (%s)', $name_text, $status_text));
	$event->setName($status_text);
	$event->setURI($status->getURI());
	$event->setViewerIsInvited($viewer_is_invited);
	$month_view->addEvent($event);
	}

	$month_view->setBrowseURI(
	$this->getURI('query/'.$query->getQueryKey().'/'));

	// TODO redesign-2015 : Move buttons out of PHUICalendarView?
	$result = new PhabricatorApplicationSearchResultView();
	$result->setContent($month_view);

	return $result;
	}

	private function buildCalendarDayView(
	array $statuses,
	PhabricatorSavedQuery $query,
	array $handles) {

	$viewer = $this->requireViewer();

	list($start_year, $start_month, $start_day) =
	$this->getDisplayYearAndMonthAndDay(
	$this->getQueryDateFrom($query)->getEpoch(),
	$this->getQueryDateTo($query)->getEpoch(),
	$query->getParameter('display'));

	$day_view = id(new PHUICalendarDayView(
	$this->getQueryDateFrom($query)->getEpoch(),
	$this->getQueryDateTo($query)->getEpoch(),
	$start_year,
	$start_month,
	$start_day))
	->setQuery($query->getQueryKey());

	$day_view->setUser($viewer);

	$phids = mpull($statuses, 'getUserPHID');

	foreach ($statuses as $status) {
	if ($status->getIsCancelled()) {
	continue;
	}

	$viewer_is_invited = $status->getIsUserInvited($viewer->getPHID());

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

	$event = new AphrontCalendarEventView();
	$event->setCanEdit($can_edit);
	$event->setEventID($status->getID());
	$event->setEpochRange($status->getDateFrom(), $status->getDateTo());
	$event->setIsAllDay($status->getIsAllDay());
	$event->setIcon($status->getIcon());
	$event->setViewerIsInvited($viewer_is_invited);

	$event->setName($status->getName());
	$event->setURI($status->getURI());
	$day_view->addEvent($event);
	}

	$day_view->setBrowseURI(
	$this->getURI('query/'.$query->getQueryKey().'/'));

	$result = new PhabricatorApplicationSearchResultView();
	$result->setContent($day_view);

	return $result;
	}

	private function getDisplayYearAndMonthAndDay(
	$range_start,
	$range_end,
	$display) {

	$viewer = $this->requireViewer();
	$epoch = null;

	if ($this->calendarYear && $this->calendarMonth) {
	$start_year = $this->calendarYear;
	$start_month = $this->calendarMonth;
	$start_day = $this->calendarDay ? $this->calendarDay : 1;
	} else {
	if ($range_start) {
	$epoch = $range_start;
	} else if ($range_end) {
	$epoch = $range_end;
	} else {
	$epoch = time();
	}
	if ($display == 'month') {
	$day = 1;
	} else {
	$day = phabricator_format_local_time($epoch, $viewer, 'd');
	}
	$start_year = phabricator_format_local_time($epoch, $viewer, 'Y');
	$start_month = phabricator_format_local_time($epoch, $viewer, 'm');
	$start_day = $day;
	}
	return array($start_year, $start_month, $start_day);
	}

	public function getPageSize(PhabricatorSavedQuery $saved) {
	if ($this->isMonthView($saved) \|\| $this->isDayView($saved)) {
	return $saved->getParameter('limit', 1000);
	} else {
	return $saved->getParameter('limit', 100);
	}
	}

	private function getQueryDateFrom(PhabricatorSavedQuery $saved) {
	return $this->getQueryDate($saved, 'rangeStart');
	}

	private function getQueryDateTo(PhabricatorSavedQuery $saved) {
	return $this->getQueryDate($saved, 'rangeEnd');
	}

	private function getQueryDate(PhabricatorSavedQuery $saved, $key) {
	$viewer = $this->requireViewer();

	$wild = $saved->getParameter($key);
	return $this->getSafeDate($wild);
	}

	private function getSafeDate($value) {
	$viewer = $this->requireViewer();
	if ($value) {
	// ideally this would be consistent and always pass in the same type
	if ($value instanceof AphrontFormDateControlValue) {
	return $value;
	} else {
	$value = AphrontFormDateControlValue::newFromWild($viewer, $value);
	}
	} else {
	$value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	PhabricatorTime::getTodayMidnightDateTime($viewer)->format('U'));
	$value->setEnabled(false);
	}

	$value->setOptional(true);

	return $value;
	}

	private function isMonthView(PhabricatorSavedQuery $query) {
	if ($this->isDayView($query)) {
	return false;
	}
	if ($query->getParameter('display') == 'month') {
	return true;
	}
	}

	private function isDayView(PhabricatorSavedQuery $query) {
	if ($query->getParameter('display') == 'day') {
	return true;
	}
	if ($this->calendarDay) {
	return true;
	}

	return false;
	}

	private function getEventDateLabel($event) {
	$viewer = $this->requireViewer();

	$from_datetime = PhabricatorTime::getDateTimeFromEpoch(
	$event->getDateFrom(),
	$viewer);
	$to_datetime = PhabricatorTime::getDateTimeFromEpoch(
	$event->getDateTo(),
	$viewer);

	$from_date_formatted = $from_datetime->format('Y m d');
	$to_date_formatted = $to_datetime->format('Y m d');

	if ($event->getIsAllDay()) {
	if ($from_date_formatted == $to_date_formatted) {
	return pht(
	'%s, All Day',
	phabricator_date($event->getDateFrom(), $viewer));
	} else {
	return pht(
	'%s - %s, All Day',
	phabricator_date($event->getDateFrom(), $viewer),
	phabricator_date($event->getDateTo(), $viewer));
	}
	} else if ($from_date_formatted == $to_date_formatted) {
	return pht(
	'%s - %s',
	phabricator_datetime($event->getDateFrom(), $viewer),
	phabricator_time($event->getDateTo(), $viewer));
	} else {
	return pht(
	'%s - %s',
	phabricator_datetime($event->getDateFrom(), $viewer),
	phabricator_datetime($event->getDateTo(), $viewer));
	}
	}
	}
	diff --git a/src/applications/config/controller/PhabricatorConfigWelcomeController.php b/src/applications/config/controller/PhabricatorConfigWelcomeController.php
	index addf80e62f..a7d29b913b 100644
	--- a/src/applications/config/controller/PhabricatorConfigWelcomeController.php
	+++ b/src/applications/config/controller/PhabricatorConfigWelcomeController.php
	@@ -1,401 +1,407 @@
	<?php

	final class PhabricatorConfigWelcomeController
	extends PhabricatorConfigController {

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

	$nav = $this->buildSideNavView();
	$nav->selectFilter('welcome/');

	$title = pht('Welcome');

	$crumbs = $this
	->buildApplicationCrumbs()
	->addTextCrumb(pht('Welcome'));

	$view = id(new PHUITwoColumnView())
	->setNavigation($nav)
	->setMainColumn(array(
	$this->buildWelcomeScreen($request),
	));

	return $this->newPage()
	->setTitle($title)
	->setCrumbs($crumbs)
	->appendChild($view);
	}

	public function buildWelcomeScreen(AphrontRequest $request) {
	$viewer = $request->getUser();
	$this->requireResource('config-welcome-css');

	$content = pht(
	"=== Install Phabricator ===\n\n".
	"You have successfully installed Phabricator. This screen will guide ".
	"you through configuration and orientation. ".
	"These steps are optional, and you can go through them in any order. ".
	"If you want to get back to this screen later on, you can find it in ".
	"the Config application under Welcome Screen.");

	$setup = array();

	$setup[] = $this->newItem(
	$request,
	'fa-check-square-o green',
	$content);

	$issues_resolved = !PhabricatorSetupCheck::getOpenSetupIssueKeys();

	$setup_href = PhabricatorEnv::getURI('/config/issue/');
	if ($issues_resolved) {
	$content = pht(
	"=== Resolve Setup Issues ===\n\n".
	"You've resolved (or ignored) all outstanding setup issues. ".
	"You can review issues in the Config application, under ".
	"[[ %s \| Setup Issues ]].",
	$setup_href);
	$icon = 'fa-check-square-o green';
	} else {
	$content = pht(
	"=== Resolve Setup Issues ===\n\n".
	"You have some unresolved setup issues to take care of. Click ".
	"the link in the yellow banner at the top of the screen to see ".
	"them, or find them in the Config application under ".
	"[[ %s \| Setup Issues ]]. ".
	"Although most setup issues should be resolved, sometimes an issue ".
	"is not applicable to an install. ".
	"If you don't intend to fix a setup issue (or don't want to fix ".
	"it for now), you can use the \"Ignore\" action to mark it as ".
	"something you don't plan to deal with.",
	$setup_href);
	$icon = 'fa-warning red';
	}

	$setup[] = $this->newItem(
	$request,
	$icon,
	$content);

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

	$auth_href = PhabricatorEnv::getURI('/auth/');
	$have_auth = (bool)$configs;
	if ($have_auth) {
	$content = pht(
	"=== Login and Registration ===\n\n".
	"You've configured at least one authentication provider, so users ".
	"can register or log in. ".
	"To configure more providers or adjust settings, use the ".
	"[[ %s \| Auth Application ]].",
	$auth_href);
	$icon = 'fa-check-square-o green';
	} else {
	$content = pht(
	"=== Login and Registration ===\n\n".
	"You haven't configured any authentication providers yet. ".
	"Authentication providers allow users to register accounts and ".
	"log in to Phabricator. You can configure Phabricator to accept ".
	"credentials like username and password, LDAP, or Google OAuth. ".
	"You can configure authentication using the ".
	"[[ %s \| Auth Application ]].",
	$auth_href);
	$icon = 'fa-warning red';
	}

	$setup[] = $this->newItem(
	$request,
	$icon,
	$content);

	$config_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) {
	$content = pht(
	"=== Configure Phabricator Settings ===\n\n".
	"You've configured at least one setting from the web interface. ".
	"To configure more settings later, use the ".
	"[[ %s \| Config Application ]].",
	$config_href);
	$icon = 'fa-check-square-o green';
	} else {
	$content = pht(
	"=== Configure Phabricator Settings ===\n\n".
	'Many aspects of Phabricator are configurable. To explore and '.
	'adjust settings, use the [[ %s \| Config Application ]].',
	$config_href);
	$icon = 'fa-info-circle';
	}

	$setup[] = $this->newItem(
	$request,
	$icon,
	$content);

	$settings_href = PhabricatorEnv::getURI('/settings/');
	- $prefs = $viewer->loadPreferences()->getPreferences();
	- $have_settings = !empty($prefs);
	+
	+ $preferences = id(new PhabricatorUserPreferencesQuery())
	+ ->setViewer($viewer)
	+ ->withUsers(array($viewer))
	+ ->executeOne();
	+
	+ $have_settings = ($preferences && $preferences->getPreferences());
	+
	if ($have_settings) {
	$content = pht(
	"=== Adjust Account Settings ===\n\n".
	"You've adjusted at least one setting on your account. ".
	"To make more adjustments, visit the ".
	"[[ %s \| Settings Application ]].",
	$settings_href);
	$icon = 'fa-check-square-o green';
	} else {
	$content = pht(
	"=== Adjust Account Settings ===\n\n".
	'You can configure settings for your account by clicking the '.
	'wrench icon in the main menu bar, or visiting the '.
	'[[ %s \| Settings Application ]] directly.',
	$settings_href);
	$icon = 'fa-info-circle';
	}

	$setup[] = $this->newItem(
	$request,
	$icon,
	$content);

	$dashboard_href = PhabricatorEnv::getURI('/dashboard/');
	$have_dashboard = (bool)PhabricatorDashboardInstall::getDashboard(
	$viewer,
	PhabricatorHomeApplication::DASHBOARD_DEFAULT,
	'PhabricatorHomeApplication');
	if ($have_dashboard) {
	$content = pht(
	"=== Customize Home Page ===\n\n".
	"You've installed a default dashboard to replace this welcome screen ".
	"on the home page. ".
	"You can still visit the welcome screen here at any time if you ".
	"have steps you want to complete later, or if you feel lonely. ".
	"If you've changed your mind about the dashboard you installed, ".
	"you can install a different default dashboard with the ".
	"[[ %s \| Dashboards Application ]].",
	$dashboard_href);
	$icon = 'fa-check-square-o green';
	} else {
	$content = pht(
	"=== Customize Home Page ===\n\n".
	"When you're done setting things up, you can create a custom ".
	"dashboard and install it. Your dashboard will replace this ".
	"welcome screen on the Phabricator home page. ".
	"Dashboards can show users the information that's most important to ".
	"your organization. You can configure them to display things like: ".
	"a custom welcome message, a feed of recent activity, or a list of ".
	"open tasks, waiting reviews, recent commits, and so on. ".
	"After you install a default dashboard, it will replace this page. ".
	"You can find this page later by visiting the Config ".
	"application, under Welcome Page. ".
	"To get started building a dashboard, use the ".
	"[[ %s \| Dashboards Application ]]. ",
	$dashboard_href);
	$icon = 'fa-info-circle';
	}

	$setup[] = $this->newItem(
	$request,
	$icon,
	$content);

	$apps_href = PhabricatorEnv::getURI('/applications/');
	$content = pht(
	"=== Explore Applications ===\n\n".
	"Phabricator is a large suite of applications that work together to ".
	"help you develop software, manage tasks, and communicate. A few of ".
	"the most commonly used applications are pinned to the left navigation ".
	"bar by default.\n\n".
	"To explore all of the Phabricator applications, adjust settings, or ".
	"uninstall applications you don't plan to use, visit the ".
	"[[ %s \| Applications Application ]]. You can also click the ".
	"Applications button in the left navigation menu, or search for an ".
	"application by name in the main menu bar. ",
	$apps_href);

	$explore = array();
	$explore[] = $this->newItem(
	$request,
	'fa-globe',
	$content);

	// TODO: Restore some sort of "Support" link here, but just nuke it for
	// now as we figure stuff out.

	$differential_uri = PhabricatorEnv::getURI('/differential/');
	$differential_create_uri = PhabricatorEnv::getURI(
	'/differential/diff/create/');
	$differential_all_uri = PhabricatorEnv::getURI('/differential/query/all/');

	$differential_user_guide = PhabricatorEnv::getDoclink(
	'Differential User Guide');
	$differential_vs_uri = PhabricatorEnv::getDoclink(
	'User Guide: Review vs Audit');

	$quick = array();
	$quick[] = $this->newItem(
	$request,
	'fa-gear',
	pht(
	"=== Quick Start: Code Review ===\n\n".
	"Review code with [[ %s \| Differential ]]. ".
	"Engineers can use Differential to share, review, and approve ".
	"changes to source code. ".
	"To get started with code review:\n\n".
	" - [[ %s \| Create a Revision ]] //(Copy and paste a diff from ".
	" the command line into the web UI to quickly get a feel for ".
	" review.)//\n".
	" - [[ %s \| View All Revisions ]]\n\n".
	"For more information, see these articles in the documentation:\n\n".
	" - [[ %s \| Differential User Guide ]], for a general overview ".
	" of Differential.\n".
	" - [[ %s \| User Guide: Review vs Audit ]], for a discussion ".
	" of different code review workflows.",
	$differential_uri,
	$differential_create_uri,
	$differential_all_uri,
	$differential_user_guide,
	$differential_vs_uri));


	$maniphest_uri = PhabricatorEnv::getURI('/maniphest/');
	$maniphest_create_uri = PhabricatorEnv::getURI('/maniphest/task/edit/');
	$maniphest_all_uri = PhabricatorEnv::getURI('/maniphest/query/all/');
	$quick[] = $this->newItem(
	$request,
	'fa-anchor',
	pht(
	"=== Quick Start: Bugs and Tasks ===\n\n".
	"Track bugs and tasks in Phabricator with ".
	"[[ %s \| Maniphest ]]. ".
	"Users in all roles can use Maniphest to manage current and ".
	"planned work and to track bugs and issues. ".
	"To get started with bugs and tasks:\n\n".
	" - [[ %s \| Create a Task ]]\n".
	" - [[ %s \| View All Tasks ]]\n",
	$maniphest_uri,
	$maniphest_create_uri,
	$maniphest_all_uri));


	$pholio_uri = PhabricatorEnv::getURI('/pholio/');
	$pholio_create_uri = PhabricatorEnv::getURI('/pholio/new/');
	$pholio_all_uri = PhabricatorEnv::getURI('/pholio/query/all/');

	$quick[] = $this->newItem(
	$request,
	'fa-camera-retro',
	pht(
	"=== Quick Start: Design Review ===\n\n".
	"Review proposed designs with [[ %s \| Pholio ]]. ".
	"Designers can use Pholio to share images of what they're working on ".
	"and show off things they've made. ".
	"To get started with design review:\n\n".
	" - [[ %s \| Create a Mock ]]\n".
	" - [[ %s \| View All Mocks ]]",
	$pholio_uri,
	$pholio_create_uri,
	$pholio_all_uri));


	$diffusion_uri = PhabricatorEnv::getURI('/diffusion/');
	$diffusion_create_uri = PhabricatorEnv::getURI('/diffusion/create/');
	$diffusion_all_uri = PhabricatorEnv::getURI('/diffusion/query/all/');

	$diffusion_user_guide = PhabricatorEnv::getDoclink('Diffusion User Guide');
	$diffusion_setup_guide = PhabricatorEnv::getDoclink(
	'Diffusion User Guide: Repository Hosting');

	$quick[] = $this->newItem(
	$request,
	'fa-code',
	pht(
	"=== Quick Start: Repositories ===\n\n".
	"Manage and browse source code repositories with ".
	"[[ %s \| Diffusion ]]. ".
	"Engineers can use Diffusion to browse and audit source code. ".
	"You can configure Phabricator to host repositories, or have it ".
	"track existing repositories hosted elsewhere (like GitHub, ".
	"Bitbucket, or an internal server). ".
	"To get started with repositories:\n\n".
	" - [[ %s \| Create a New Repository ]]\n".
	" - [[ %s \| View All Repositories ]]\n\n".
	"For more information, see these articles in the documentation:\n\n".
	" - [[ %s \| Diffusion User Guide ]], for a general overview of ".
	" Diffusion.\n".
	" - [[ %s \| Diffusion User Guide: Repository Hosting ]], ".
	" for instructions on configuring repository hosting.\n\n".
	"Phabricator supports Git, Mercurial and Subversion.",
	$diffusion_uri,
	$diffusion_create_uri,
	$diffusion_all_uri,
	$diffusion_user_guide,
	$diffusion_setup_guide));

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Welcome to Phabricator'));

	$setup_header = new PHUIRemarkupView(
	$viewer, pht('=Setup and Configuration'));

	$explore_header = new PHUIRemarkupView(
	$viewer, pht('=Explore Phabricator'));

	$quick_header = new PHUIRemarkupView(
	$viewer, pht('=Quick Start Guide'));

	return id(new PHUIDocumentView())
	->setHeader($header)
	->setFluid(true)
	->appendChild($setup_header)
	->appendChild($setup)
	->appendChild($explore_header)
	->appendChild($explore)
	->appendChild($quick_header)
	->appendChild($quick);
	}

	private function newItem(AphrontRequest $request, $icon, $content) {
	$viewer = $request->getUser();

	$icon = id(new PHUIIconView())
	->setIcon($icon.' fa-2x');

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

	$icon = phutil_tag(
	'div',
	array(
	'class' => 'config-welcome-icon',
	),
	$icon);

	$content = phutil_tag(
	'div',
	array(
	'class' => 'config-welcome-content',
	),
	$content);

	$view = phutil_tag(
	'div',
	array(
	'class' => 'config-welcome-box grouped',
	),
	array(
	$icon,
	$content,
	));

	return $view;
	}

	}
	diff --git a/src/applications/conpherence/view/ConpherenceThreadListView.php b/src/applications/conpherence/view/ConpherenceThreadListView.php
	index 40262c765b..a4f4a7de6d 100644
	--- a/src/applications/conpherence/view/ConpherenceThreadListView.php
	+++ b/src/applications/conpherence/view/ConpherenceThreadListView.php
	@@ -1,224 +1,216 @@
	<?php

	final class ConpherenceThreadListView extends AphrontView {

	const SEE_MORE_LIMIT = 15;

	private $baseURI;
	private $threads;

	public function setThreads(array $threads) {
	assert_instances_of($threads, 'ConpherenceThread');
	$this->threads = $threads;
	return $this;
	}

	public function setBaseURI($base_uri) {
	$this->baseURI = $base_uri;
	return $this;
	}

	public function render() {
	require_celerity_resource('conpherence-menu-css');

	$menu = id(new PHUIListView())
	->addClass('conpherence-menu')
	->setID('conpherence-menu');

	$policy_objects = ConpherenceThread::loadViewPolicyObjects(
	$this->getUser(),
	$this->threads);

	$this->addRoomsToMenu($menu, $this->threads, $policy_objects);

	return $menu;
	}

	public function renderSingleThread(
	ConpherenceThread $thread,
	array $policy_objects) {
	assert_instances_of($policy_objects, 'PhabricatorPolicy');
	return $this->renderThread($thread, $policy_objects);
	}

	private function renderThreadItem(
	ConpherenceThread $thread,
	array $policy_objects) {
	return id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_CUSTOM)
	->setName($this->renderThread($thread, $policy_objects));
	}

	private function renderThread(
	ConpherenceThread $thread,
	array $policy_objects) {

	$user = $this->getUser();

	$uri = '/'.$thread->getMonogram();
	$data = $thread->getDisplayData($user);
	$icon = id(new PHUIIconView())
	->addClass('msr')
	->setIcon($thread->getPolicyIconName($policy_objects));
	$title = phutil_tag(
	'span',
	array(),
	array(
	$icon,
	$data['title'],
	));
	$subtitle = $data['subtitle'];
	$unread_count = $data['unread_count'];
	$epoch = $data['epoch'];
	$image = $data['image'];
	$dom_id = $thread->getPHID().'-nav-item';
	- $glyph_pref = PhabricatorUserPreferences::PREFERENCE_TITLES;
	- $preferences = $user->loadPreferences();
	- if ($preferences->getPreference($glyph_pref) == 'glyph') {
	- $glyph = id(new PhabricatorConpherenceApplication())
	- ->getTitleGlyph().' ';
	- } else {
	- $glyph = null;
	- }

	return id(new ConpherenceMenuItemView())
	->setUser($user)
	->setTitle($title)
	->setSubtitle($subtitle)
	->setHref($uri)
	->setEpoch($epoch)
	->setImageURI($image)
	->setUnreadCount($unread_count)
	->setID($thread->getPHID().'-nav-item')
	->addSigil('conpherence-menu-click')
	->setMetadata(
	array(
	- 'title' => $glyph.$data['title'],
	+ 'title' => $data['title'],
	'id' => $dom_id,
	'threadID' => $thread->getID(),
	));
	}

	private function addRoomsToMenu(
	PHUIListView $menu,
	array $rooms,
	array $policy_objects) {

	$header = $this->renderMenuItemHeader(
	pht('Rooms'),
	'conpherence-room-list-header');
	$header->appendChild(
	id(new PHUIIconView())
	->setIcon('fa-search')
	->setHref('/conpherence/search/')
	->setText(pht('Search')));
	$menu->addMenuItem($header);

	if (empty($rooms)) {
	$join_item = id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_LINK)
	->setHref('/conpherence/search/')
	->setName(pht('Join a Room'));
	$menu->addMenuItem($join_item);

	$create_item = id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_LINK)
	->setHref('/conpherence/new/')
	->setWorkflow(true)
	->setName(pht('Create a Room'));
	$menu->addMenuItem($create_item);

	return $menu;
	}

	$this->addThreadsToMenu($menu, $rooms, $policy_objects);
	return $menu;
	}

	private function addThreadsToMenu(
	PHUIListView $menu,
	array $threads,
	array $policy_objects) {

	// If we have self::SEE_MORE_LIMIT or less, we can just render
	// all the threads at once. Otherwise, we render a "See more"
	// UI element, which toggles a show / hide on the remaining rooms
	$show_threads = $threads;
	$more_threads = array();
	if (count($threads) > self::SEE_MORE_LIMIT) {
	$show_threads = array_slice($threads, 0, self::SEE_MORE_LIMIT);
	$more_threads = array_slice($threads, self::SEE_MORE_LIMIT);
	}

	foreach ($show_threads as $thread) {
	$item = $this->renderThreadItem($thread, $policy_objects);
	$menu->addMenuItem($item);
	}

	if ($more_threads) {
	$search_uri = '/conpherence/search/query/participant/';
	$sigil = 'more-room';

	$more_item = id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_LINK)
	->setHref($search_uri)
	->addSigil('conpherence-menu-see-more')
	->setMetadata(array('moreSigil' => $sigil))
	->setName(pht('See More'));
	$menu->addMenuItem($more_item);
	$show_more_threads = $more_threads;
	$even_more_threads = array();
	if (count($more_threads) > self::SEE_MORE_LIMIT) {
	$show_more_threads = array_slice(
	$more_threads,
	0,
	self::SEE_MORE_LIMIT);
	$even_more_threads = array_slice(
	$more_threads,
	self::SEE_MORE_LIMIT);
	}
	foreach ($show_more_threads as $thread) {
	$item = $this->renderThreadItem($thread, $policy_objects)
	->addSigil($sigil)
	->addClass('hidden');
	$menu->addMenuItem($item);
	}

	if ($even_more_threads) {
	// kick them to application search here
	$even_more_item = id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_LINK)
	->setHref($search_uri)
	->addSigil($sigil)
	->addClass('hidden')
	->setName(pht('See More'));
	$menu->addMenuItem($even_more_item);
	}
	}

	return $menu;
	}

	private function renderMenuItemHeader($title, $class = null) {
	$item = id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_LABEL)
	->setName($title)
	->addClass($class);
	return $item;
	}

	private function getNoRoomsMenuItem() {
	$message = phutil_tag(
	'div',
	array(
	'class' => 'no-conpherences-menu-item',
	),
	pht('No Rooms'));

	return id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_CUSTOM)
	->setName($message);
	}


	}
	diff --git a/src/applications/differential/controller/DifferentialRevisionViewController.php b/src/applications/differential/controller/DifferentialRevisionViewController.php
	index ef333a4197..39fc6ca201 100644
	--- a/src/applications/differential/controller/DifferentialRevisionViewController.php
	+++ b/src/applications/differential/controller/DifferentialRevisionViewController.php
	@@ -1,1173 +1,1174 @@
	<?php

	final class DifferentialRevisionViewController extends DifferentialController {

	private $revisionID;

	public function shouldAllowPublic() {
	return true;
	}

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

	$viewer_is_anonymous = !$viewer->isLoggedIn();

	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($this->revisionID))
	->setViewer($request->getUser())
	->needRelationships(true)
	->needReviewerStatus(true)
	->needReviewerAuthority(true)
	->executeOne();

	if (!$revision) {
	return new Aphront404Response();
	}

	$diffs = id(new DifferentialDiffQuery())
	->setViewer($request->getUser())
	->withRevisionIDs(array($this->revisionID))
	->execute();
	$diffs = array_reverse($diffs, $preserve_keys = true);

	if (!$diffs) {
	throw new Exception(
	pht('This revision has no diffs. Something has gone quite wrong.'));
	}

	$revision->attachActiveDiff(last($diffs));

	$diff_vs = $request->getInt('vs');
	$target_id = $request->getInt('id');
	$target = idx($diffs, $target_id, end($diffs));

	$target_manual = $target;
	if (!$target_id) {
	foreach ($diffs as $diff) {
	if ($diff->getCreationMethod() != 'commit') {
	$target_manual = $diff;
	}
	}
	}

	if (empty($diffs[$diff_vs])) {
	$diff_vs = null;
	}

	$repository = null;
	$repository_phid = $target->getRepositoryPHID();
	if ($repository_phid) {
	if ($repository_phid == $revision->getRepositoryPHID()) {
	$repository = $revision->getRepository();
	} else {
	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->withPHIDs(array($repository_phid))
	->executeOne();
	}
	}

	list($changesets, $vs_map, $vs_changesets, $rendering_references) =
	$this->loadChangesetsAndVsMap(
	$target,
	idx($diffs, $diff_vs),
	$repository);

	if ($request->getExists('download')) {
	return $this->buildRawDiffResponse(
	$revision,
	$changesets,
	$vs_changesets,
	$vs_map,
	$repository);
	}

	$map = $vs_map;
	if (!$map) {
	$map = array_fill_keys(array_keys($changesets), 0);
	}

	$old_ids = array();
	$new_ids = array();
	foreach ($map as $id => $vs) {
	if ($vs <= 0) {
	$old_ids[] = $id;
	$new_ids[] = $id;
	} else {
	$new_ids[] = $id;
	$new_ids[] = $vs;
	}
	}

	$this->loadDiffProperties($diffs);
	$props = $target_manual->getDiffProperties();

	$object_phids = array_merge(
	$revision->getReviewers(),
	$revision->getCCPHIDs(),
	$revision->loadCommitPHIDs(),
	array(
	$revision->getAuthorPHID(),
	$viewer->getPHID(),
	));

	foreach ($revision->getAttached() as $type => $phids) {
	foreach ($phids as $phid => $info) {
	$object_phids[] = $phid;
	}
	}

	$field_list = PhabricatorCustomField::getObjectFields(
	$revision,
	PhabricatorCustomField::ROLE_VIEW);

	$field_list->setViewer($viewer);
	$field_list->readFieldsFromStorage($revision);

	$warning_handle_map = array();
	foreach ($field_list->getFields() as $key => $field) {
	$req = $field->getRequiredHandlePHIDsForRevisionHeaderWarnings();
	foreach ($req as $phid) {
	$warning_handle_map[$key][] = $phid;
	$object_phids[] = $phid;
	}
	}

	$handles = $this->loadViewerHandles($object_phids);

	$request_uri = $request->getRequestURI();

	$limit = 100;
	$large = $request->getStr('large');
	if (count($changesets) > $limit && !$large) {
	$count = count($changesets);
	$warning = new PHUIInfoView();
	$warning->setTitle(pht('Very Large Diff'));
	$warning->setSeverity(PHUIInfoView::SEVERITY_WARNING);
	$warning->appendChild(hsprintf(
	'%s <strong>%s</strong>',
	pht(
	'This diff is very large and affects %s files. '.
	'You may load each file individually or ',
	new PhutilNumber($count)),
	phutil_tag(
	'a',
	array(
	'class' => 'button grey',
	'href' => $request_uri
	->alter('large', 'true')
	->setFragment('toc'),
	),
	pht('Show All Files Inline'))));
	$warning = $warning->render();

	$old = array_select_keys($changesets, $old_ids);
	$new = array_select_keys($changesets, $new_ids);

	$query = id(new DifferentialInlineCommentQuery())
	->setViewer($viewer)
	->needHidden(true)
	->withRevisionPHIDs(array($revision->getPHID()));
	$inlines = $query->execute();
	$inlines = $query->adjustInlinesForChangesets(
	$inlines,
	$old,
	$new,
	$revision);

	$visible_changesets = array();
	foreach ($inlines as $inline) {
	$changeset_id = $inline->getChangesetID();
	if (isset($changesets[$changeset_id])) {
	$visible_changesets[$changeset_id] = $changesets[$changeset_id];
	}
	}
	} else {
	$warning = null;
	$visible_changesets = $changesets;
	}

	$commit_hashes = mpull($diffs, 'getSourceControlBaseRevision');
	$local_commits = idx($props, 'local:commits', array());
	foreach ($local_commits as $local_commit) {
	$commit_hashes[] = idx($local_commit, 'tree');
	$commit_hashes[] = idx($local_commit, 'local');
	}
	$commit_hashes = array_unique(array_filter($commit_hashes));
	if ($commit_hashes) {
	$commits_for_links = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIdentifiers($commit_hashes)
	->execute();
	$commits_for_links = mpull(
	$commits_for_links,
	null,
	'getCommitIdentifier');
	} else {
	$commits_for_links = array();
	}

	$header = $this->buildHeader($revision);
	$subheader = $this->buildSubheaderView($revision);
	$details = $this->buildDetails($revision, $field_list);
	$curtain = $this->buildCurtain($revision);

	$whitespace = $request->getStr(
	'whitespace',
	DifferentialChangesetParser::WHITESPACE_IGNORE_MOST);

	$repository = $revision->getRepository();
	if ($repository) {
	$symbol_indexes = $this->buildSymbolIndexes(
	$repository,
	$visible_changesets);
	} else {
	$symbol_indexes = array();
	}

	$revision_warnings = $this->buildRevisionWarnings(
	$revision,
	$field_list,
	$warning_handle_map,
	$handles);
	$info_view = null;
	if ($revision_warnings) {
	$info_view = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setErrors($revision_warnings);
	}

	$detail_diffs = array_select_keys(
	$diffs,
	array($diff_vs, $target->getID()));
	$detail_diffs = mpull($detail_diffs, null, 'getPHID');

	$this->loadHarbormasterData($detail_diffs);

	$diff_detail_box = $this->buildDiffDetailView(
	$detail_diffs,
	$revision,
	$field_list);

	$unit_box = $this->buildUnitMessagesView(
	$target,
	$revision);

	$comment_view = $this->buildTransactions(
	$revision,
	$diff_vs ? $diffs[$diff_vs] : $target,
	$target,
	$old_ids,
	$new_ids);

	if (!$viewer_is_anonymous) {
	$comment_view->setQuoteRef('D'.$revision->getID());
	$comment_view->setQuoteTargetID('comment-content');
	}

	$changeset_view = id(new DifferentialChangesetListView())
	->setChangesets($changesets)
	->setVisibleChangesets($visible_changesets)
	->setStandaloneURI('/differential/changeset/')
	->setRawFileURIs(
	'/differential/changeset/?view=old',
	'/differential/changeset/?view=new')
	->setUser($viewer)
	->setDiff($target)
	->setRenderingReferences($rendering_references)
	->setVsMap($vs_map)
	->setWhitespace($whitespace)
	->setSymbolIndexes($symbol_indexes)
	->setTitle(pht('Diff %s', $target->getID()))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);

	if ($repository) {
	$changeset_view->setRepository($repository);
	}

	if (!$viewer_is_anonymous) {
	$changeset_view->setInlineCommentControllerURI(
	'/differential/comment/inline/edit/'.$revision->getID().'/');
	}

	$diff_history = id(new DifferentialRevisionUpdateHistoryView())
	->setUser($viewer)
	->setDiffs($diffs)
	->setSelectedVersusDiffID($diff_vs)
	->setSelectedDiffID($target->getID())
	->setSelectedWhitespace($whitespace)
	->setCommitsForLinks($commits_for_links);

	$local_view = id(new DifferentialLocalCommitsView())
	->setUser($viewer)
	->setLocalCommits(idx($props, 'local:commits'))
	->setCommitsForLinks($commits_for_links);

	if ($repository) {
	$other_revisions = $this->loadOtherRevisions(
	$changesets,
	$target,
	$repository);
	} else {
	$other_revisions = array();
	}

	$other_view = null;
	if ($other_revisions) {
	$other_view = $this->renderOtherRevisions($other_revisions);
	}

	$toc_view = $this->buildTableOfContents(
	$changesets,
	$visible_changesets,
	$target->loadCoverageMap($viewer));

	$comment_form = null;
	if (!$viewer_is_anonymous) {
	$comment_form = $this->buildCommentForm($revision, $field_list);
	}

	$signatures = DifferentialRequiredSignaturesField::loadForRevision(
	$revision);
	$missing_signatures = false;
	foreach ($signatures as $phid => $signed) {
	if (!$signed) {
	$missing_signatures = true;
	}
	}

	$footer = array();
	$signature_message = null;
	if ($missing_signatures) {
	$signature_message = id(new PHUIInfoView())
	->setTitle(pht('Content Hidden'))
	->appendChild(
	pht(
	'The content of this revision is hidden until the author has '.
	'signed all of the required legal agreements.'));
	} else {
	$footer[] =
	array(
	$diff_history,
	$warning,
	$local_view,
	$toc_view,
	$other_view,
	$changeset_view,
	);
	}

	if ($comment_form) {
	$footer[] = $comment_form;
	} else {
	// TODO: For now, just use this to get "Login to Comment".
	$footer[] = id(new PhabricatorApplicationTransactionCommentView())
	->setUser($viewer)
	->setRequestURI($request->getRequestURI());
	}

	$object_id = 'D'.$revision->getID();
	$operations_box = $this->buildOperationsBox($revision);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb($object_id, '/'.$object_id);
	$crumbs->setBorder(true);

	- $prefs = $viewer->loadPreferences();
	- $pref_filetree = PhabricatorUserPreferences::PREFERENCE_DIFF_FILETREE;
	+ $filetree_on = $viewer->compareUserSetting(
	+ PhabricatorShowFiletreeSetting::SETTINGKEY,
	+ PhabricatorShowFiletreeSetting::VALUE_ENABLE_FILETREE);
	+
	$nav = null;
	- if ($prefs->getPreference($pref_filetree)) {
	- $collapsed = $prefs->getPreference(
	- PhabricatorUserPreferences::PREFERENCE_NAV_COLLAPSED,
	- false);
	+ if ($filetree_on) {
	+ $collapsed_key = PhabricatorUserPreferences::PREFERENCE_NAV_COLLAPSED;
	+ $collapsed_value = $viewer->getUserSetting($collapsed_key);

	$nav = id(new DifferentialChangesetFileTreeSideNavBuilder())
	->setTitle('D'.$revision->getID())
	->setBaseURI(new PhutilURI('/D'.$revision->getID()))
	- ->setCollapsed((bool)$collapsed)
	+ ->setCollapsed((bool)$collapsed_value)
	->build($changesets);
	}

	// Haunt Mode
	$pane_id = celerity_generate_unique_node_id();
	Javelin::initBehavior(
	'differential-keyboard-navigation',
	array(
	'haunt' => $pane_id,
	));
	Javelin::initBehavior('differential-user-select');

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setSubheader($subheader)
	->setCurtain($curtain)
	->setID($pane_id)
	->setMainColumn(array(
	$operations_box,
	$info_view,
	$details,
	$diff_detail_box,
	$unit_box,
	$comment_view,
	$signature_message,
	))
	->setFooter($footer);

	$page = $this->newPage()
	->setTitle($object_id.' '.$revision->getTitle())
	->setCrumbs($crumbs)
	->setPageObjectPHIDs(array($revision->getPHID()))
	->appendChild($view);

	if ($nav) {
	$page->setNavigation($nav);
	}

	return $page;
	}

	private function buildHeader(DifferentialRevision $revision) {
	$view = id(new PHUIHeaderView())
	->setHeader($revision->getTitle($revision))
	->setUser($this->getViewer())
	->setPolicyObject($revision)
	->setHeaderIcon('fa-cog');

	$status = $revision->getStatus();
	$status_name =
	DifferentialRevisionStatus::renderFullDescription($status);

	$view->addProperty(PHUIHeaderView::PROPERTY_STATUS, $status_name);

	return $view;
	}

	private function buildSubheaderView(DifferentialRevision $revision) {
	$viewer = $this->getViewer();

	$author_phid = $revision->getAuthorPHID();

	$author = $viewer->renderHandle($author_phid)->render();
	$date = phabricator_datetime($revision->getDateCreated(), $viewer);
	$author = phutil_tag('strong', array(), $author);

	$handles = $viewer->loadHandles(array($author_phid));
	$image_uri = $handles[$author_phid]->getImageURI();
	$image_href = $handles[$author_phid]->getURI();

	$content = pht('Authored by %s on %s.', $author, $date);

	return id(new PHUIHeadThingView())
	->setImage($image_uri)
	->setImageHref($image_href)
	->setContent($content);
	}

	private function buildDetails(
	DifferentialRevision $revision,
	$custom_fields) {
	$viewer = $this->getViewer();
	$properties = id(new PHUIPropertyListView())
	->setUser($viewer);

	if ($custom_fields) {
	$custom_fields->appendFieldsToPropertyList(
	$revision,
	$viewer,
	$properties);
	}

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Details'));

	return id(new PHUIObjectBoxView())
	->setHeader($header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($properties);
	}

	private function buildCurtain(DifferentialRevision $revision) {
	$viewer = $this->getViewer();
	$revision_id = $revision->getID();
	$revision_phid = $revision->getPHID();
	$curtain = $this->newCurtainView($revision);

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

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-pencil')
	->setHref("/differential/revision/edit/{$revision_id}/")
	->setName(pht('Edit Revision'))
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit));

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-upload')
	->setHref("/differential/revision/update/{$revision_id}/")
	->setName(pht('Update Diff'))
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit));

	$this->requireResource('phabricator-object-selector-css');
	$this->requireResource('javelin-behavior-phabricator-object-selector');

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-link')
	->setName(pht('Edit Dependencies'))
	->setHref("/search/attach/{$revision_phid}/DREV/dependencies/")
	->setWorkflow(true)
	->setDisabled(!$can_edit));

	$maniphest = 'PhabricatorManiphestApplication';
	if (PhabricatorApplication::isClassInstalled($maniphest)) {
	$curtain->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-anchor')
	->setName(pht('Edit Maniphest Tasks'))
	->setHref("/search/attach/{$revision_phid}/TASK/")
	->setWorkflow(true)
	->setDisabled(!$can_edit));
	}

	$request_uri = $this->getRequest()->getRequestURI();
	$curtain->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-download')
	->setName(pht('Download Raw Diff'))
	->setHref($request_uri->alter('download', 'true')));

	return $curtain;
	}

	private function buildCommentForm(
	DifferentialRevision $revision,
	$field_list) {

	$viewer = $this->getViewer();

	$draft = id(new PhabricatorDraft())->loadOneWhere(
	'authorPHID = %s AND draftKey = %s',
	$viewer->getPHID(),
	'differential-comment-'.$revision->getID());

	$reviewers = array();
	$ccs = array();
	if ($draft) {
	$reviewers = idx($draft->getMetadata(), 'reviewers', array());
	$ccs = idx($draft->getMetadata(), 'ccs', array());
	if ($reviewers \|\| $ccs) {
	$handles = $this->loadViewerHandles(array_merge($reviewers, $ccs));
	$reviewers = array_select_keys($handles, $reviewers);
	$ccs = array_select_keys($handles, $ccs);
	}
	}

	$comment_form = id(new DifferentialAddCommentView())
	->setRevision($revision);

	$review_warnings = array();
	foreach ($field_list->getFields() as $field) {
	$review_warnings[] = $field->getWarningsForDetailView();
	}
	$review_warnings = array_mergev($review_warnings);

	if ($review_warnings) {
	$review_warnings_panel = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setErrors($review_warnings);
	$comment_form->setInfoView($review_warnings_panel);
	}

	$action_uri = $this->getApplicationURI(
	'comment/save/'.$revision->getID().'/');

	$comment_form->setActions($this->getRevisionCommentActions($revision))
	->setActionURI($action_uri)
	->setUser($viewer)
	->setDraft($draft)
	->setReviewers(mpull($reviewers, 'getFullName', 'getPHID'))
	->setCCs(mpull($ccs, 'getFullName', 'getPHID'));

	// TODO: This just makes the "Z" key work. Generalize this and remove
	// it at some point.
	$comment_form = phutil_tag(
	'div',
	array(
	'class' => 'differential-add-comment-panel',
	),
	$comment_form);
	return $comment_form;
	}

	private function getRevisionCommentActions(DifferentialRevision $revision) {
	$actions = array(
	DifferentialAction::ACTION_COMMENT => true,
	);

	$viewer = $this->getViewer();
	$viewer_phid = $viewer->getPHID();
	$viewer_is_owner = ($viewer_phid == $revision->getAuthorPHID());
	$viewer_is_reviewer = in_array($viewer_phid, $revision->getReviewers());
	$status = $revision->getStatus();

	$viewer_has_accepted = false;
	$viewer_has_rejected = false;
	$status_accepted = DifferentialReviewerStatus::STATUS_ACCEPTED;
	$status_rejected = DifferentialReviewerStatus::STATUS_REJECTED;
	foreach ($revision->getReviewerStatus() as $reviewer) {
	if ($reviewer->getReviewerPHID() == $viewer_phid) {
	if ($reviewer->getStatus() == $status_accepted) {
	$viewer_has_accepted = true;
	}
	if ($reviewer->getStatus() == $status_rejected) {
	$viewer_has_rejected = true;
	}
	break;
	}
	}

	$allow_self_accept = PhabricatorEnv::getEnvConfig(
	'differential.allow-self-accept');
	$always_allow_abandon = PhabricatorEnv::getEnvConfig(
	'differential.always-allow-abandon');
	$always_allow_close = PhabricatorEnv::getEnvConfig(
	'differential.always-allow-close');
	$allow_reopen = PhabricatorEnv::getEnvConfig(
	'differential.allow-reopen');

	if ($viewer_is_owner) {
	switch ($status) {
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	$actions[DifferentialAction::ACTION_ACCEPT] = $allow_self_accept;
	$actions[DifferentialAction::ACTION_ABANDON] = true;
	$actions[DifferentialAction::ACTION_RETHINK] = true;
	break;
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
	$actions[DifferentialAction::ACTION_ACCEPT] = $allow_self_accept;
	$actions[DifferentialAction::ACTION_ABANDON] = true;
	$actions[DifferentialAction::ACTION_REQUEST] = true;
	break;
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	$actions[DifferentialAction::ACTION_ABANDON] = true;
	$actions[DifferentialAction::ACTION_REQUEST] = true;
	$actions[DifferentialAction::ACTION_RETHINK] = true;
	$actions[DifferentialAction::ACTION_CLOSE] = true;
	break;
	case ArcanistDifferentialRevisionStatus::CLOSED:
	break;
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	$actions[DifferentialAction::ACTION_RECLAIM] = true;
	break;
	}
	} else {
	switch ($status) {
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	$actions[DifferentialAction::ACTION_ABANDON] = $always_allow_abandon;
	$actions[DifferentialAction::ACTION_ACCEPT] = true;
	$actions[DifferentialAction::ACTION_REJECT] = true;
	$actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
	break;
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
	$actions[DifferentialAction::ACTION_ABANDON] = $always_allow_abandon;
	$actions[DifferentialAction::ACTION_ACCEPT] = true;
	$actions[DifferentialAction::ACTION_REJECT] = !$viewer_has_rejected;
	$actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
	break;
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	$actions[DifferentialAction::ACTION_ABANDON] = $always_allow_abandon;
	$actions[DifferentialAction::ACTION_ACCEPT] = !$viewer_has_accepted;
	$actions[DifferentialAction::ACTION_REJECT] = true;
	$actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
	break;
	case ArcanistDifferentialRevisionStatus::CLOSED:
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	break;
	}
	if ($status != ArcanistDifferentialRevisionStatus::CLOSED) {
	$actions[DifferentialAction::ACTION_CLAIM] = true;
	$actions[DifferentialAction::ACTION_CLOSE] = $always_allow_close;
	}
	}

	$actions[DifferentialAction::ACTION_ADDREVIEWERS] = true;
	$actions[DifferentialAction::ACTION_ADDCCS] = true;
	$actions[DifferentialAction::ACTION_REOPEN] = $allow_reopen &&
	($status == ArcanistDifferentialRevisionStatus::CLOSED);

	$actions = array_keys(array_filter($actions));
	$actions_dict = array();
	foreach ($actions as $action) {
	$actions_dict[$action] = DifferentialAction::getActionVerb($action);
	}

	return $actions_dict;
	}

	private function loadChangesetsAndVsMap(
	DifferentialDiff $target,
	DifferentialDiff $diff_vs = null,
	PhabricatorRepository $repository = null) {

	$load_diffs = array($target);
	if ($diff_vs) {
	$load_diffs[] = $diff_vs;
	}

	$raw_changesets = id(new DifferentialChangesetQuery())
	->setViewer($this->getRequest()->getUser())
	->withDiffs($load_diffs)
	->execute();
	$changeset_groups = mgroup($raw_changesets, 'getDiffID');

	$changesets = idx($changeset_groups, $target->getID(), array());
	$changesets = mpull($changesets, null, 'getID');

	$refs = array();
	$vs_map = array();
	$vs_changesets = array();
	if ($diff_vs) {
	$vs_id = $diff_vs->getID();
	$vs_changesets_path_map = array();
	foreach (idx($changeset_groups, $vs_id, array()) as $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $diff_vs);
	$vs_changesets_path_map[$path] = $changeset;
	$vs_changesets[$changeset->getID()] = $changeset;
	}
	foreach ($changesets as $key => $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $target);
	if (isset($vs_changesets_path_map[$path])) {
	$vs_map[$changeset->getID()] =
	$vs_changesets_path_map[$path]->getID();
	$refs[$changeset->getID()] =
	$changeset->getID().'/'.$vs_changesets_path_map[$path]->getID();
	unset($vs_changesets_path_map[$path]);
	} else {
	$refs[$changeset->getID()] = $changeset->getID();
	}
	}
	foreach ($vs_changesets_path_map as $path => $changeset) {
	$changesets[$changeset->getID()] = $changeset;
	$vs_map[$changeset->getID()] = -1;
	$refs[$changeset->getID()] = $changeset->getID().'/-1';
	}
	} else {
	foreach ($changesets as $changeset) {
	$refs[$changeset->getID()] = $changeset->getID();
	}
	}

	$changesets = msort($changesets, 'getSortKey');

	return array($changesets, $vs_map, $vs_changesets, $refs);
	}

	private function buildSymbolIndexes(
	PhabricatorRepository $repository,
	array $visible_changesets) {
	assert_instances_of($visible_changesets, 'DifferentialChangeset');

	$engine = PhabricatorSyntaxHighlighter::newEngine();

	$langs = $repository->getSymbolLanguages();
	$langs = nonempty($langs, array());

	$sources = $repository->getSymbolSources();
	$sources = nonempty($sources, array());

	$symbol_indexes = array();

	if ($langs && $sources) {
	$have_symbols = id(new DiffusionSymbolQuery())
	->existsSymbolsInRepository($repository->getPHID());
	if (!$have_symbols) {
	return $symbol_indexes;
	}
	}

	$repository_phids = array_merge(
	array($repository->getPHID()),
	$sources);

	$indexed_langs = array_fill_keys($langs, true);
	foreach ($visible_changesets as $key => $changeset) {
	$lang = $engine->getLanguageFromFilename($changeset->getFilename());
	if (empty($indexed_langs) \|\| isset($indexed_langs[$lang])) {
	$symbol_indexes[$key] = array(
	'lang' => $lang,
	'repositories' => $repository_phids,
	);
	}
	}

	return $symbol_indexes;
	}

	private function loadOtherRevisions(
	array $changesets,
	DifferentialDiff $target,
	PhabricatorRepository $repository) {
	assert_instances_of($changesets, 'DifferentialChangeset');

	$paths = array();
	foreach ($changesets as $changeset) {
	$paths[] = $changeset->getAbsoluteRepositoryPath(
	$repository,
	$target);
	}

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

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

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

	$recent = (PhabricatorTime::getNow() - phutil_units('30 days in seconds'));

	$query = id(new DifferentialRevisionQuery())
	->setViewer($this->getRequest()->getUser())
	->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
	->withUpdatedEpochBetween($recent, null)
	->setOrder(DifferentialRevisionQuery::ORDER_MODIFIED)
	->setLimit(10)
	->needFlags(true)
	->needDrafts(true)
	->needRelationships(true);

	foreach ($path_map as $path => $path_id) {
	$query->withPath($repository->getID(), $path_id);
	}

	$results = $query->execute();

	// Strip out this revision.
	foreach ($results as $key => $result) {
	if ($result->getID() == $this->revisionID) {
	unset($results[$key]);
	}
	}

	return $results;
	}

	private function renderOtherRevisions(array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');
	$viewer = $this->getViewer();

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Recent Similar Revisions'));

	$view = id(new DifferentialRevisionListView())
	->setHeader($header)
	->setRevisions($revisions)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setUser($viewer);

	$phids = $view->getRequiredHandlePHIDs();
	$handles = $this->loadViewerHandles($phids);
	$view->setHandles($handles);

	return $view;
	}


	/**
	* Note this code is somewhat similar to the buildPatch method in
	* @{class:DifferentialReviewRequestMail}.
	*
	* @return @{class:AphrontRedirectResponse}
	*/
	private function buildRawDiffResponse(
	DifferentialRevision $revision,
	array $changesets,
	array $vs_changesets,
	array $vs_map,
	PhabricatorRepository $repository = null) {

	assert_instances_of($changesets, 'DifferentialChangeset');
	assert_instances_of($vs_changesets, 'DifferentialChangeset');

	$viewer = $this->getViewer();

	id(new DifferentialHunkQuery())
	->setViewer($viewer)
	->withChangesets($changesets)
	->needAttachToChangesets(true)
	->execute();

	$diff = new DifferentialDiff();
	$diff->attachChangesets($changesets);
	$raw_changes = $diff->buildChangesList();
	$changes = array();
	foreach ($raw_changes as $changedict) {
	$changes[] = ArcanistDiffChange::newFromDictionary($changedict);
	}

	$loader = id(new PhabricatorFileBundleLoader())
	->setViewer($viewer);

	$bundle = ArcanistBundle::newFromChanges($changes);
	$bundle->setLoadFileDataCallback(array($loader, 'loadFileData'));

	$vcs = $repository ? $repository->getVersionControlSystem() : null;
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$raw_diff = $bundle->toGitPatch();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	default:
	$raw_diff = $bundle->toUnifiedDiff();
	break;
	}

	$request_uri = $this->getRequest()->getRequestURI();

	// this ends up being something like
	// D123.diff
	// or the verbose
	// D123.vs123.id123.whitespaceignore-all.diff
	// lame but nice to include these options
	$file_name = ltrim($request_uri->getPath(), '/').'.';
	foreach ($request_uri->getQueryParams() as $key => $value) {
	if ($key == 'download') {
	continue;
	}
	$file_name .= $key.$value.'.';
	}
	$file_name .= 'diff';

	$file = PhabricatorFile::buildFromFileDataOrHash(
	$raw_diff,
	array(
	'name' => $file_name,
	'ttl' => (60 * 60 * 24),
	'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
	));

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$file->attachToObject($revision->getPHID());
	unset($unguarded);

	return $file->getRedirectResponse();
	}

	private function buildTransactions(
	DifferentialRevision $revision,
	DifferentialDiff $left_diff,
	DifferentialDiff $right_diff,
	array $old_ids,
	array $new_ids) {

	$timeline = $this->buildTransactionTimeline(
	$revision,
	new DifferentialTransactionQuery(),
	$engine = null,
	array(
	'left' => $left_diff->getID(),
	'right' => $right_diff->getID(),
	'old' => implode(',', $old_ids),
	'new' => implode(',', $new_ids),
	));

	return $timeline;
	}

	private function buildRevisionWarnings(
	DifferentialRevision $revision,
	PhabricatorCustomFieldList $field_list,
	array $warning_handle_map,
	array $handles) {

	$warnings = array();
	foreach ($field_list->getFields() as $key => $field) {
	$phids = idx($warning_handle_map, $key, array());
	$field_handles = array_select_keys($handles, $phids);
	$field_warnings = $field->getWarningsForRevisionHeader($field_handles);
	foreach ($field_warnings as $warning) {
	$warnings[] = $warning;
	}
	}

	return $warnings;
	}

	private function buildDiffDetailView(
	array $diffs,
	DifferentialRevision $revision,
	PhabricatorCustomFieldList $field_list) {
	$viewer = $this->getViewer();

	$fields = array();
	foreach ($field_list->getFields() as $field) {
	if ($field->shouldAppearInDiffPropertyView()) {
	$fields[] = $field;
	}
	}

	if (!$fields) {
	return null;
	}

	$property_lists = array();
	foreach ($this->getDiffTabLabels($diffs) as $tab) {
	list($label, $diff) = $tab;

	$property_lists[] = array(
	$label,
	$this->buildDiffPropertyList($diff, $revision, $fields),
	);
	}

	$box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Diff Detail'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setUser($viewer);

	$last_tab = null;
	foreach ($property_lists as $key => $property_list) {
	list($tab_name, $list_view) = $property_list;

	$tab = id(new PHUIListItemView())
	->setKey($key)
	->setName($tab_name);

	$box->addPropertyList($list_view, $tab);
	$last_tab = $tab;
	}

	if ($last_tab) {
	$last_tab->setSelected(true);
	}

	return $box;
	}

	private function buildDiffPropertyList(
	DifferentialDiff $diff,
	DifferentialRevision $revision,
	array $fields) {
	$viewer = $this->getViewer();

	$view = id(new PHUIPropertyListView())
	->setUser($viewer)
	->setObject($diff);

	foreach ($fields as $field) {
	$label = $field->renderDiffPropertyViewLabel($diff);
	$value = $field->renderDiffPropertyViewValue($diff);
	if ($value !== null) {
	$view->addProperty($label, $value);
	}
	}

	return $view;
	}

	private function buildOperationsBox(DifferentialRevision $revision) {
	$viewer = $this->getViewer();

	// Save a query if we can't possibly have pending operations.
	$repository = $revision->getRepository();
	if (!$repository \|\| !$repository->canPerformAutomation()) {
	return null;
	}

	$operations = id(new DrydockRepositoryOperationQuery())
	->setViewer($viewer)
	->withObjectPHIDs(array($revision->getPHID()))
	->withIsDismissed(false)
	->withOperationTypes(
	array(
	DrydockLandRepositoryOperation::OPCONST,
	))
	->execute();
	if (!$operations) {
	return null;
	}

	$state_fail = DrydockRepositoryOperation::STATE_FAIL;

	// We're going to show the oldest operation which hasn't failed, or the
	// most recent failure if they're all failures.
	$operations = msort($operations, 'getID');
	foreach ($operations as $operation) {
	if ($operation->getOperationState() != $state_fail) {
	break;
	}
	}

	// If we found a completed operation, don't render anything. We don't want
	// to show an older error after the thing worked properly.
	if ($operation->isDone()) {
	return null;
	}

	$box_view = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Active Operations'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);

	return id(new DrydockRepositoryOperationStatusView())
	->setUser($viewer)
	->setBoxView($box_view)
	->setOperation($operation);
	}

	private function buildUnitMessagesView(
	$diff,
	DifferentialRevision $revision) {
	$viewer = $this->getViewer();

	if (!$diff->getBuildable()) {
	return null;
	}

	if (!$diff->getUnitMessages()) {
	return null;
	}

	$interesting_messages = array();
	foreach ($diff->getUnitMessages() as $message) {
	switch ($message->getResult()) {
	case ArcanistUnitTestResult::RESULT_PASS:
	case ArcanistUnitTestResult::RESULT_SKIP:
	break;
	default:
	$interesting_messages[] = $message;
	break;
	}
	}

	if (!$interesting_messages) {
	return null;
	}

	$excuse = null;
	if ($diff->hasDiffProperty('arc:unit-excuse')) {
	$excuse = $diff->getProperty('arc:unit-excuse');
	}

	return id(new HarbormasterUnitSummaryView())
	->setUser($viewer)
	->setExcuse($excuse)
	->setBuildable($diff->getBuildable())
	->setUnitMessages($diff->getUnitMessages())
	->setLimit(5)
	->setShowViewAll(true);
	}


	}
	diff --git a/src/applications/differential/parser/DifferentialChangesetParser.php b/src/applications/differential/parser/DifferentialChangesetParser.php
	index e49538fd91..c745d8e42a 100644
	--- a/src/applications/differential/parser/DifferentialChangesetParser.php
	+++ b/src/applications/differential/parser/DifferentialChangesetParser.php
	@@ -1,1696 +1,1699 @@
	<?php

	final class DifferentialChangesetParser extends Phobject {

	const HIGHLIGHT_BYTE_LIMIT = 262144;

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

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

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

	protected $changeset;
	protected $whitespaceMode = null;

	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 $characterEncoding;
	private $highlightAs;
	private $highlightingDisabled;
	private $showEditAndReplyLinks = true;
	private $canMarkDone;
	private $objectOwnerPHID;
	private $offsetMode;

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

	private $highlightEngine;

	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 setHighlightAs($highlight_as) {
	$this->highlightAs = $highlight_as;
	return $this;
	}

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

	public function setCharacterEncoding($character_encoding) {
	$this->characterEncoding = $character_encoding;
	return $this;
	}

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

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

	public function getRenderer() {
	if (!$this->renderer) {
	return new DifferentialChangesetTwoUpRenderer();
	}
	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 static function getDefaultRendererForViewer(PhabricatorUser $viewer) {
	- $prefs = $viewer->loadPreferences();
	- $pref_unified = PhabricatorUserPreferences::PREFERENCE_DIFF_UNIFIED;
	- if ($prefs->getPreference($pref_unified) == 'unified') {
	+ $is_unified = $viewer->compareUserSetting(
	+ PhabricatorUnifiedDiffsSetting::SETTINGKEY,
	+ PhabricatorUnifiedDiffsSetting::VALUE_ALWAYS_UNIFIED);
	+
	+ if ($is_unified) {
	return '1up';
	}
	+
	return null;
	}

	public function readParametersFromRequest(AphrontRequest $request) {
	$this->setWhitespaceMode($request->getStr('whitespace'));
	$this->setCharacterEncoding($request->getStr('encoding'));
	$this->setHighlightAs($request->getStr('highlight'));

	$renderer = null;

	// If the viewer prefers unified diffs, always set the renderer to unified.
	// Otherwise, we leave it unspecified and the client will choose a
	// renderer based on the screen size.

	if ($request->getStr('renderer')) {
	$renderer = $request->getStr('renderer');
	} else {
	$renderer = self::getDefaultRendererForViewer($request->getViewer());
	}

	switch ($renderer) {
	case '1up':
	$this->setRenderer(new DifferentialChangesetOneUpRenderer());
	break;
	default:
	$this->setRenderer(new DifferentialChangesetTwoUpRenderer());
	break;
	}

	return $this;
	}

	const CACHE_VERSION = 11;
	const CACHE_MAX_SIZE = 8e6;

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

	const WHITESPACE_SHOW_ALL = 'show-all';
	const WHITESPACE_IGNORE_TRAILING = 'ignore-trailing';
	const WHITESPACE_IGNORE_MOST = 'ignore-most';
	const WHITESPACE_IGNORE_ALL = 'ignore-all';

	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 setVisibileLinesMask(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.
	*
	* NOTE: Currently, this key must be a valid Differential Changeset ID.
	*
	* @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 setWhitespaceMode($whitespace_mode) {
	$this->whitespaceMode = $whitespace_mode;
	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 setUser(PhabricatorUser $user) {
	$this->user = $user;
	return $this;
	}

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

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

	public function parseInlineComment(
	PhabricatorInlineCommentInterface $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 id = %d',
	$changeset->getTableName().'_parse_cache',
	$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',
	'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 (id, cache, dateCreated) VALUES (%d, %B, %d)
	ON DUPLICATE KEY UPDATE cache = VALUES(cache)',
	DifferentialChangeset::TABLE_CACHE,
	$render_cache_key,
	$cache,
	time());
	} 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');
	$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 isWhitespaceOnly() {
	return idx($this->specialAttributes, self::ATTR_WHITELINES, false);
	}

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

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

	foreach ($render as $key => $text) {
	if (isset($intra[$key])) {
	$render[$key] = ArcanistDiffUtils::applyIntralineDiff(
	$text,
	$intra[$key]);
	}
	}
	}

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

	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() {
	$whitespace_mode = $this->whitespaceMode;
	switch ($whitespace_mode) {
	case self::WHITESPACE_SHOW_ALL:
	case self::WHITESPACE_IGNORE_TRAILING:
	case self::WHITESPACE_IGNORE_ALL:
	break;
	default:
	$whitespace_mode = self::WHITESPACE_IGNORE_MOST;
	break;
	}

	$skip_cache = ($whitespace_mode != self::WHITESPACE_IGNORE_MOST);
	if ($this->disableCache) {
	$skip_cache = true;
	}

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

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

	$this->whitespaceMode = $whitespace_mode;

	$changeset = $this->changeset;

	if ($changeset->getFileType() != DifferentialChangeType::FILE_TEXT &&
	$changeset->getFileType() != DifferentialChangeType::FILE_SYMLINK) {

	$this->markGenerated();

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

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

	$ignore_all = (($whitespace_mode == self::WHITESPACE_IGNORE_MOST) \|\|
	($whitespace_mode == self::WHITESPACE_IGNORE_ALL));

	$force_ignore = ($whitespace_mode == self::WHITESPACE_IGNORE_ALL);

	if (!$force_ignore) {
	if ($ignore_all && $changeset->getWhitespaceMatters()) {
	$ignore_all = false;
	}
	}

	// The "ignore all whitespace" algorithm 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,
	// don't use the "ignore all" algorithm.
	if ($ignore_all) {
	$hunks = $changeset->getHunks();
	if (count($hunks) !== 1) {
	$ignore_all = false;
	} else {
	$first_hunk = reset($hunks);
	if ($first_hunk->getOldOffset() != 1 \|\|
	$first_hunk->getNewOffset() != 1) {
	$ignore_all = false;
	}
	}
	}

	if ($ignore_all) {
	$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).
	$ignore_all = false;
	}
	}

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

	// Depending on the whitespace mode, we may need to compute a different
	// set of changes than the set of changes in the hunk data (specificaly,
	// we might want to consider changed lines which have only whitespace
	// changes as unchanged).
	if ($ignore_all) {
	$engine = new PhabricatorDifferenceEngine();
	$engine->setIgnoreWhitespace(true);
	$no_whitespace_changeset = $engine->generateChangesetFromFileContent(
	$old_file,
	$new_file);

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

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

	$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_WHITELINES => !$hunk_parser->getHasTextChanges(),
	self::ATTR_MOVEAWAY => $moveaway,
	));

	$lines_context = $this->getLinesOfContext();

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

	$this->setOldLines($hunk_parser->getOldLines());
	$this->setNewLines($hunk_parser->getNewLines());
	$this->setIntraLineDiffs($hunk_parser->getIntraLineDiffs());
	$this->setVisibileLinesMask($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()) {

	// "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();

	$encoding = null;
	if ($this->characterEncoding) {
	// 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 = $this->characterEncoding;
	foreach ($this->changeset->getHunks() as $hunk) {
	$hunk->forceEncoding($this->characterEncoding);
	}
	} 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;
	}

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

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

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

	$renderer = $this->getRenderer()
	->setUser($this->getUser())
	->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())
	->setMarkupEngine($this->markupEngine)
	->setHandles($this->handles)
	->setOldLines($this->old)
	->setNewLines($this->new)
	->setOriginalCharacterEncoding($encoding)
	->setShowEditAndReplyLinks($this->getShowEditAndReplyLinks())
	->setCanMarkDone($this->getCanMarkDone())
	->setObjectOwnerPHID($this->getObjectOwnerPHID())
	->setHighlightingDisabled($this->highlightingDisabled);

	$shield = null;
	if ($this->isTopLevel && !$this->comments) {
	if ($this->isGenerated()) {
	$shield = $renderer->renderShield(
	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 = '';
	} 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';
	}

	$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 = $renderer->renderShield(
	pht('This is an empty file.'),
	$type);
	} else {
	$shield = $renderer->renderShield(
	pht('The contents of this file were not changed.'),
	$type);
	}
	} else if ($this->isWhitespaceOnly()) {
	$shield = $renderer->renderShield(
	pht('This file was changed only by adding or removing whitespace.'),
	'whitespace');
	} else if ($this->isDeleted()) {
	$shield = $renderer->renderShield(
	pht('This file was completely deleted.'));
	} else if ($this->changeset->getAffectedLineCount() > 2500) {
	$shield = $renderer->renderShield(
	pht(
	'This file has a very large number of changes (%s lines).',
	new PhutilNumber($this->changeset->getAffectedLineCount())));
	}
	}

	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();
	if ($new_side) {
	$back_line = $new_backmap[$line];
	} else {
	$back_line = $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 = $this->reorderAndThreadComments($this->comments);

	foreach ($this->comments as $comment) {
	$final = $comment->getLineNumber() +
	$comment->getLineLength();
	$final = max(1, $final);
	if ($this->isCommentOnRightSideWhenDisplayed($comment)) {
	$new_comments[$final][] = $comment;
	} else {
	$old_comments[$final][] = $comment;
	}
	}
	}
	$renderer
	->setOldComments($old_comments)
	->setNewComments($new_comments);

	switch ($this->changeset->getFileType()) {
	case DifferentialChangeType::FILE_IMAGE:
	$old = null;
	$new = null;
	// TODO: Improve the architectural issue as discussed in D955
	// https://secure.phabricator.com/D955
	$reference = $this->getRenderingReference();
	$parts = explode('/', $reference);
	if (count($parts) == 2) {
	list($id, $vs) = $parts;
	} else {
	$id = $parts[0];
	$vs = 0;
	}
	$id = (int)$id;
	$vs = (int)$vs;

	if (!$vs) {
	$metadata = $this->changeset->getMetadata();
	$data = idx($metadata, 'attachment-data');

	$old_phid = idx($metadata, 'old:binary-phid');
	$new_phid = idx($metadata, 'new:binary-phid');
	} else {
	$vs_changeset = id(new DifferentialChangeset())->load($vs);
	$old_phid = null;
	$new_phid = null;

	// TODO: This is spooky, see D6851
	if ($vs_changeset) {
	$vs_metadata = $vs_changeset->getMetadata();
	$old_phid = idx($vs_metadata, 'new:binary-phid');
	}

	$changeset = id(new DifferentialChangeset())->load($id);
	if ($changeset) {
	$metadata = $changeset->getMetadata();
	$new_phid = idx($metadata, 'new:binary-phid');
	}
	}

	if ($old_phid \|\| $new_phid) {
	// grab the files, (micro) optimization for 1 query not 2
	$file_phids = array();
	if ($old_phid) {
	$file_phids[] = $old_phid;
	}
	if ($new_phid) {
	$file_phids[] = $new_phid;
	}

	$files = id(new PhabricatorFileQuery())
	->setViewer($this->getUser())
	->withPHIDs($file_phids)
	->execute();
	foreach ($files as $file) {
	if (empty($file)) {
	continue;
	}
	if ($file->getPHID() == $old_phid) {
	$old = $file;
	} else if ($file->getPHID() == $new_phid) {
	$new = $file;
	}
	}
	}

	$renderer->attachOldFile($old);
	$renderer->attachNewFile($new);

	return $renderer->renderFileChange($old, $new, $id, $vs);
	case DifferentialChangeType::FILE_DIRECTORY:
	case DifferentialChangeType::FILE_BINARY:
	$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, $depths) = $this->calculateGapsMaskAndDepths(
	$mask_force,
	$feedback_mask,
	$range_start,
	$range_len);

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

	$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 sparesely populated dictionary
	* of $visible_line_number => true.
	*
	* Depths - compute how indented any given line is. The $depths returned
	* is a sparesely populated dictionary of $visible_line_number => $depth.
	*
	* This function also has the side effect of modifying member variable
	* new such that tabs are normalized to spaces for each line of the diff.
	*
	* @return array($gaps, $mask, $depths)
	*/
	private function calculateGapsMaskAndDepths(
	$mask_force,
	$feedback_mask,
	$range_start,
	$range_len) {

	$lines_context = $this->getLinesOfContext();

	// Calculate gaps and mask first
	$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;

	// Time to calculate depth.
	// We need to go backwards to properly indent whitespace in this code:
	//
	// 0: class C {
	// 1:
	// 1: function f() {
	// 2:
	// 2: return;
	// 1:
	// 1: }
	// 0:
	// 0: }
	//
	$depths = array();
	$last_depth = 0;
	$range_end = $range_start + $range_len;
	if (!isset($this->new[$range_end])) {
	$range_end--;
	}
	for ($ii = $range_end; $ii >= $range_start; $ii--) {
	// We need to expand tabs to process mixed indenting and to round
	// correctly later.
	$line = str_replace("\t", ' ', $this->new[$ii]['text']);
	$trimmed = ltrim($line);
	if ($trimmed != '') {
	// We round down to flatten "/*" and " ".
	$last_depth = floor((strlen($line) - strlen($trimmed)) / 2);
	}
	$depths[$ii] = $last_depth;
	}

	return array($gaps, $mask, $depths);
	}

	/**
	* Determine if an inline comment will appear on the rendered diff,
	* taking into consideration which halves of which changesets will actually
	* be shown.
	*
	* @param PhabricatorInlineCommentInterface Comment to test for visibility.
	* @return bool True if the comment is visible on the rendered diff.
	*/
	private function isCommentVisibleOnRenderedDiff(
	PhabricatorInlineCommentInterface $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 PhabricatorInlineCommentInterface Comment to test for display
	* location.
	* @return bool True for right, false for left.
	*/
	private function isCommentOnRightSideWhenDisplayed(
	PhabricatorInlineCommentInterface $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['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)));
	}

	public function detectCopiedCode(
	array $changesets,
	$min_width = 30,
	$min_lines = 3) {

	assert_instances_of($changesets, 'DifferentialChangeset');

	$map = array();
	$files = array();
	$types = array();
	foreach ($changesets as $changeset) {
	$file = $changeset->getFilename();
	foreach ($changeset->getHunks() as $hunk) {
	$lines = $hunk->getStructuredOldFile();
	foreach ($lines as $line => $info) {
	$type = $info['type'];
	if ($type == '\\') {
	continue;
	}
	$types[$file][$line] = $type;

	$text = $info['text'];
	$text = trim($text);
	$files[$file][$line] = $text;

	if (strlen($text) >= $min_width) {
	$map[$text][] = array($file, $line);
	}
	}
	}
	}

	foreach ($changesets as $changeset) {
	$copies = array();
	foreach ($changeset->getHunks() as $hunk) {
	$added = $hunk->getStructuredNewFile();
	$atype = array();

	foreach ($added as $line => $info) {
	$atype[$line] = $info['type'];
	$added[$line] = trim($info['text']);
	}

	$skip_lines = 0;
	foreach ($added as $line => $code) {
	if ($skip_lines) {
	// We're skipping lines that we already processed because we
	// extended a block above them downward to include them.
	$skip_lines--;
	continue;
	}

	if ($atype[$line] !== '+') {
	// This line hasn't been changed in the new file, so don't try
	// to figure out where it came from.
	continue;
	}

	if (empty($map[$code])) {
	// This line was too short to trigger copy/move detection.
	continue;
	}

	if (count($map[$code]) > 16) {
	// If there are a large number of identical lines in this diff,
	// don't try to figure out where this block came from: the analysis
	// is O(N^2), since we need to compare every line against every
	// other line. Even if we arrive at a result, it is unlikely to be
	// meaningful. See T5041.
	continue;
	}

	$best_length = 0;

	// Explore all candidates.
	foreach ($map[$code] as $val) {
	list($file, $orig_line) = $val;
	$length = 1;

	// Search backward and forward to find all of the adjacent lines
	// which match.
	foreach (array(-1, 1) as $direction) {
	$offset = $direction;
	while (true) {
	if (isset($copies[$line + $offset])) {
	// If we run into a block above us which we've already
	// attributed to a move or copy from elsewhere, stop
	// looking.
	break;
	}

	if (!isset($added[$line + $offset])) {
	// If we've run off the beginning or end of the new file,
	// stop looking.
	break;
	}

	if (!isset($files[$file][$orig_line + $offset])) {
	// If we've run off the beginning or end of the original
	// file, we also stop looking.
	break;
	}

	$old = $files[$file][$orig_line + $offset];
	$new = $added[$line + $offset];
	if ($old !== $new) {
	// If the old line doesn't match the new line, stop
	// looking.
	break;
	}

	$length++;
	$offset += $direction;
	}
	}

	if ($length < $best_length) {
	// If we already know of a better source (more matching lines)
	// for this move/copy, stick with that one. We prefer long
	// copies/moves which match a lot of context over short ones.
	continue;
	}

	if ($length == $best_length) {
	if (idx($types[$file], $orig_line) != '-') {
	// If we already know of an equally good source (same number
	// of matching lines) and this isn't a move, stick with the
	// other one. We prefer moves over copies.
	continue;
	}
	}

	$best_length = $length;
	// ($offset - 1) contains number of forward matching lines.
	$best_offset = $offset - 1;
	$best_file = $file;
	$best_line = $orig_line;
	}

	$file = ($best_file == $changeset->getFilename() ? '' : $best_file);
	for ($i = $best_length; $i--; ) {
	$type = idx($types[$best_file], $best_line + $best_offset - $i);
	$copies[$line + $best_offset - $i] = ($best_length < $min_lines
	? array() // Ignore short blocks.
	: array($file, $best_line + $best_offset - $i, $type));
	}

	$skip_lines = $best_offset;
	}
	}

	$copies = array_filter($copies);
	if ($copies) {
	$metadata = $changeset->getMetadata();
	$metadata['copy:lines'] = $copies;
	$changeset->setMetadata($metadata);
	}
	}
	return $changesets;
	}

	/**
	* 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) {
	$old_back[$old['line']] = $old['line'];
	}
	foreach ($this->new as $ii => $new) {
	$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 reorderAndThreadComments(array $comments) {
	$comments = msort($comments, 'getID');

	// Build an empty map of all the comments we actually have. If a comment
	// is a reply but the parent has gone missing, we don't want it to vanish
	// completely.
	$comment_phids = mpull($comments, 'getPHID');
	$replies = array_fill_keys($comment_phids, array());

	// Now, remove all comments which are replies, leaving only the top-level
	// comments.
	foreach ($comments as $key => $comment) {
	$reply_phid = $comment->getReplyToCommentPHID();
	if (isset($replies[$reply_phid])) {
	$replies[$reply_phid][] = $comment;
	unset($comments[$key]);
	}
	}

	// For each top level comment, add the comment, then add any replies
	// to it. Do this recursively so threads are shown in threaded order.
	$results = array();
	foreach ($comments as $comment) {
	$results[] = $comment;
	$phid = $comment->getPHID();
	$descendants = $this->getInlineReplies($replies, $phid, 1);
	foreach ($descendants as $descendant) {
	$results[] = $descendant;
	}
	}

	// If we have anything left, they were cyclic references. Just dump
	// them in a the end. This should be impossible, but users are very
	// creative.
	foreach ($replies as $phid => $comments) {
	foreach ($comments as $comment) {
	$results[] = $comment;
	}
	}

	return $results;
	}

	private function getInlineReplies(array &$replies, $phid, $depth) {
	$comments = idx($replies, $phid, array());
	unset($replies[$phid]);

	$results = array();
	foreach ($comments as $comment) {
	$results[] = $comment;
	$descendants = $this->getInlineReplies(
	$replies,
	$comment->getPHID(),
	$depth + 1);
	foreach ($descendants as $descendant) {
	$results[] = $descendant;
	}
	}

	return $results;
	}

	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;
	}

	}
	diff --git a/src/applications/differential/query/DifferentialInlineCommentQuery.php b/src/applications/differential/query/DifferentialInlineCommentQuery.php
	index 7e986bdc60..3f8ea62e14 100644
	--- a/src/applications/differential/query/DifferentialInlineCommentQuery.php
	+++ b/src/applications/differential/query/DifferentialInlineCommentQuery.php
	@@ -1,482 +1,483 @@
	<?php

	/**
	* Temporary wrapper for transitioning Differential to ApplicationTransactions.
	*/
	final class DifferentialInlineCommentQuery
	extends PhabricatorOffsetPagedQuery {

	// TODO: Remove this when this query eventually moves to PolicyAware.
	private $viewer;

	private $ids;
	private $phids;
	private $drafts;
	private $authorPHIDs;
	private $revisionPHIDs;
	private $deletedDrafts;
	private $needHidden;

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

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

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

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

	public function withDrafts($drafts) {
	$this->drafts = $drafts;
	return $this;
	}

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

	public function withRevisionPHIDs(array $revision_phids) {
	$this->revisionPHIDs = $revision_phids;
	return $this;
	}

	public function withDeletedDrafts($deleted_drafts) {
	$this->deletedDrafts = $deleted_drafts;
	return $this;
	}

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

	public function execute() {
	$table = new DifferentialTransactionComment();
	$conn_r = $table->establishConnection('r');

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

	$comments = $table->loadAllFromArray($data);

	if ($this->needHidden) {
	$viewer_phid = $this->getViewer()->getPHID();
	if ($viewer_phid && $comments) {
	$hidden = queryfx_all(
	$conn_r,
	'SELECT commentID FROM %T WHERE userPHID = %s
	AND commentID IN (%Ls)',
	id(new DifferentialHiddenComment())->getTableName(),
	$viewer_phid,
	mpull($comments, 'getID'));
	$hidden = array_fuse(ipull($hidden, 'commentID'));
	} else {
	$hidden = array();
	}

	foreach ($comments as $inline) {
	$inline->attachIsHidden(isset($hidden[$inline->getID()]));
	}
	}

	foreach ($comments as $key => $value) {
	$comments[$key] = DifferentialInlineComment::newFromModernComment(
	$value);
	}

	return $comments;
	}

	public function executeOne() {
	// TODO: Remove when this query moves to PolicyAware.
	return head($this->execute());
	}

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

	// Only find inline comments.
	$where[] = qsprintf(
	$conn_r,
	'changesetID IS NOT NULL');

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

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

	if ($this->revisionPHIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'revisionPHID IN (%Ls)',
	$this->revisionPHIDs);
	}

	if ($this->drafts === null) {
	if ($this->deletedDrafts) {
	$where[] = qsprintf(
	$conn_r,
	'(authorPHID = %s) OR (transactionPHID IS NOT NULL)',
	$this->getViewer()->getPHID());
	} else {
	$where[] = qsprintf(
	$conn_r,
	'(authorPHID = %s AND isDeleted = 0)
	OR (transactionPHID IS NOT NULL)',
	$this->getViewer()->getPHID());
	}
	} else if ($this->drafts) {
	$where[] = qsprintf(
	$conn_r,
	'(authorPHID = %s AND isDeleted = 0) AND (transactionPHID IS NULL)',
	$this->getViewer()->getPHID());
	} else {
	$where[] = qsprintf(
	$conn_r,
	'transactionPHID IS NOT NULL');
	}

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

	public function adjustInlinesForChangesets(
	array $inlines,
	array $old,
	array $new,
	DifferentialRevision $revision) {

	assert_instances_of($inlines, 'DifferentialInlineComment');
	assert_instances_of($old, 'DifferentialChangeset');
	assert_instances_of($new, 'DifferentialChangeset');

	$viewer = $this->getViewer();

	- $pref = $viewer->loadPreferences()->getPreference(
	- PhabricatorUserPreferences::PREFERENCE_DIFF_GHOSTS);
	- if ($pref == 'disabled') {
	+ $no_ghosts = $viewer->compareUserSetting(
	+ PhabricatorOlderInlinesSetting::SETTINGKEY,
	+ PhabricatorOlderInlinesSetting::VALUE_GHOST_INLINES_DISABLED);
	+ if ($no_ghosts) {
	return $inlines;
	}

	$all = array_merge($old, $new);

	$changeset_ids = mpull($inlines, 'getChangesetID');
	$changeset_ids = array_unique($changeset_ids);

	$all_map = mpull($all, null, 'getID');

	// We already have at least some changesets, and we might not need to do
	// any more data fetching. Remove everything we already have so we can
	// tell if we need new stuff.
	foreach ($changeset_ids as $key => $id) {
	if (isset($all_map[$id])) {
	unset($changeset_ids[$key]);
	}
	}

	if ($changeset_ids) {
	$changesets = id(new DifferentialChangesetQuery())
	->setViewer($viewer)
	->withIDs($changeset_ids)
	->execute();
	$changesets = mpull($changesets, null, 'getID');
	} else {
	$changesets = array();
	}
	$changesets += $all_map;

	$id_map = array();
	foreach ($all as $changeset) {
	$id_map[$changeset->getID()] = $changeset->getID();
	}

	// Generate filename maps for older and newer comments. If we're bringing
	// an older comment forward in a diff-of-diffs, we want to put it on the
	// left side of the screen, not the right side. Both sides are "new" files
	// with the same name, so they're both appropriate targets, but the left
	// is a better target conceptually for users because it's more consistent
	// with the rest of the UI, which shows old information on the left and
	// new information on the right.
	$move_here = DifferentialChangeType::TYPE_MOVE_HERE;

	$name_map_old = array();
	$name_map_new = array();
	$move_map = array();
	foreach ($all as $changeset) {
	$changeset_id = $changeset->getID();

	$filenames = array();
	$filenames[] = $changeset->getFilename();

	// If this is the target of a move, also map comments on the old filename
	// to this changeset.
	if ($changeset->getChangeType() == $move_here) {
	$old_file = $changeset->getOldFile();
	$filenames[] = $old_file;
	$move_map[$changeset_id][$old_file] = true;
	}

	foreach ($filenames as $filename) {
	// We update the old map only if we don't already have an entry (oldest
	// changeset persists).
	if (empty($name_map_old[$filename])) {
	$name_map_old[$filename] = $changeset_id;
	}

	// We always update the new map (newest changeset overwrites).
	$name_map_new[$changeset->getFilename()] = $changeset_id;
	}
	}

	// Find the smallest "new" changeset ID. We'll consider everything
	// larger than this to be "newer", and everything smaller to be "older".
	$first_new_id = min(mpull($new, 'getID'));

	$results = array();
	foreach ($inlines as $inline) {
	$changeset_id = $inline->getChangesetID();
	if (isset($id_map[$changeset_id])) {
	// This inline is legitimately on one of the current changesets, so
	// we can include it in the result set unmodified.
	$results[] = $inline;
	continue;
	}

	$changeset = idx($changesets, $changeset_id);
	if (!$changeset) {
	// Just discard this inline, as it has bogus data.
	continue;
	}

	$target_id = null;

	if ($changeset_id >= $first_new_id) {
	$name_map = $name_map_new;
	$is_new = true;
	} else {
	$name_map = $name_map_old;
	$is_new = false;
	}

	$filename = $changeset->getFilename();
	if (isset($name_map[$filename])) {
	// This changeset is on a file with the same name as the current
	// changeset, so we're going to port it forward or backward.
	$target_id = $name_map[$filename];

	$is_move = isset($move_map[$target_id][$filename]);
	if ($is_new) {
	if ($is_move) {
	$reason = pht(
	'This comment was made on a file with the same name as the '.
	'file this file was moved from, but in a newer diff.');
	} else {
	$reason = pht(
	'This comment was made on a file with the same name, but '.
	'in a newer diff.');
	}
	} else {
	if ($is_move) {
	$reason = pht(
	'This comment was made on a file with the same name as the '.
	'file this file was moved from, but in an older diff.');
	} else {
	$reason = pht(
	'This comment was made on a file with the same name, but '.
	'in an older diff.');
	}
	}
	}


	// If we didn't find a target and this change is the target of a move,
	// look for a match against the old filename.
	if (!$target_id) {
	if ($changeset->getChangeType() == $move_here) {
	$filename = $changeset->getOldFile();
	if (isset($name_map[$filename])) {
	$target_id = $name_map[$filename];
	if ($is_new) {
	$reason = pht(
	'This comment was made on a file which this file was moved '.
	'to, but in a newer diff.');
	} else {
	$reason = pht(
	'This comment was made on a file which this file was moved '.
	'to, but in an older diff.');
	}
	}
	}
	}


	// If we found a changeset to port this comment to, bring it forward
	// or backward and mark it.
	if ($target_id) {
	$diff_id = $changeset->getDiffID();
	$inline_id = $inline->getID();
	$revision_id = $revision->getID();
	$href = "/D{$revision_id}?id={$diff_id}#inline-{$inline_id}";

	$inline
	->makeEphemeral(true)
	->setChangesetID($target_id)
	->setIsGhost(
	array(
	'new' => $is_new,
	'reason' => $reason,
	'href' => $href,
	'originalID' => $changeset->getID(),
	));

	$results[] = $inline;
	}
	}

	// Filter out the inlines we ported forward which won't be visible because
	// they appear on the wrong side of a file.
	$keep_map = array();
	foreach ($old as $changeset) {
	$keep_map[$changeset->getID()][0] = true;
	}
	foreach ($new as $changeset) {
	$keep_map[$changeset->getID()][1] = true;
	}

	foreach ($results as $key => $inline) {
	$is_new = (int)$inline->getIsNewFile();
	$changeset_id = $inline->getChangesetID();
	if (!isset($keep_map[$changeset_id][$is_new])) {
	unset($results[$key]);
	continue;
	}
	}

	// Adjust inline line numbers to account for content changes across
	// updates and rebases.
	$plan = array();
	$need = array();
	foreach ($results as $inline) {
	$ghost = $inline->getIsGhost();
	if (!$ghost) {
	// If this isn't a "ghost" inline, ignore it.
	continue;
	}

	$src_id = $ghost['originalID'];
	$dst_id = $inline->getChangesetID();

	$xforms = array();

	// If the comment is on the right, transform it through the inverse map
	// back to the left.
	if ($inline->getIsNewFile()) {
	$xforms[] = array($src_id, $src_id, true);
	}

	// Transform it across rebases.
	$xforms[] = array($src_id, $dst_id, false);

	// If the comment is on the right, transform it back onto the right.
	if ($inline->getIsNewFile()) {
	$xforms[] = array($dst_id, $dst_id, false);
	}

	$key = array();
	foreach ($xforms as $xform) {
	list($u, $v, $inverse) = $xform;

	$short = $u.'/'.$v;
	$need[$short] = array($u, $v);

	$part = $u.($inverse ? '<' : '>').$v;
	$key[] = $part;
	}
	$key = implode(',', $key);

	if (empty($plan[$key])) {
	$plan[$key] = array(
	'xforms' => $xforms,
	'inlines' => array(),
	);
	}

	$plan[$key]['inlines'][] = $inline;
	}

	if ($need) {
	$maps = DifferentialLineAdjustmentMap::loadMaps($need);
	} else {
	$maps = array();
	}

	foreach ($plan as $step) {
	$xforms = $step['xforms'];

	$chain = null;
	foreach ($xforms as $xform) {
	list($u, $v, $inverse) = $xform;
	$map = idx(idx($maps, $u, array()), $v);
	if (!$map) {
	continue 2;
	}

	if ($inverse) {
	$map = DifferentialLineAdjustmentMap::newInverseMap($map);
	} else {
	$map = clone $map;
	}

	if ($chain) {
	$chain->addMapToChain($map);
	} else {
	$chain = $map;
	}
	}

	foreach ($step['inlines'] as $inline) {
	$head_line = $inline->getLineNumber();
	$tail_line = ($head_line + $inline->getLineLength());

	$head_info = $chain->mapLine($head_line, false);
	$tail_info = $chain->mapLine($tail_line, true);

	list($head_deleted, $head_offset, $head_line) = $head_info;
	list($tail_deleted, $tail_offset, $tail_line) = $tail_info;

	if ($head_offset !== false) {
	$inline->setLineNumber($head_line + 1 + $head_offset);
	} else {
	$inline->setLineNumber($head_line);
	$inline->setLineLength($tail_line - $head_line);
	}
	}
	}

	return $results;
	}

	}
	diff --git a/src/applications/diffusion/controller/DiffusionCommitController.php b/src/applications/diffusion/controller/DiffusionCommitController.php
	index 419be17898..6cdca19953 100644
	--- a/src/applications/diffusion/controller/DiffusionCommitController.php
	+++ b/src/applications/diffusion/controller/DiffusionCommitController.php
	@@ -1,1291 +1,1292 @@
	<?php

	final class DiffusionCommitController extends DiffusionController {

	const CHANGES_LIMIT = 100;

	private $auditAuthorityPHIDs;
	private $highlightedAudits;

	private $commitParents;
	private $commitRefs;
	private $commitMerges;
	private $commitErrors;
	private $commitExists;

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$response = $this->loadDiffusionContext();
	if ($response) {
	return $response;
	}

	$drequest = $this->getDiffusionRequest();
	$viewer = $request->getUser();

	if ($request->getStr('diff')) {
	return $this->buildRawDiffResponse($drequest);
	}

	$repository = $drequest->getRepository();

	$commit = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepository($repository)
	->withIdentifiers(array($drequest->getCommit()))
	->needCommitData(true)
	->needAuditRequests(true)
	->executeOne();

	$crumbs = $this->buildCrumbs(array(
	'commit' => true,
	));
	$crumbs->setBorder(true);

	if (!$commit) {
	if (!$this->getCommitExists()) {
	return new Aphront404Response();
	}

	$error = id(new PHUIInfoView())
	->setTitle(pht('Commit Still Parsing'))
	->appendChild(
	pht(
	'Failed to load the commit because the commit has not been '.
	'parsed yet.'));

	$title = pht('Commit Still Parsing');

	return $this->newPage()
	->setTitle($title)
	->setCrumbs($crumbs)
	->appendChild($error);

	}

	$audit_requests = $commit->getAudits();
	$this->auditAuthorityPHIDs =
	PhabricatorAuditCommentEditor::loadAuditPHIDsForUser($viewer);

	$commit_data = $commit->getCommitData();
	$is_foreign = $commit_data->getCommitDetail('foreign-svn-stub');
	$error_panel = null;
	if ($is_foreign) {
	$subpath = $commit_data->getCommitDetail('svn-subpath');

	$error_panel = new PHUIInfoView();
	$error_panel->setTitle(pht('Commit Not Tracked'));
	$error_panel->setSeverity(PHUIInfoView::SEVERITY_WARNING);
	$error_panel->appendChild(
	pht(
	"This Diffusion repository is configured to track only one ".
	"subdirectory of the entire Subversion repository, and this commit ".
	"didn't affect the tracked subdirectory ('%s'), so no ".
	"information is available.",
	$subpath));
	} else {
	$engine = PhabricatorMarkupEngine::newDifferentialMarkupEngine();
	$engine->setConfig('viewer', $viewer);

	$commit_tag = $this->renderCommitHashTag($drequest);
	$header = id(new PHUIHeaderView())
	->setHeader(nonempty($commit->getSummary(), pht('Commit Detail')))
	->setHeaderIcon('fa-code-fork')
	->addTag($commit_tag);

	if ($commit->getAuditStatus()) {
	$icon = PhabricatorAuditCommitStatusConstants::getStatusIcon(
	$commit->getAuditStatus());
	$color = PhabricatorAuditCommitStatusConstants::getStatusColor(
	$commit->getAuditStatus());
	$status = PhabricatorAuditCommitStatusConstants::getStatusName(
	$commit->getAuditStatus());

	$header->setStatus($icon, $color, $status);
	}

	$curtain = $this->buildCurtain($commit, $repository);
	$subheader = $this->buildSubheaderView($commit, $commit_data);
	$details = $this->buildPropertyListView(
	$commit,
	$commit_data,
	$audit_requests);

	$message = $commit_data->getCommitMessage();

	$revision = $commit->getCommitIdentifier();
	$message = $this->linkBugtraq($message);
	$message = $engine->markupText($message);

	$detail_list = new PHUIPropertyListView();
	$detail_list->addTextContent(
	phutil_tag(
	'div',
	array(
	'class' => 'diffusion-commit-message phabricator-remarkup',
	),
	$message));

	if ($this->getCommitErrors()) {
	$error_panel = id(new PHUIInfoView())
	->appendChild($this->getCommitErrors())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING);
	}
	}

	$timeline = $this->buildComments($commit);
	$hard_limit = 1000;

	if ($commit->isImported()) {
	$change_query = DiffusionPathChangeQuery::newFromDiffusionRequest(
	$drequest);
	$change_query->setLimit($hard_limit + 1);
	$changes = $change_query->loadChanges();
	} else {
	$changes = array();
	}

	$was_limited = (count($changes) > $hard_limit);
	if ($was_limited) {
	$changes = array_slice($changes, 0, $hard_limit);
	}

	$merge_table = $this->buildMergesTable($commit);

	$highlighted_audits = $commit->getAuthorityAudits(
	$viewer,
	$this->auditAuthorityPHIDs);

	$count = count($changes);

	$bad_commit = null;
	if ($count == 0) {
	$bad_commit = queryfx_one(
	id(new PhabricatorRepository())->establishConnection('r'),
	'SELECT * FROM %T WHERE fullCommitName = %s',
	PhabricatorRepository::TABLE_BADCOMMIT,
	$commit->getMonogram());
	}

	$show_changesets = false;
	$info_panel = null;
	$change_list = null;
	$change_table = null;
	if ($bad_commit) {
	$info_panel = $this->renderStatusMessage(
	pht('Bad Commit'),
	$bad_commit['description']);
	} else if ($is_foreign) {
	// Don't render anything else.
	} else if (!$commit->isImported()) {
	$info_panel = $this->renderStatusMessage(
	pht('Still Importing...'),
	pht(
	'This commit is still importing. Changes will be visible once '.
	'the import finishes.'));
	} else if (!count($changes)) {
	$info_panel = $this->renderStatusMessage(
	pht('Empty Commit'),
	pht(
	'This commit is empty and does not affect any paths.'));
	} else if ($was_limited) {
	$info_panel = $this->renderStatusMessage(
	pht('Enormous Commit'),
	pht(
	'This commit is enormous, and affects more than %d files. '.
	'Changes are not shown.',
	$hard_limit));
	} else if (!$this->getCommitExists()) {
	$info_panel = $this->renderStatusMessage(
	pht('Commit No Longer Exists'),
	pht('This commit no longer exists in the repository.'));
	} else {
	$show_changesets = true;

	// The user has clicked "Show All Changes", and we should show all the
	// changes inline even if there are more than the soft limit.
	$show_all_details = $request->getBool('show_all');

	$change_header = id(new PHUIHeaderView())
	->setHeader(pht('Changes (%s)', new PhutilNumber($count)));

	$warning_view = null;
	if ($count > self::CHANGES_LIMIT && !$show_all_details) {
	$button = id(new PHUIButtonView())
	->setText(pht('Show All Changes'))
	->setHref('?show_all=true')
	->setTag('a')
	->setIcon('fa-files-o');

	$warning_view = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setTitle(pht('Very Large Commit'))
	->appendChild(
	pht('This commit is very large. Load each file individually.'));

	$change_header->addActionLink($button);
	}

	$changesets = DiffusionPathChange::convertToDifferentialChangesets(
	$viewer,
	$changes);

	// TODO: This table and panel shouldn't really be separate, but we need
	// to clean up the "Load All Files" interaction first.
	$change_table = $this->buildTableOfContents(
	$changesets,
	$change_header,
	$warning_view);

	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$vcs_supports_directory_changes = true;
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$vcs_supports_directory_changes = false;
	break;
	default:
	throw new Exception(pht('Unknown VCS.'));
	}

	$references = array();
	foreach ($changesets as $key => $changeset) {
	$file_type = $changeset->getFileType();
	if ($file_type == DifferentialChangeType::FILE_DIRECTORY) {
	if (!$vcs_supports_directory_changes) {
	unset($changesets[$key]);
	continue;
	}
	}

	$references[$key] = $drequest->generateURI(
	array(
	'action' => 'rendering-ref',
	'path' => $changeset->getFilename(),
	));
	}

	// TODO: Some parts of the views still rely on properties of the
	// DifferentialChangeset. Make the objects ephemeral to make sure we don't
	// accidentally save them, and then set their ID to the appropriate ID for
	// this application (the path IDs).
	$path_ids = array_flip(mpull($changes, 'getPath'));
	foreach ($changesets as $changeset) {
	$changeset->makeEphemeral();
	$changeset->setID($path_ids[$changeset->getFilename()]);
	}

	if ($count <= self::CHANGES_LIMIT \|\| $show_all_details) {
	$visible_changesets = $changesets;
	} else {
	$visible_changesets = array();
	$inlines = PhabricatorAuditInlineComment::loadDraftAndPublishedComments(
	$viewer,
	$commit->getPHID());
	$path_ids = mpull($inlines, null, 'getPathID');
	foreach ($changesets as $key => $changeset) {
	if (array_key_exists($changeset->getID(), $path_ids)) {
	$visible_changesets[$key] = $changeset;
	}
	}
	}

	$change_list_title = $commit->getDisplayName();

	$change_list = new DifferentialChangesetListView();
	$change_list->setTitle($change_list_title);
	$change_list->setChangesets($changesets);
	$change_list->setVisibleChangesets($visible_changesets);
	$change_list->setRenderingReferences($references);
	$change_list->setRenderURI($repository->getPathURI('diff/'));
	$change_list->setRepository($repository);
	$change_list->setUser($viewer);
	$change_list->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);

	// TODO: Try to setBranch() to something reasonable here?

	$change_list->setStandaloneURI(
	$repository->getPathURI('diff/'));

	$change_list->setRawFileURIs(
	// TODO: Implement this, somewhat tricky if there's an octopus merge
	// or whatever?
	null,
	$repository->getPathURI('diff/?view=r'));

	$change_list->setInlineCommentControllerURI(
	'/diffusion/inline/edit/'.phutil_escape_uri($commit->getPHID()).'/');

	}

	$add_comment = $this->renderAddCommentPanel($commit, $audit_requests);

	- $prefs = $viewer->loadPreferences();
	- $pref_filetree = PhabricatorUserPreferences::PREFERENCE_DIFF_FILETREE;
	+ $filetree_on = $viewer->compareUserSetting(
	+ PhabricatorShowFiletreeSetting::SETTINGKEY,
	+ PhabricatorShowFiletreeSetting::VALUE_ENABLE_FILETREE);
	+
	$pref_collapse = PhabricatorUserPreferences::PREFERENCE_NAV_COLLAPSED;
	- $show_filetree = $prefs->getPreference($pref_filetree);
	- $collapsed = $prefs->getPreference($pref_collapse);
	+ $collapsed = $viewer->getUserSetting($pref_collapse);

	$nav = null;
	- if ($show_changesets && $show_filetree) {
	+ if ($show_changesets && $filetree_on) {
	$nav = id(new DifferentialChangesetFileTreeSideNavBuilder())
	->setTitle($commit->getDisplayName())
	->setBaseURI(new PhutilURI($commit->getURI()))
	->build($changesets)
	->setCrumbs($crumbs)
	->setCollapsed((bool)$collapsed);
	}

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setSubheader($subheader)
	->setMainColumn(array(
	$error_panel,
	$timeline,
	$merge_table,
	$info_panel,
	))
	->setFooter(array(
	$change_table,
	$change_list,
	$add_comment,
	))
	->addPropertySection(pht('Description'), $detail_list)
	->addPropertySection(pht('Details'), $details)
	->setCurtain($curtain);

	$page = $this->newPage()
	->setTitle($commit->getDisplayName())
	->setCrumbs($crumbs)
	->setPageObjectPHIDS(array($commit->getPHID()))
	->appendChild(
	array(
	$view,
	));

	if ($nav) {
	$page->setNavigation($nav);
	}

	return $page;

	}

	private function buildPropertyListView(
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data,
	array $audit_requests) {

	$viewer = $this->getViewer();
	$commit_phid = $commit->getPHID();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$view = id(new PHUIPropertyListView())
	->setUser($this->getRequest()->getUser());

	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(array($commit_phid))
	->withEdgeTypes(array(
	DiffusionCommitHasTaskEdgeType::EDGECONST,
	DiffusionCommitHasRevisionEdgeType::EDGECONST,
	DiffusionCommitRevertsCommitEdgeType::EDGECONST,
	DiffusionCommitRevertedByCommitEdgeType::EDGECONST,
	));

	$edges = $edge_query->execute();

	$task_phids = array_keys(
	$edges[$commit_phid][DiffusionCommitHasTaskEdgeType::EDGECONST]);
	$revision_phid = key(
	$edges[$commit_phid][DiffusionCommitHasRevisionEdgeType::EDGECONST]);

	$reverts_phids = array_keys(
	$edges[$commit_phid][DiffusionCommitRevertsCommitEdgeType::EDGECONST]);
	$reverted_by_phids = array_keys(
	$edges[$commit_phid][DiffusionCommitRevertedByCommitEdgeType::EDGECONST]);

	$phids = $edge_query->getDestinationPHIDs(array($commit_phid));

	if ($data->getCommitDetail('authorPHID')) {
	$phids[] = $data->getCommitDetail('authorPHID');
	}
	if ($data->getCommitDetail('reviewerPHID')) {
	$phids[] = $data->getCommitDetail('reviewerPHID');
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[] = $data->getCommitDetail('committerPHID');
	}

	// NOTE: We should never normally have more than a single push log, but
	// it can occur naturally if a commit is pushed, then the branch it was
	// on is deleted, then the commit is pushed again (or through other similar
	// chains of events). This should be rare, but does not indicate a bug
	// or data issue.

	// NOTE: We never query push logs in SVN because the commiter is always
	// the pusher and the commit time is always the push time; the push log
	// is redundant and we save a query by skipping it.

	$push_logs = array();
	if ($repository->isHosted() && !$repository->isSVN()) {
	$push_logs = id(new PhabricatorRepositoryPushLogQuery())
	->setViewer($viewer)
	->withRepositoryPHIDs(array($repository->getPHID()))
	->withNewRefs(array($commit->getCommitIdentifier()))
	->withRefTypes(array(PhabricatorRepositoryPushLog::REFTYPE_COMMIT))
	->execute();
	foreach ($push_logs as $log) {
	$phids[] = $log->getPusherPHID();
	}
	}

	$handles = array();
	if ($phids) {
	$handles = $this->loadViewerHandles($phids);
	}

	$props = array();

	if ($audit_requests) {
	$user_requests = array();
	$other_requests = array();

	foreach ($audit_requests as $audit_request) {
	if (!$audit_request->isInteresting()) {
	continue;
	}

	if ($audit_request->isUser()) {
	$user_requests[] = $audit_request;
	} else {
	$other_requests[] = $audit_request;
	}
	}

	if ($user_requests) {
	$view->addProperty(
	pht('Auditors'),
	$this->renderAuditStatusView($user_requests));
	}

	if ($other_requests) {
	$view->addProperty(
	pht('Group Auditors'),
	$this->renderAuditStatusView($other_requests));
	}
	}

	$author_phid = $data->getCommitDetail('authorPHID');
	$author_name = $data->getAuthorName();
	$author_epoch = $data->getCommitDetail('authorEpoch');

	$committed_info = id(new PHUIStatusItemView())
	->setNote(phabricator_datetime($commit->getEpoch(), $viewer));

	$committer_phid = $data->getCommitDetail('committerPHID');
	$committer_name = $data->getCommitDetail('committer');
	if ($committer_phid) {
	$committed_info->setTarget($handles[$committer_phid]->renderLink());
	} else if (strlen($committer_name)) {
	$committed_info->setTarget($committer_name);
	} else if ($author_phid) {
	$committed_info->setTarget($handles[$author_phid]->renderLink());
	} else if (strlen($author_name)) {
	$committed_info->setTarget($author_name);
	}

	$committed_list = new PHUIStatusListView();
	$committed_list->addItem($committed_info);
	$view->addProperty(
	pht('Committed'),
	$committed_list);

	if ($push_logs) {
	$pushed_list = new PHUIStatusListView();

	foreach ($push_logs as $push_log) {
	$pushed_item = id(new PHUIStatusItemView())
	->setTarget($handles[$push_log->getPusherPHID()]->renderLink())
	->setNote(phabricator_datetime($push_log->getEpoch(), $viewer));
	$pushed_list->addItem($pushed_item);
	}

	$view->addProperty(
	pht('Pushed'),
	$pushed_list);
	}

	$reviewer_phid = $data->getCommitDetail('reviewerPHID');
	if ($reviewer_phid) {
	$view->addProperty(
	pht('Reviewer'),
	$handles[$reviewer_phid]->renderLink());
	}

	if ($revision_phid) {
	$view->addProperty(
	pht('Differential Revision'),
	$handles[$revision_phid]->renderLink());
	}

	$parents = $this->getCommitParents();
	if ($parents) {
	$view->addProperty(
	pht('Parents'),
	$viewer->renderHandleList(mpull($parents, 'getPHID')));
	}

	if ($this->getCommitExists()) {
	$view->addProperty(
	pht('Branches'),
	phutil_tag(
	'span',
	array(
	'id' => 'commit-branches',
	),
	pht('Unknown')));

	$view->addProperty(
	pht('Tags'),
	phutil_tag(
	'span',
	array(
	'id' => 'commit-tags',
	),
	pht('Unknown')));

	$identifier = $commit->getCommitIdentifier();
	$root = $repository->getPathURI("commit/{$identifier}");
	Javelin::initBehavior(
	'diffusion-commit-branches',
	array(
	$root.'/branches/' => 'commit-branches',
	$root.'/tags/' => 'commit-tags',
	));
	}

	$refs = $this->getCommitRefs();
	if ($refs) {
	$ref_links = array();
	foreach ($refs as $ref_data) {
	$ref_links[] = phutil_tag(
	'a',
	array(
	'href' => $ref_data['href'],
	),
	$ref_data['ref']);
	}
	$view->addProperty(
	pht('References'),
	phutil_implode_html(', ', $ref_links));
	}

	if ($reverts_phids) {
	$view->addProperty(
	pht('Reverts'),
	$viewer->renderHandleList($reverts_phids));
	}

	if ($reverted_by_phids) {
	$view->addProperty(
	pht('Reverted By'),
	$viewer->renderHandleList($reverted_by_phids));
	}

	if ($task_phids) {
	$task_list = array();
	foreach ($task_phids as $phid) {
	$task_list[] = $handles[$phid]->renderLink();
	}
	$task_list = phutil_implode_html(phutil_tag('br'), $task_list);
	$view->addProperty(
	pht('Tasks'),
	$task_list);
	}

	return $view;
	}

	private function buildSubheaderView(
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data) {

	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	if ($repository->isSVN()) {
	return null;
	}

	$author_phid = $data->getCommitDetail('authorPHID');
	$author_name = $data->getAuthorName();
	$author_epoch = $data->getCommitDetail('authorEpoch');
	$date = null;
	if ($author_epoch !== null) {
	$date = phabricator_datetime($author_epoch, $viewer);
	}

	if ($author_phid) {
	$handles = $viewer->loadHandles(array($author_phid));
	$image_uri = $handles[$author_phid]->getImageURI();
	$image_href = $handles[$author_phid]->getURI();
	$author = $handles[$author_phid]->renderLink();
	} else if (strlen($author_name)) {
	$author = $author_name;
	$image_uri = null;
	$image_href = null;
	} else {
	return null;
	}

	$author = phutil_tag('strong', array(), $author);
	if ($date) {
	$content = pht('Authored by %s on %s.', $author, $date);
	} else {
	$content = pht('Authored by %s.', $author);
	}

	return id(new PHUIHeadThingView())
	->setImage($image_uri)
	->setImageHref($image_href)
	->setContent($content);

	}


	private function buildComments(PhabricatorRepositoryCommit $commit) {
	$timeline = $this->buildTransactionTimeline(
	$commit,
	new PhabricatorAuditTransactionQuery());
	$commit->willRenderTimeline($timeline, $this->getRequest());
	return $timeline;
	}

	private function renderAddCommentPanel(
	PhabricatorRepositoryCommit $commit,
	array $audit_requests) {
	assert_instances_of($audit_requests, 'PhabricatorRepositoryAuditRequest');

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

	if (!$viewer->isLoggedIn()) {
	return id(new PhabricatorApplicationTransactionCommentView())
	->setUser($viewer)
	->setRequestURI($request->getRequestURI());
	}

	$is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');

	$pane_id = celerity_generate_unique_node_id();
	Javelin::initBehavior(
	'differential-keyboard-navigation',
	array(
	'haunt' => $pane_id,
	));

	$draft = id(new PhabricatorDraft())->loadOneWhere(
	'authorPHID = %s AND draftKey = %s',
	$viewer->getPHID(),
	'diffusion-audit-'.$commit->getID());
	if ($draft) {
	$draft = $draft->getDraft();
	} else {
	$draft = null;
	}

	$actions = $this->getAuditActions($commit, $audit_requests);

	$mailable_source = new PhabricatorMetaMTAMailableDatasource();
	$auditor_source = new DiffusionAuditorDatasource();

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->setAction('/audit/addcomment/')
	->addHiddenInput('commit', $commit->getPHID())
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Action'))
	->setName('action')
	->setID('audit-action')
	->setOptions($actions))
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setLabel(pht('Add Auditors'))
	->setName('auditors')
	->setControlID('add-auditors')
	->setControlStyle('display: none')
	->setID('add-auditors-tokenizer')
	->setDisableBehavior(true)
	->setDatasource($auditor_source))
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setLabel(pht('Add CCs'))
	->setName('ccs')
	->setControlID('add-ccs')
	->setControlStyle('display: none')
	->setID('add-ccs-tokenizer')
	->setDisableBehavior(true)
	->setDatasource($mailable_source))
	->appendChild(
	id(new PhabricatorRemarkupControl())
	->setLabel(pht('Comments'))
	->setName('content')
	->setValue($draft)
	->setID('audit-content')
	->setUser($viewer))
	->appendChild(
	id(new AphrontFormSubmitControl())
	->setValue(pht('Submit')));

	$header = new PHUIHeaderView();
	$header->setHeader(
	$is_serious ? pht('Audit Commit') : pht('Creative Accounting'));

	Javelin::initBehavior(
	'differential-add-reviewers-and-ccs',
	array(
	'dynamic' => array(
	'add-auditors-tokenizer' => array(
	'actions' => array('add_auditors' => 1),
	'src' => $auditor_source->getDatasourceURI(),
	'row' => 'add-auditors',
	'placeholder' => $auditor_source->getPlaceholderText(),
	),
	'add-ccs-tokenizer' => array(
	'actions' => array('add_ccs' => 1),
	'src' => $mailable_source->getDatasourceURI(),
	'row' => 'add-ccs',
	'placeholder' => $mailable_source->getPlaceholderText(),
	),
	),
	'select' => 'audit-action',
	));

	Javelin::initBehavior('differential-feedback-preview', array(
	'uri' => '/audit/preview/'.$commit->getID().'/',
	'preview' => 'audit-preview',
	'content' => 'audit-content',
	'action' => 'audit-action',
	'previewTokenizers' => array(
	'auditors' => 'add-auditors-tokenizer',
	'ccs' => 'add-ccs-tokenizer',
	),
	'inline' => 'inline-comment-preview',
	'inlineuri' => '/diffusion/inline/preview/'.$commit->getPHID().'/',
	));

	$loading = phutil_tag_div(
	'aphront-panel-preview-loading-text',
	pht('Loading preview...'));

	$preview_panel = phutil_tag_div(
	'aphront-panel-preview aphront-panel-flush',
	array(
	phutil_tag('div', array('id' => 'audit-preview'), $loading),
	phutil_tag('div', array('id' => 'inline-comment-preview')),
	));

	// TODO: This is pretty awkward, unify the CSS between Diffusion and
	// Differential better.
	require_celerity_resource('differential-core-view-css');

	$anchor = id(new PhabricatorAnchorView())
	->setAnchorName('comment')
	->setNavigationMarker(true)
	->render();

	$comment_box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->appendChild($form);

	return phutil_tag(
	'div',
	array(
	'id' => $pane_id,
	),
	phutil_tag_div(
	'differential-add-comment-panel',
	array($anchor, $comment_box, $preview_panel)));
	}

	/**
	* Return a map of available audit actions for rendering into a <select />.
	* This shows the user valid actions, and does not show nonsense/invalid
	* actions (like closing an already-closed commit, or resigning from a commit
	* you have no association with).
	*/
	private function getAuditActions(
	PhabricatorRepositoryCommit $commit,
	array $audit_requests) {
	assert_instances_of($audit_requests, 'PhabricatorRepositoryAuditRequest');
	$viewer = $this->getViewer();

	$user_is_author = ($commit->getAuthorPHID() == $viewer->getPHID());

	$user_request = null;
	foreach ($audit_requests as $audit_request) {
	if ($audit_request->getAuditorPHID() == $viewer->getPHID()) {
	$user_request = $audit_request;
	break;
	}
	}

	$actions = array();
	$actions[PhabricatorAuditActionConstants::COMMENT] = true;

	// We allow you to accept your own commits. A use case here is that you
	// notice an issue with your own commit and "Raise Concern" as an indicator
	// to other auditors that you're on top of the issue, then later resolve it
	// and "Accept". You can not accept on behalf of projects or packages,
	// however.
	$actions[PhabricatorAuditActionConstants::ACCEPT] = true;
	$actions[PhabricatorAuditActionConstants::CONCERN] = true;

	// To resign, a user must have authority on some request and not be the
	// commit's author.
	if (!$user_is_author) {
	$may_resign = false;

	$authority_map = array_fill_keys($this->auditAuthorityPHIDs, true);
	foreach ($audit_requests as $request) {
	if (empty($authority_map[$request->getAuditorPHID()])) {
	continue;
	}
	$may_resign = true;
	break;
	}

	// If the user has already resigned, don't show "Resign...".
	$status_resigned = PhabricatorAuditStatusConstants::RESIGNED;
	if ($user_request) {
	if ($user_request->getAuditStatus() == $status_resigned) {
	$may_resign = false;
	}
	}

	if ($may_resign) {
	$actions[PhabricatorAuditActionConstants::RESIGN] = true;
	}
	}

	$status_concern = PhabricatorAuditCommitStatusConstants::CONCERN_RAISED;
	$concern_raised = ($commit->getAuditStatus() == $status_concern);
	$can_close_option = PhabricatorEnv::getEnvConfig(
	'audit.can-author-close-audit');
	if ($can_close_option && $user_is_author && $concern_raised) {
	$actions[PhabricatorAuditActionConstants::CLOSE] = true;
	}

	$actions[PhabricatorAuditActionConstants::ADD_AUDITORS] = true;
	$actions[PhabricatorAuditActionConstants::ADD_CCS] = true;

	foreach ($actions as $constant => $ignored) {
	$actions[$constant] =
	PhabricatorAuditActionConstants::getActionName($constant);
	}

	return $actions;
	}

	private function buildMergesTable(PhabricatorRepositoryCommit $commit) {
	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$merges = $this->getCommitMerges();
	if (!$merges) {
	return null;
	}

	$limit = $this->getMergeDisplayLimit();

	$caption = null;
	if (count($merges) > $limit) {
	$merges = array_slice($merges, 0, $limit);
	$caption = new PHUIInfoView();
	$caption->setSeverity(PHUIInfoView::SEVERITY_NOTICE);
	$caption->appendChild(
	pht(
	'This commit merges a very large number of changes. '.
	'Only the first %s are shown.',
	new PhutilNumber($limit)));
	}

	$history_table = id(new DiffusionHistoryTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setHistory($merges);

	$history_table->loadRevisions();

	$panel = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Merged Changes'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setTable($history_table);
	if ($caption) {
	$panel->setInfoView($caption);
	}

	return $panel;
	}

	private function buildCurtain(
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepository $repository) {

	$request = $this->getRequest();
	$viewer = $this->getViewer();
	$curtain = $this->newCurtainView($commit);

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

	$identifier = $commit->getCommitIdentifier();
	$uri = $repository->getPathURI("commit/{$identifier}/edit/");

	$action = id(new PhabricatorActionView())
	->setName(pht('Edit Commit'))
	->setHref($uri)
	->setIcon('fa-pencil')
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit);
	$curtain->addAction($action);

	require_celerity_resource('phabricator-object-selector-css');
	require_celerity_resource('javelin-behavior-phabricator-object-selector');

	$maniphest = 'PhabricatorManiphestApplication';
	if (PhabricatorApplication::isClassInstalled($maniphest)) {
	$action = id(new PhabricatorActionView())
	->setName(pht('Edit Maniphest Tasks'))
	->setIcon('fa-anchor')
	->setHref('/search/attach/'.$commit->getPHID().'/TASK/edge/')
	->setWorkflow(true)
	->setDisabled(!$can_edit);
	$curtain->addAction($action);
	}

	$action = id(new PhabricatorActionView())
	->setName(pht('Download Raw Diff'))
	->setHref($request->getRequestURI()->alter('diff', true))
	->setIcon('fa-download');
	$curtain->addAction($action);

	return $curtain;
	}

	private function buildRawDiffResponse(DiffusionRequest $drequest) {
	$raw_diff = $this->callConduitWithDiffusionRequest(
	'diffusion.rawdiffquery',
	array(
	'commit' => $drequest->getCommit(),
	'path' => $drequest->getPath(),
	));

	$file = PhabricatorFile::buildFromFileDataOrHash(
	$raw_diff,
	array(
	'name' => $drequest->getCommit().'.diff',
	'ttl' => (60 * 60 * 24),
	'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
	));

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$file->attachToObject($drequest->getRepository()->getPHID());
	unset($unguarded);

	return $file->getRedirectResponse();
	}

	private function renderAuditStatusView(array $audit_requests) {
	assert_instances_of($audit_requests, 'PhabricatorRepositoryAuditRequest');
	$viewer = $this->getViewer();

	$authority_map = array_fill_keys($this->auditAuthorityPHIDs, true);

	$view = new PHUIStatusListView();
	foreach ($audit_requests as $request) {
	$code = $request->getAuditStatus();
	$item = new PHUIStatusItemView();
	$item->setIcon(
	PhabricatorAuditStatusConstants::getStatusIcon($code),
	PhabricatorAuditStatusConstants::getStatusColor($code),
	PhabricatorAuditStatusConstants::getStatusName($code));

	$note = array();
	foreach ($request->getAuditReasons() as $reason) {
	$note[] = phutil_tag('div', array(), $reason);
	}
	$item->setNote($note);

	$auditor_phid = $request->getAuditorPHID();
	$target = $viewer->renderHandle($auditor_phid);
	$item->setTarget($target);

	if (isset($authority_map[$auditor_phid])) {
	$item->setHighlighted(true);
	}

	$view->addItem($item);
	}

	return $view;
	}

	private function linkBugtraq($corpus) {
	$url = PhabricatorEnv::getEnvConfig('bugtraq.url');
	if (!strlen($url)) {
	return $corpus;
	}

	$regexes = PhabricatorEnv::getEnvConfig('bugtraq.logregex');
	if (!$regexes) {
	return $corpus;
	}

	$parser = id(new PhutilBugtraqParser())
	->setBugtraqPattern("[[ {$url} \| %BUGID% ]]")
	->setBugtraqCaptureExpression(array_shift($regexes));

	$select = array_shift($regexes);
	if ($select) {
	$parser->setBugtraqSelectExpression($select);
	}

	return $parser->processCorpus($corpus);
	}

	private function buildTableOfContents(
	array $changesets,
	$header,
	$info_view) {

	$drequest = $this->getDiffusionRequest();
	$viewer = $this->getViewer();

	$toc_view = id(new PHUIDiffTableOfContentsListView())
	->setUser($viewer)
	->setHeader($header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);

	if ($info_view) {
	$toc_view->setInfoView($info_view);
	}

	// TODO: This is hacky, we just want access to the linkX() methods on
	// DiffusionView.
	$diffusion_view = id(new DiffusionEmptyResultView())
	->setDiffusionRequest($drequest);

	$have_owners = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorOwnersApplication',
	$viewer);

	if (!$changesets) {
	$have_owners = false;
	}

	if ($have_owners) {
	if ($viewer->getPHID()) {
	$packages = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
	->withAuthorityPHIDs(array($viewer->getPHID()))
	->execute();
	$toc_view->setAuthorityPackages($packages);
	}

	$repository = $drequest->getRepository();
	$repository_phid = $repository->getPHID();

	$control_query = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
	->withControl($repository_phid, mpull($changesets, 'getFilename'));
	$control_query->execute();
	}

	foreach ($changesets as $changeset_id => $changeset) {
	$path = $changeset->getFilename();
	$anchor = substr(md5($path), 0, 8);

	$history_link = $diffusion_view->linkHistory($path);
	$browse_link = $diffusion_view->linkBrowse(
	$path,
	array(
	'type' => $changeset->getFileType(),
	));

	$item = id(new PHUIDiffTableOfContentsItemView())
	->setChangeset($changeset)
	->setAnchor($anchor)
	->setContext(
	array(
	$history_link,
	' ',
	$browse_link,
	));

	if ($have_owners) {
	$packages = $control_query->getControllingPackagesForPath(
	$repository_phid,
	$changeset->getFilename());
	$item->setPackages($packages);
	}

	$toc_view->addItem($item);
	}

	return $toc_view;
	}

	private function loadCommitState() {
	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();
	$commit = $drequest->getCommit();

	// TODO: We could use futures here and resolve these calls in parallel.

	$exceptions = array();

	try {
	$parent_refs = $this->callConduitWithDiffusionRequest(
	'diffusion.commitparentsquery',
	array(
	'commit' => $commit,
	));

	if ($parent_refs) {
	$parents = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepository($repository)
	->withIdentifiers($parent_refs)
	->execute();
	} else {
	$parents = array();
	}

	$this->commitParents = $parents;
	} catch (Exception $ex) {
	$this->commitParents = false;
	$exceptions[] = $ex;
	}

	$merge_limit = $this->getMergeDisplayLimit();

	try {
	if ($repository->isSVN()) {
	$this->commitMerges = array();
	} else {
	$merges = $this->callConduitWithDiffusionRequest(
	'diffusion.mergedcommitsquery',
	array(
	'commit' => $commit,
	'limit' => $merge_limit + 1,
	));
	$this->commitMerges = DiffusionPathChange::newFromConduit($merges);
	}
	} catch (Exception $ex) {
	$this->commitMerges = false;
	$exceptions[] = $ex;
	}


	try {
	if ($repository->isGit()) {
	$refs = $this->callConduitWithDiffusionRequest(
	'diffusion.refsquery',
	array(
	'commit' => $commit,
	));
	} else {
	$refs = array();
	}

	$this->commitRefs = $refs;
	} catch (Exception $ex) {
	$this->commitRefs = false;
	$exceptions[] = $ex;
	}

	if ($exceptions) {
	$exists = $this->callConduitWithDiffusionRequest(
	'diffusion.existsquery',
	array(
	'commit' => $commit,
	));

	if ($exists) {
	$this->commitExists = true;
	foreach ($exceptions as $exception) {
	$this->commitErrors[] = $exception->getMessage();
	}
	} else {
	$this->commitExists = false;
	$this->commitErrors[] = pht(
	'This commit no longer exists in the repository. It may have '.
	'been part of a branch which was deleted.');
	}
	} else {
	$this->commitExists = true;
	$this->commitErrors = array();
	}
	}

	private function getMergeDisplayLimit() {
	return 50;
	}

	private function getCommitExists() {
	if ($this->commitExists === null) {
	$this->loadCommitState();
	}

	return $this->commitExists;
	}

	private function getCommitParents() {
	if ($this->commitParents === null) {
	$this->loadCommitState();
	}

	return $this->commitParents;
	}

	private function getCommitRefs() {
	if ($this->commitRefs === null) {
	$this->loadCommitState();
	}

	return $this->commitRefs;
	}

	private function getCommitMerges() {
	if ($this->commitMerges === null) {
	$this->loadCommitState();
	}

	return $this->commitMerges;
	}

	private function getCommitErrors() {
	if ($this->commitErrors === null) {
	$this->loadCommitState();
	}

	return $this->commitErrors;
	}


	}
	diff --git a/src/applications/people/storage/PhabricatorUser.php b/src/applications/people/storage/PhabricatorUser.php
	index fd2f69ccb6..0c19b3acdd 100644
	--- a/src/applications/people/storage/PhabricatorUser.php
	+++ b/src/applications/people/storage/PhabricatorUser.php
	@@ -1,1537 +1,1542 @@
	<?php

	/**
	* @task availability Availability
	* @task image-cache Profile Image Cache
	* @task factors Multi-Factor Authentication
	* @task handles Managing Handles
	* @task cache User Cache
	*/
	final class PhabricatorUser
	extends PhabricatorUserDAO
	implements
	PhutilPerson,
	PhabricatorPolicyInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorDestructibleInterface,
	PhabricatorSSHPublicKeyInterface,
	PhabricatorFlaggableInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorFulltextInterface,
	PhabricatorConduitResultInterface {

	const SESSION_TABLE = 'phabricator_session';
	const NAMETOKEN_TABLE = 'user_nametoken';
	const MAXIMUM_USERNAME_LENGTH = 64;

	protected $userName;
	protected $realName;
	protected $sex;
	protected $translation;
	protected $passwordSalt;
	protected $passwordHash;
	protected $profileImagePHID;
	protected $profileImageCache;
	protected $availabilityCache;
	protected $availabilityCacheTTL;
	protected $timezoneIdentifier = '';

	protected $consoleEnabled = 0;
	protected $consoleVisible = 0;
	protected $consoleTab = '';

	protected $conduitCertificate;

	protected $isSystemAgent = 0;
	protected $isMailingList = 0;
	protected $isAdmin = 0;
	protected $isDisabled = 0;
	protected $isEmailVerified = 0;
	protected $isApproved = 0;
	protected $isEnrolledInMultiFactor = 0;

	protected $accountSecret;

	private $profileImage = self::ATTACHABLE;
	private $profile = null;
	private $availability = self::ATTACHABLE;
	private $preferences = null;
	private $omnipotent = false;
	private $customFields = self::ATTACHABLE;
	private $badgePHIDs = self::ATTACHABLE;

	private $alternateCSRFString = self::ATTACHABLE;
	private $session = self::ATTACHABLE;
	private $rawCacheData = array();
	private $usableCacheData = array();

	private $authorities = array();
	private $handlePool;
	private $csrfSalt;

	protected function readField($field) {
	switch ($field) {
	case 'timezoneIdentifier':
	// If the user hasn't set one, guess the server's time.
	return nonempty(
	$this->timezoneIdentifier,
	date_default_timezone_get());
	// Make sure these return booleans.
	case 'isAdmin':
	return (bool)$this->isAdmin;
	case 'isDisabled':
	return (bool)$this->isDisabled;
	case 'isSystemAgent':
	return (bool)$this->isSystemAgent;
	case 'isMailingList':
	return (bool)$this->isMailingList;
	case 'isEmailVerified':
	return (bool)$this->isEmailVerified;
	case 'isApproved':
	return (bool)$this->isApproved;
	default:
	return parent::readField($field);
	}
	}


	/**
	* Is this a live account which has passed required approvals? Returns true
	* if this is an enabled, verified (if required), approved (if required)
	* account, and false otherwise.
	*
	* @return bool True if this is a standard, usable account.
	*/
	public function isUserActivated() {
	if ($this->isOmnipotent()) {
	return true;
	}

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

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

	if (PhabricatorUserEmail::isEmailVerificationRequired()) {
	if (!$this->getIsEmailVerified()) {
	return false;
	}
	}

	return true;
	}

	public function canEstablishWebSessions() {
	if ($this->getIsMailingList()) {
	return false;
	}

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

	return true;
	}

	public function canEstablishAPISessions() {
	if ($this->getIsDisabled()) {
	return false;
	}

	// Intracluster requests are permitted even if the user is logged out:
	// in particular, public users are allowed to issue intracluster requests
	// when browsing Diffusion.
	if (PhabricatorEnv::isClusterRemoteAddress()) {
	if (!$this->isLoggedIn()) {
	return true;
	}
	}

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

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

	return true;
	}

	public function canEstablishSSHSessions() {
	if (!$this->isUserActivated()) {
	return false;
	}

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

	return true;
	}

	/**
	* Returns `true` if this is a standard user who is logged in. Returns `false`
	* for logged out, anonymous, or external users.
	*
	* @return bool `true` if the user is a standard user who is logged in with
	* a normal session.
	*/
	public function getIsStandardUser() {
	$type_user = PhabricatorPeopleUserPHIDType::TYPECONST;
	return $this->getPHID() && (phid_get_type($this->getPHID()) == $type_user);
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'userName' => 'sort64',
	'realName' => 'text128',
	'sex' => 'text4?',
	'translation' => 'text64?',
	'passwordSalt' => 'text32?',
	'passwordHash' => 'text128?',
	'profileImagePHID' => 'phid?',
	'consoleEnabled' => 'bool',
	'consoleVisible' => 'bool',
	'consoleTab' => 'text64',
	'conduitCertificate' => 'text255',
	'isSystemAgent' => 'bool',
	'isMailingList' => 'bool',
	'isDisabled' => 'bool',
	'isAdmin' => 'bool',
	'timezoneIdentifier' => 'text255',
	'isEmailVerified' => 'uint32',
	'isApproved' => 'uint32',
	'accountSecret' => 'bytes64',
	'isEnrolledInMultiFactor' => 'bool',
	'profileImageCache' => 'text255?',
	'availabilityCache' => 'text255?',
	'availabilityCacheTTL' => 'uint32?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'userName' => array(
	'columns' => array('userName'),
	'unique' => true,
	),
	'realName' => array(
	'columns' => array('realName'),
	),
	'key_approved' => array(
	'columns' => array('isApproved'),
	),
	),
	self::CONFIG_NO_MUTATE => array(
	'profileImageCache' => true,
	'availabilityCache' => true,
	'availabilityCacheTTL' => true,
	),
	) + parent::getConfiguration();
	}

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

	public function setPassword(PhutilOpaqueEnvelope $envelope) {
	if (!$this->getPHID()) {
	throw new Exception(
	pht(
	'You can not set a password for an unsaved user because their PHID '.
	'is a salt component in the password hash.'));
	}

	if (!strlen($envelope->openEnvelope())) {
	$this->setPasswordHash('');
	} else {
	$this->setPasswordSalt(md5(Filesystem::readRandomBytes(32)));
	$hash = $this->hashPassword($envelope);
	$this->setPasswordHash($hash->openEnvelope());
	}
	return $this;
	}

	// To satisfy PhutilPerson.
	public function getSex() {
	return $this->sex;
	}

	public function getMonogram() {
	return '@'.$this->getUsername();
	}

	public function isLoggedIn() {
	return !($this->getPHID() === null);
	}

	public function save() {
	if (!$this->getConduitCertificate()) {
	$this->setConduitCertificate($this->generateConduitCertificate());
	}

	if (!strlen($this->getAccountSecret())) {
	$this->setAccountSecret(Filesystem::readRandomCharacters(64));
	}

	$result = parent::save();

	if ($this->profile) {
	$this->profile->save();
	}

	$this->updateNameTokens();

	PhabricatorSearchWorker::queueDocumentForIndexing($this->getPHID());

	return $result;
	}

	public function attachSession(PhabricatorAuthSession $session) {
	$this->session = $session;
	return $this;
	}

	public function getSession() {
	return $this->assertAttached($this->session);
	}

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

	private function generateConduitCertificate() {
	return Filesystem::readRandomCharacters(255);
	}

	public function comparePassword(PhutilOpaqueEnvelope $envelope) {
	if (!strlen($envelope->openEnvelope())) {
	return false;
	}
	if (!strlen($this->getPasswordHash())) {
	return false;
	}

	return PhabricatorPasswordHasher::comparePassword(
	$this->getPasswordHashInput($envelope),
	new PhutilOpaqueEnvelope($this->getPasswordHash()));
	}

	private function getPasswordHashInput(PhutilOpaqueEnvelope $password) {
	$input =
	$this->getUsername().
	$password->openEnvelope().
	$this->getPHID().
	$this->getPasswordSalt();

	return new PhutilOpaqueEnvelope($input);
	}

	private function hashPassword(PhutilOpaqueEnvelope $password) {
	$hasher = PhabricatorPasswordHasher::getBestHasher();

	$input_envelope = $this->getPasswordHashInput($password);
	return $hasher->getPasswordHashForStorage($input_envelope);
	}

	const CSRF_CYCLE_FREQUENCY = 3600;
	const CSRF_SALT_LENGTH = 8;
	const CSRF_TOKEN_LENGTH = 16;
	const CSRF_BREACH_PREFIX = 'B@';

	const EMAIL_CYCLE_FREQUENCY = 86400;
	const EMAIL_TOKEN_LENGTH = 24;

	private function getRawCSRFToken($offset = 0) {
	return $this->generateToken(
	time() + (self::CSRF_CYCLE_FREQUENCY * $offset),
	self::CSRF_CYCLE_FREQUENCY,
	PhabricatorEnv::getEnvConfig('phabricator.csrf-key'),
	self::CSRF_TOKEN_LENGTH);
	}

	public function getCSRFToken() {
	if ($this->isOmnipotent()) {
	// We may end up here when called from the daemons. The omnipotent user
	// has no meaningful CSRF token, so just return `null`.
	return null;
	}

	if ($this->csrfSalt === null) {
	$this->csrfSalt = Filesystem::readRandomCharacters(
	self::CSRF_SALT_LENGTH);
	}

	$salt = $this->csrfSalt;

	// Generate a token hash to mitigate BREACH attacks against SSL. See
	// discussion in T3684.
	$token = $this->getRawCSRFToken();
	$hash = PhabricatorHash::digest($token, $salt);
	return self::CSRF_BREACH_PREFIX.$salt.substr(
	$hash, 0, self::CSRF_TOKEN_LENGTH);
	}

	public function validateCSRFToken($token) {
	// We expect a BREACH-mitigating token. See T3684.
	$breach_prefix = self::CSRF_BREACH_PREFIX;
	$breach_prelen = strlen($breach_prefix);
	if (strncmp($token, $breach_prefix, $breach_prelen) !== 0) {
	return false;
	}

	$salt = substr($token, $breach_prelen, self::CSRF_SALT_LENGTH);
	$token = substr($token, $breach_prelen + self::CSRF_SALT_LENGTH);

	// When the user posts a form, we check that it contains a valid CSRF token.
	// Tokens cycle each hour (every CSRF_CYLCE_FREQUENCY seconds) and we accept
	// either the current token, the next token (users can submit a "future"
	// token if you have two web frontends that have some clock skew) or any of
	// the last 6 tokens. This means that pages are valid for up to 7 hours.
	// There is also some Javascript which periodically refreshes the CSRF
	// tokens on each page, so theoretically pages should be valid indefinitely.
	// However, this code may fail to run (if the user loses their internet
	// connection, or there's a JS problem, or they don't have JS enabled).
	// Choosing the size of the window in which we accept old CSRF tokens is
	// an issue of balancing concerns between security and usability. We could
	// choose a very narrow (e.g., 1-hour) window to reduce vulnerability to
	// attacks using captured CSRF tokens, but it's also more likely that real
	// users will be affected by this, e.g. if they close their laptop for an
	// hour, open it back up, and try to submit a form before the CSRF refresh
	// can kick in. Since the user experience of submitting a form with expired
	// CSRF is often quite bad (you basically lose data, or it's a big pain to
	// recover at least) and I believe we gain little additional protection
	// by keeping the window very short (the overwhelming value here is in
	// preventing blind attacks, and most attacks which can capture CSRF tokens
	// can also just capture authentication information [sniffing networks]
	// or act as the user [xss]) the 7 hour default seems like a reasonable
	// balance. Other major platforms have much longer CSRF token lifetimes,
	// like Rails (session duration) and Django (forever), which suggests this
	// is a reasonable analysis.
	$csrf_window = 6;

	for ($ii = -$csrf_window; $ii <= 1; $ii++) {
	$valid = $this->getRawCSRFToken($ii);

	$digest = PhabricatorHash::digest($valid, $salt);
	$digest = substr($digest, 0, self::CSRF_TOKEN_LENGTH);
	if (phutil_hashes_are_identical($digest, $token)) {
	return true;
	}
	}

	return false;
	}

	private function generateToken($epoch, $frequency, $key, $len) {
	if ($this->getPHID()) {
	$vec = $this->getPHID().$this->getAccountSecret();
	} else {
	$vec = $this->getAlternateCSRFString();
	}

	if ($this->hasSession()) {
	$vec = $vec.$this->getSession()->getSessionKey();
	}

	$time_block = floor($epoch / $frequency);
	$vec = $vec.$key.$time_block;

	return substr(PhabricatorHash::digest($vec), 0, $len);
	}

	public function getUserProfile() {
	return $this->assertAttached($this->profile);
	}

	public function attachUserProfile(PhabricatorUserProfile $profile) {
	$this->profile = $profile;
	return $this;
	}

	public function loadUserProfile() {
	if ($this->profile) {
	return $this->profile;
	}

	$profile_dao = new PhabricatorUserProfile();
	$this->profile = $profile_dao->loadOneWhere('userPHID = %s',
	$this->getPHID());

	if (!$this->profile) {
	$this->profile = PhabricatorUserProfile::initializeNewProfile($this);
	}

	return $this->profile;
	}

	public function loadPrimaryEmailAddress() {
	$email = $this->loadPrimaryEmail();
	if (!$email) {
	throw new Exception(pht('User has no primary email address!'));
	}
	return $email->getAddress();
	}

	public function loadPrimaryEmail() {
	return $this->loadOneRelative(
	new PhabricatorUserEmail(),
	'userPHID',
	'getPHID',
	'(isPrimary = 1)');
	}

	public function getUserSetting($key) {
	$settings_key = PhabricatorUserPreferencesCacheType::KEY_PREFERENCES;
	$settings = $this->requireCacheData($settings_key);

	if (array_key_exists($key, $settings)) {
	return $settings[$key];
	}

	$defaults = PhabricatorSetting::getAllEnabledSettings($this);
	if (isset($defaults[$key])) {
	return $defaults[$key]->getSettingDefaultValue();
	}

	return null;
	}

	+ public function compareUserSetting($key, $value) {
	+ $actual = $this->getUserSetting($key);
	+ return ($actual == $value);
	+ }
	+
	public function loadPreferences() {
	if ($this->preferences) {
	return $this->preferences;
	}

	$preferences = null;
	if ($this->getPHID()) {
	$preferences = id(new PhabricatorUserPreferencesQuery())
	->setViewer($this)
	->withUsers(array($this))
	->executeOne();
	}

	if (!$preferences) {
	$preferences = new PhabricatorUserPreferences();
	$preferences->setUserPHID($this->getPHID());
	$preferences->attachUser($this);

	$default_dict = array(
	PhabricatorUserPreferences::PREFERENCE_TITLES => 'glyph',
	PhabricatorUserPreferences::PREFERENCE_EDITOR => '',
	PhabricatorUserPreferences::PREFERENCE_MONOSPACED => '',
	PhabricatorUserPreferences::PREFERENCE_DARK_CONSOLE => 0,
	);

	$preferences->setPreferences($default_dict);
	}

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

	public function loadEditorLink(
	$path,
	$line,
	PhabricatorRepository $repository = null) {

	$editor = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_EDITOR);

	if (is_array($path)) {
	$multiedit = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_MULTIEDIT);
	switch ($multiedit) {
	case '':
	$path = implode(' ', $path);
	break;
	case 'disable':
	return null;
	}
	}

	if (!strlen($editor)) {
	return null;
	}

	if ($repository) {
	$callsign = $repository->getCallsign();
	} else {
	$callsign = null;
	}

	$uri = strtr($editor, array(
	'%%' => '%',
	'%f' => phutil_escape_uri($path),
	'%l' => phutil_escape_uri($line),
	'%r' => phutil_escape_uri($callsign),
	));

	// The resulting URI must have an allowed protocol. Otherwise, we'll return
	// a link to an error page explaining the misconfiguration.

	$ok = PhabricatorHelpEditorProtocolController::hasAllowedProtocol($uri);
	if (!$ok) {
	return '/help/editorprotocol/';
	}

	return (string)$uri;
	}

	public function getAlternateCSRFString() {
	return $this->assertAttached($this->alternateCSRFString);
	}

	public function attachAlternateCSRFString($string) {
	$this->alternateCSRFString = $string;
	return $this;
	}

	/**
	* Populate the nametoken table, which used to fetch typeahead results. When
	* a user types "linc", we want to match "Abraham Lincoln" from on-demand
	* typeahead sources. To do this, we need a separate table of name fragments.
	*/
	public function updateNameTokens() {
	$table = self::NAMETOKEN_TABLE;
	$conn_w = $this->establishConnection('w');

	$tokens = PhabricatorTypeaheadDatasource::tokenizeString(
	$this->getUserName().' '.$this->getRealName());

	$sql = array();
	foreach ($tokens as $token) {
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %s)',
	$this->getID(),
	$token);
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE userID = %d',
	$table,
	$this->getID());
	if ($sql) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (userID, token) VALUES %Q',
	$table,
	implode(', ', $sql));
	}
	}

	public function sendWelcomeEmail(PhabricatorUser $admin) {
	if (!$this->canEstablishWebSessions()) {
	throw new Exception(
	pht(
	'Can not send welcome mail to users who can not establish '.
	'web sessions!'));
	}

	$admin_username = $admin->getUserName();
	$admin_realname = $admin->getRealName();
	$user_username = $this->getUserName();
	$is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');

	$base_uri = PhabricatorEnv::getProductionURI('/');

	$engine = new PhabricatorAuthSessionEngine();
	$uri = $engine->getOneTimeLoginURI(
	$this,
	$this->loadPrimaryEmail(),
	PhabricatorAuthSessionEngine::ONETIME_WELCOME);

	$body = pht(
	"Welcome to Phabricator!\n\n".
	"%s (%s) has created an account for you.\n\n".
	" Username: %s\n\n".
	"To login to Phabricator, follow this link and set a password:\n\n".
	" %s\n\n".
	"After you have set a password, you can login in the future by ".
	"going here:\n\n".
	" %s\n",
	$admin_username,
	$admin_realname,
	$user_username,
	$uri,
	$base_uri);

	if (!$is_serious) {
	$body .= sprintf(
	"\n%s\n",
	pht("Love,\nPhabricator"));
	}

	$mail = id(new PhabricatorMetaMTAMail())
	->addTos(array($this->getPHID()))
	->setForceDelivery(true)
	->setSubject(pht('[Phabricator] Welcome to Phabricator'))
	->setBody($body)
	->saveAndSend();
	}

	public function sendUsernameChangeEmail(
	PhabricatorUser $admin,
	$old_username) {

	$admin_username = $admin->getUserName();
	$admin_realname = $admin->getRealName();
	$new_username = $this->getUserName();

	$password_instructions = null;
	if (PhabricatorPasswordAuthProvider::getPasswordProvider()) {
	$engine = new PhabricatorAuthSessionEngine();
	$uri = $engine->getOneTimeLoginURI(
	$this,
	null,
	PhabricatorAuthSessionEngine::ONETIME_USERNAME);
	$password_instructions = sprintf(
	"%s\n\n %s\n\n%s\n",
	pht(
	"If you use a password to login, you'll need to reset it ".
	"before you can login again. You can reset your password by ".
	"following this link:"),
	$uri,
	pht(
	"And, of course, you'll need to use your new username to login ".
	"from now on. If you use OAuth to login, nothing should change."));
	}

	$body = sprintf(
	"%s\n\n %s\n %s\n\n%s",
	pht(
	'%s (%s) has changed your Phabricator username.',
	$admin_username,
	$admin_realname),
	pht(
	'Old Username: %s',
	$old_username),
	pht(
	'New Username: %s',
	$new_username),
	$password_instructions);

	$mail = id(new PhabricatorMetaMTAMail())
	->addTos(array($this->getPHID()))
	->setForceDelivery(true)
	->setSubject(pht('[Phabricator] Username Changed'))
	->setBody($body)
	->saveAndSend();
	}

	public static function describeValidUsername() {
	return pht(
	'Usernames must contain only numbers, letters, period, underscore and '.
	'hyphen, and can not end with a period. They must have no more than %d '.
	'characters.',
	new PhutilNumber(self::MAXIMUM_USERNAME_LENGTH));
	}

	public static function validateUsername($username) {
	// NOTE: If you update this, make sure to update:
	//
	// - Remarkup rule for @mentions.
	// - Routing rule for "/p/username/".
	// - Unit tests, obviously.
	// - describeValidUsername() method, above.

	if (strlen($username) > self::MAXIMUM_USERNAME_LENGTH) {
	return false;
	}

	return (bool)preg_match('/^[a-zA-Z0-9._-]*[a-zA-Z0-9_-]\z/', $username);
	}

	public static function getDefaultProfileImageURI() {
	return celerity_get_resource_uri('/rsrc/image/avatar.png');
	}

	public function attachProfileImageURI($uri) {
	$this->profileImage = $uri;
	return $this;
	}

	public function getProfileImageURI() {
	return $this->assertAttached($this->profileImage);
	}

	public function getFullName() {
	if (strlen($this->getRealName())) {
	return $this->getUsername().' ('.$this->getRealName().')';
	} else {
	return $this->getUsername();
	}
	}

	public function getTimeZone() {
	return new DateTimeZone($this->getTimezoneIdentifier());
	}

	public function getTimeZoneOffset() {
	$timezone = $this->getTimeZone();
	$now = new DateTime('@'.PhabricatorTime::getNow());
	$offset = $timezone->getOffset($now);

	// Javascript offsets are in minutes and have the opposite sign.
	$offset = -(int)($offset / 60);

	return $offset;
	}

	public function formatShortDateTime($when, $now = null) {
	if ($now === null) {
	$now = PhabricatorTime::getNow();
	}

	try {
	$when = new DateTime('@'.$when);
	$now = new DateTime('@'.$now);
	} catch (Exception $ex) {
	return null;
	}

	$zone = $this->getTimeZone();

	$when->setTimeZone($zone);
	$now->setTimeZone($zone);

	if ($when->format('Y') !== $now->format('Y')) {
	// Different year, so show "Feb 31 2075".
	$format = 'M j Y';
	} else if ($when->format('Ymd') !== $now->format('Ymd')) {
	// Same year but different month and day, so show "Feb 31".
	$format = 'M j';
	} else {
	// Same year, month and day so show a time of day.
	$pref_time = PhabricatorUserPreferences::PREFERENCE_TIME_FORMAT;
	$format = $this->getPreference($pref_time);
	}

	return $when->format($format);
	}

	public function getPreference($key) {
	$preferences = $this->loadPreferences();

	// TODO: After T4103 and T7707 this should eventually be pushed down the
	// stack into modular preference definitions and role profiles. This is
	// just fixing T8601 and mildly anticipating those changes.
	$value = $preferences->getPreference($key);

	$allowed_values = null;
	switch ($key) {
	case PhabricatorUserPreferences::PREFERENCE_TIME_FORMAT:
	$allowed_values = array(
	'g:i A',
	'H:i',
	);
	break;
	case PhabricatorUserPreferences::PREFERENCE_DATE_FORMAT:
	$allowed_values = array(
	'Y-m-d',
	'n/j/Y',
	'd-m-Y',
	);
	break;
	}

	if ($allowed_values !== null) {
	$allowed_values = array_fuse($allowed_values);
	if (empty($allowed_values[$value])) {
	$value = head($allowed_values);
	}
	}

	return $value;
	}

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

	public static function loadOneWithEmailAddress($address) {
	$email = id(new PhabricatorUserEmail())->loadOneWhere(
	'address = %s',
	$address);
	if (!$email) {
	return null;
	}
	return id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$email->getUserPHID());
	}

	public function getDefaultSpacePHID() {
	// TODO: We might let the user switch which space they're "in" later on;
	// for now just use the global space if one exists.

	// If the viewer has access to the default space, use that.
	$spaces = PhabricatorSpacesNamespaceQuery::getViewerActiveSpaces($this);
	foreach ($spaces as $space) {
	if ($space->getIsDefaultNamespace()) {
	return $space->getPHID();
	}
	}

	// Otherwise, use the space with the lowest ID that they have access to.
	// This just tends to keep the default stable and predictable over time,
	// so adding a new space won't change behavior for users.
	if ($spaces) {
	$spaces = msort($spaces, 'getID');
	return head($spaces)->getPHID();
	}

	return null;
	}


	/**
	* Grant a user a source of authority, to let them bypass policy checks they
	* could not otherwise.
	*/
	public function grantAuthority($authority) {
	$this->authorities[] = $authority;
	return $this;
	}


	/**
	* Get authorities granted to the user.
	*/
	public function getAuthorities() {
	return $this->authorities;
	}


	/* -( Availability )------------------------------------------------------- */


	/**
	* @task availability
	*/
	public function attachAvailability(array $availability) {
	$this->availability = $availability;
	return $this;
	}


	/**
	* Get the timestamp the user is away until, if they are currently away.
	*
	* @return int\|null Epoch timestamp, or `null` if the user is not away.
	* @task availability
	*/
	public function getAwayUntil() {
	$availability = $this->availability;

	$this->assertAttached($availability);
	if (!$availability) {
	return null;
	}

	return idx($availability, 'until');
	}


	/**
	* Describe the user's availability.
	*
	* @param PhabricatorUser Viewing user.
	* @return string Human-readable description of away status.
	* @task availability
	*/
	public function getAvailabilityDescription(PhabricatorUser $viewer) {
	$until = $this->getAwayUntil();
	if ($until) {
	return pht('Away until %s', phabricator_datetime($until, $viewer));
	} else {
	return pht('Available');
	}
	}


	/**
	* Get cached availability, if present.
	*
	* @return wild\|null Cache data, or null if no cache is available.
	* @task availability
	*/
	public function getAvailabilityCache() {
	$now = PhabricatorTime::getNow();
	if ($this->availabilityCacheTTL <= $now) {
	return null;
	}

	try {
	return phutil_json_decode($this->availabilityCache);
	} catch (Exception $ex) {
	return null;
	}
	}


	/**
	* Write to the availability cache.
	*
	* @param wild Availability cache data.
	* @param int\|null Cache TTL.
	* @return this
	* @task availability
	*/
	public function writeAvailabilityCache(array $availability, $ttl) {
	if (PhabricatorEnv::isReadOnly()) {
	return $this;
	}

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	queryfx(
	$this->establishConnection('w'),
	'UPDATE %T SET availabilityCache = %s, availabilityCacheTTL = %nd
	WHERE id = %d',
	$this->getTableName(),
	json_encode($availability),
	$ttl,
	$this->getID());
	unset($unguarded);

	return $this;
	}


	/* -( Profile Image Cache )------------------------------------------------ */


	/**
	* Get this user's cached profile image URI.
	*
	* @return string\|null Cached URI, if a URI is cached.
	* @task image-cache
	*/
	public function getProfileImageCache() {
	$version = $this->getProfileImageVersion();

	$parts = explode(',', $this->profileImageCache, 2);
	if (count($parts) !== 2) {
	return null;
	}

	if ($parts[0] !== $version) {
	return null;
	}

	return $parts[1];
	}


	/**
	* Generate a new cache value for this user's profile image.
	*
	* @return string New cache value.
	* @task image-cache
	*/
	public function writeProfileImageCache($uri) {
	$version = $this->getProfileImageVersion();
	$cache = "{$version},{$uri}";

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	queryfx(
	$this->establishConnection('w'),
	'UPDATE %T SET profileImageCache = %s WHERE id = %d',
	$this->getTableName(),
	$cache,
	$this->getID());
	unset($unguarded);
	}


	/**
	* Get a version identifier for a user's profile image.
	*
	* This version will change if the image changes, or if any of the
	* environment configuration which goes into generating a URI changes.
	*
	* @return string Cache version.
	* @task image-cache
	*/
	private function getProfileImageVersion() {
	$parts = array(
	PhabricatorEnv::getCDNURI('/'),
	PhabricatorEnv::getEnvConfig('cluster.instance'),
	$this->getProfileImagePHID(),
	);
	$parts = serialize($parts);
	return PhabricatorHash::digestForIndex($parts);
	}


	/* -( Multi-Factor Authentication )---------------------------------------- */


	/**
	* Update the flag storing this user's enrollment in multi-factor auth.
	*
	* With certain settings, we need to check if a user has MFA on every page,
	* so we cache MFA enrollment on the user object for performance. Calling this
	* method synchronizes the cache by examining enrollment records. After
	* updating the cache, use @{method:getIsEnrolledInMultiFactor} to check if
	* the user is enrolled.
	*
	* This method should be called after any changes are made to a given user's
	* multi-factor configuration.
	*
	* @return void
	* @task factors
	*/
	public function updateMultiFactorEnrollment() {
	$factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());

	$enrolled = count($factors) ? 1 : 0;
	if ($enrolled !== $this->isEnrolledInMultiFactor) {
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	queryfx(
	$this->establishConnection('w'),
	'UPDATE %T SET isEnrolledInMultiFactor = %d WHERE id = %d',
	$this->getTableName(),
	$enrolled,
	$this->getID());
	unset($unguarded);

	$this->isEnrolledInMultiFactor = $enrolled;
	}
	}


	/**
	* Check if the user is enrolled in multi-factor authentication.
	*
	* Enrolled users have one or more multi-factor authentication sources
	* attached to their account. For performance, this value is cached. You
	* can use @{method:updateMultiFactorEnrollment} to update the cache.
	*
	* @return bool True if the user is enrolled.
	* @task factors
	*/
	public function getIsEnrolledInMultiFactor() {
	return $this->isEnrolledInMultiFactor;
	}


	/* -( Omnipotence )-------------------------------------------------------- */


	/**
	* Returns true if this user is omnipotent. Omnipotent users bypass all policy
	* checks.
	*
	* @return bool True if the user bypasses policy checks.
	*/
	public function isOmnipotent() {
	return $this->omnipotent;
	}


	/**
	* Get an omnipotent user object for use in contexts where there is no acting
	* user, notably daemons.
	*
	* @return PhabricatorUser An omnipotent user.
	*/
	public static function getOmnipotentUser() {
	static $user = null;
	if (!$user) {
	$user = new PhabricatorUser();
	$user->omnipotent = true;
	$user->makeEphemeral();
	}
	return $user;
	}


	/**
	* Get a scalar string identifying this user.
	*
	* This is similar to using the PHID, but distinguishes between ominpotent
	* and public users explicitly. This allows safe construction of cache keys
	* or cache buckets which do not conflate public and omnipotent users.
	*
	* @return string Scalar identifier.
	*/
	public function getCacheFragment() {
	if ($this->isOmnipotent()) {
	return 'u.omnipotent';
	}

	$phid = $this->getPHID();
	if ($phid) {
	return 'u.'.$phid;
	}

	return 'u.public';
	}


	/* -( Managing Handles )--------------------------------------------------- */


	/**
	* Get a @{class:PhabricatorHandleList} which benefits from this viewer's
	* internal handle pool.
	*
	* @param list<phid> List of PHIDs to load.
	* @return PhabricatorHandleList Handle list object.
	* @task handle
	*/
	public function loadHandles(array $phids) {
	if ($this->handlePool === null) {
	$this->handlePool = id(new PhabricatorHandlePool())
	->setViewer($this);
	}

	return $this->handlePool->newHandleList($phids);
	}


	/**
	* Get a @{class:PHUIHandleView} for a single handle.
	*
	* This benefits from the viewer's internal handle pool.
	*
	* @param phid PHID to render a handle for.
	* @return PHUIHandleView View of the handle.
	* @task handle
	*/
	public function renderHandle($phid) {
	return $this->loadHandles(array($phid))->renderHandle($phid);
	}


	/**
	* Get a @{class:PHUIHandleListView} for a list of handles.
	*
	* This benefits from the viewer's internal handle pool.
	*
	* @param list<phid> List of PHIDs to render.
	* @return PHUIHandleListView View of the handles.
	* @task handle
	*/
	public function renderHandleList(array $phids) {
	return $this->loadHandles($phids)->renderList();
	}

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

	public function getBadgePHIDs() {
	return $this->assertAttached($this->badgePHIDs);
	}


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


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

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicies::POLICY_PUBLIC;
	case PhabricatorPolicyCapability::CAN_EDIT:
	if ($this->getIsSystemAgent() \|\| $this->getIsMailingList()) {
	return PhabricatorPolicies::POLICY_ADMIN;
	} else {
	return PhabricatorPolicies::POLICY_NOONE;
	}
	}
	}

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

	public function describeAutomaticCapability($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_EDIT:
	return pht('Only you can edit your information.');
	default:
	return null;
	}
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('user.fields');
	}

	public function getCustomFieldBaseClass() {
	return 'PhabricatorUserCustomField';
	}

	public function getCustomFields() {
	return $this->assertAttached($this->customFields);
	}

	public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
	$this->customFields = $fields;
	return $this;
	}


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


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

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

	$externals = id(new PhabricatorExternalAccount())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($externals as $external) {
	$external->delete();
	}

	$prefs = id(new PhabricatorUserPreferencesQuery())
	->setViewer($engine->getViewer())
	->withUsers(array($this))
	->execute();
	foreach ($prefs as $pref) {
	$engine->destroyObject($pref);
	}

	$profiles = id(new PhabricatorUserProfile())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($profiles as $profile) {
	$profile->delete();
	}

	$keys = id(new PhabricatorAuthSSHKeyQuery())
	->setViewer($engine->getViewer())
	->withObjectPHIDs(array($this->getPHID()))
	->execute();
	foreach ($keys as $key) {
	$engine->destroyObject($key);
	}

	$emails = id(new PhabricatorUserEmail())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($emails as $email) {
	$email->delete();
	}

	$sessions = id(new PhabricatorAuthSession())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($sessions as $session) {
	$session->delete();
	}

	$factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($factors as $factor) {
	$factor->delete();
	}

	$this->saveTransaction();
	}


	/* -( PhabricatorSSHPublicKeyInterface )----------------------------------- */


	public function getSSHPublicKeyManagementURI(PhabricatorUser $viewer) {
	if ($viewer->getPHID() == $this->getPHID()) {
	// If the viewer is managing their own keys, take them to the normal
	// panel.
	return '/settings/panel/ssh/';
	} else {
	// Otherwise, take them to the administrative panel for this user.
	return '/settings/'.$this->getID().'/panel/ssh/';
	}
	}

	public function getSSHKeyDefaultName() {
	return 'id_rsa_phabricator';
	}

	public function getSSHKeyNotifyPHIDs() {
	return array(
	$this->getPHID(),
	);
	}


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


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

	public function getApplicationTransactionObject() {
	return $this;
	}

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

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {
	return $timeline;
	}


	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new PhabricatorUserFulltextEngine();
	}


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


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('username')
	->setType('string')
	->setDescription(pht("The user's username.")),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('realName')
	->setType('string')
	->setDescription(pht("The user's real name.")),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('roles')
	->setType('list<string>')
	->setDescription(pht('List of acccount roles.')),
	);
	}

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

	if ($this->getIsDisabled()) {
	$roles[] = 'disabled';
	}

	if ($this->getIsSystemAgent()) {
	$roles[] = 'bot';
	}

	if ($this->getIsMailingList()) {
	$roles[] = 'list';
	}

	if ($this->getIsAdmin()) {
	$roles[] = 'admin';
	}

	if ($this->getIsEmailVerified()) {
	$roles[] = 'verified';
	}

	if ($this->getIsApproved()) {
	$roles[] = 'approved';
	}

	if ($this->isUserActivated()) {
	$roles[] = 'activated';
	}

	return array(
	'username' => $this->getUsername(),
	'realName' => $this->getRealName(),
	'roles' => $roles,
	);
	}

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


	/* -( User Cache )--------------------------------------------------------- */


	/**
	* @task cache
	*/
	public function attachRawCacheData(array $data) {
	$this->rawCacheData = $data + $this->rawCacheData;
	return $this;
	}


	/**
	* @task cache
	*/
	protected function requireCacheData($key) {
	if (isset($this->usableCacheData[$key])) {
	return $this->usableCacheData[$key];
	}

	$type = PhabricatorUserCacheType::requireCacheTypeForKey($key);

	if (isset($this->rawCacheData[$key])) {
	$raw_value = $this->rawCacheData[$key];

	$usable_value = $type->getValueFromStorage($raw_value);
	$this->usableCacheData[$key] = $usable_value;

	return $usable_value;
	}

	$usable_value = $type->getDefaultValue();

	$user_phid = $this->getPHID();
	if ($user_phid) {
	$map = $type->newValueForUsers($key, array($this));
	if (array_key_exists($user_phid, $map)) {
	$usable_value = $map[$user_phid];
	$raw_value = $type->getValueForStorage($usable_value);

	$this->rawCacheData[$key] = $raw_value;
	PhabricatorUserCache::writeCache(
	$type,
	$key,
	$user_phid,
	$raw_value);
	}
	}

	$this->usableCacheData[$key] = $usable_value;

	return $usable_value;
	}

	}
	diff --git a/src/applications/policy/query/PhabricatorPolicyQuery.php b/src/applications/policy/query/PhabricatorPolicyQuery.php
	index e6e7008827..81c9bb8a51 100644
	--- a/src/applications/policy/query/PhabricatorPolicyQuery.php
	+++ b/src/applications/policy/query/PhabricatorPolicyQuery.php
	@@ -1,429 +1,428 @@
	<?php

	final class PhabricatorPolicyQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $object;
	private $phids;

	const OBJECT_POLICY_PREFIX = 'obj.';

	public function setObject(PhabricatorPolicyInterface $object) {
	$this->object = $object;
	return $this;
	}

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

	public static function loadPolicies(
	PhabricatorUser $viewer,
	PhabricatorPolicyInterface $object) {

	$results = array();

	$map = array();
	foreach ($object->getCapabilities() as $capability) {
	$map[$capability] = $object->getPolicy($capability);
	}

	$policies = id(new PhabricatorPolicyQuery())
	->setViewer($viewer)
	->withPHIDs($map)
	->execute();

	foreach ($map as $capability => $phid) {
	$results[$capability] = $policies[$phid];
	}

	return $results;
	}

	public static function renderPolicyDescriptions(
	PhabricatorUser $viewer,
	PhabricatorPolicyInterface $object,
	$icon = false) {

	$policies = self::loadPolicies($viewer, $object);

	foreach ($policies as $capability => $policy) {
	$policies[$capability] = $policy->renderDescription($icon);
	}

	return $policies;
	}

	protected function loadPage() {
	if ($this->object && $this->phids) {
	throw new Exception(
	pht(
	'You can not issue a policy query with both %s and %s.',
	'setObject()',
	'setPHIDs()'));
	} else if ($this->object) {
	$phids = $this->loadObjectPolicyPHIDs();
	} else {
	$phids = $this->phids;
	}

	$phids = array_fuse($phids);

	$results = array();

	// First, load global policies.
	foreach (self::getGlobalPolicies() as $phid => $policy) {
	if (isset($phids[$phid])) {
	$results[$phid] = $policy;
	unset($phids[$phid]);
	}
	}

	// Now, load object policies.
	foreach (self::getObjectPolicies($this->object) as $phid => $policy) {
	if (isset($phids[$phid])) {
	$results[$phid] = $policy;
	unset($phids[$phid]);
	}
	}

	// If we still need policies, we're going to have to fetch data. Bucket
	// the remaining policies into rule-based policies and handle-based
	// policies.
	if ($phids) {
	$rule_policies = array();
	$handle_policies = array();
	foreach ($phids as $phid) {
	$phid_type = phid_get_type($phid);
	if ($phid_type == PhabricatorPolicyPHIDTypePolicy::TYPECONST) {
	$rule_policies[$phid] = $phid;
	} else {
	$handle_policies[$phid] = $phid;
	}
	}

	if ($handle_policies) {
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->getViewer())
	->withPHIDs($handle_policies)
	->execute();
	foreach ($handle_policies as $phid) {
	$results[$phid] = PhabricatorPolicy::newFromPolicyAndHandle(
	$phid,
	$handles[$phid]);
	}
	}

	if ($rule_policies) {
	$rules = id(new PhabricatorPolicy())->loadAllWhere(
	'phid IN (%Ls)',
	$rule_policies);
	$results += mpull($rules, null, 'getPHID');
	}
	}

	$results = msort($results, 'getSortKey');

	return $results;
	}

	public static function isGlobalPolicy($policy) {
	$global_policies = self::getGlobalPolicies();

	if (isset($global_policies[$policy])) {
	return true;
	}

	return false;
	}

	public static function getGlobalPolicy($policy) {
	if (!self::isGlobalPolicy($policy)) {
	throw new Exception(pht("Policy '%s' is not a global policy!", $policy));
	}
	return idx(self::getGlobalPolicies(), $policy);
	}

	private static function getGlobalPolicies() {
	static $constants = array(
	PhabricatorPolicies::POLICY_PUBLIC,
	PhabricatorPolicies::POLICY_USER,
	PhabricatorPolicies::POLICY_ADMIN,
	PhabricatorPolicies::POLICY_NOONE,
	);

	$results = array();
	foreach ($constants as $constant) {
	$results[$constant] = id(new PhabricatorPolicy())
	->setType(PhabricatorPolicyType::TYPE_GLOBAL)
	->setPHID($constant)
	->setName(self::getGlobalPolicyName($constant))
	->setShortName(self::getGlobalPolicyShortName($constant))
	->makeEphemeral();
	}

	return $results;
	}

	private static function getGlobalPolicyName($policy) {
	switch ($policy) {
	case PhabricatorPolicies::POLICY_PUBLIC:
	return pht('Public (No Login Required)');
	case PhabricatorPolicies::POLICY_USER:
	return pht('All Users');
	case PhabricatorPolicies::POLICY_ADMIN:
	return pht('Administrators');
	case PhabricatorPolicies::POLICY_NOONE:
	return pht('No One');
	default:
	return pht('Unknown Policy');
	}
	}

	private static function getGlobalPolicyShortName($policy) {
	switch ($policy) {
	case PhabricatorPolicies::POLICY_PUBLIC:
	return pht('Public');
	default:
	return null;
	}
	}

	private function loadObjectPolicyPHIDs() {
	$phids = array();
	$viewer = $this->getViewer();

	if ($viewer->getPHID()) {
	$pref_key = PhabricatorUserPreferences::PREFERENCE_FAVORITE_POLICIES;

	$favorite_limit = 10;
	$default_limit = 5;

	// If possible, show the user's 10 most recently used projects.
	- $preferences = $viewer->loadPreferences();
	- $favorites = $preferences->getPreference($pref_key);
	+ $favorites = $viewer->getUserSetting($pref_key);
	if (!is_array($favorites)) {
	$favorites = array();
	}
	$favorite_phids = array_keys($favorites);
	$favorite_phids = array_slice($favorite_phids, -$favorite_limit);

	if ($favorite_phids) {
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withPHIDs($favorite_phids)
	->withIsMilestone(false)
	->setLimit($favorite_limit)
	->execute();
	$projects = mpull($projects, null, 'getPHID');
	} else {
	$projects = array();
	}

	// If we didn't find enough favorites, add some default projects. These
	// are just arbitrary projects that the viewer is a member of, but may
	// be useful on smaller installs and for new users until they can use
	// the control enough time to establish useful favorites.
	if (count($projects) < $default_limit) {
	$default_projects = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withMemberPHIDs(array($viewer->getPHID()))
	->withIsMilestone(false)
	->withStatuses(
	array(
	PhabricatorProjectStatus::STATUS_ACTIVE,
	))
	->setLimit($default_limit)
	->execute();
	$default_projects = mpull($default_projects, null, 'getPHID');
	$projects = $projects + $default_projects;
	$projects = array_slice($projects, 0, $default_limit);
	}

	foreach ($projects as $project) {
	$phids[] = $project->getPHID();
	}

	// Include the "current viewer" policy. This improves consistency, but
	// is also useful for creating private instances of normally-shared object
	// types, like repositories.
	$phids[] = $viewer->getPHID();
	}

	$capabilities = $this->object->getCapabilities();
	foreach ($capabilities as $capability) {
	$policy = $this->object->getPolicy($capability);
	if (!$policy) {
	continue;
	}
	$phids[] = $policy;
	}

	// If this install doesn't have "Public" enabled, don't include it as an
	// option unless the object already has a "Public" policy. In this case we
	// retain the policy but enforce it as though it was "All Users".
	$show_public = PhabricatorEnv::getEnvConfig('policy.allow-public');
	foreach (self::getGlobalPolicies() as $phid => $policy) {
	if ($phid == PhabricatorPolicies::POLICY_PUBLIC) {
	if (!$show_public) {
	continue;
	}
	}
	$phids[] = $phid;
	}

	foreach (self::getObjectPolicies($this->object) as $phid => $policy) {
	$phids[] = $phid;
	}

	return $phids;
	}

	protected function shouldDisablePolicyFiltering() {
	// Policy filtering of policies is currently perilous and not required by
	// the application.
	return true;
	}

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

	public static function isSpecialPolicy($identifier) {
	if (self::isObjectPolicy($identifier)) {
	return true;
	}

	if (self::isGlobalPolicy($identifier)) {
	return true;
	}

	return false;
	}


	/* -( Object Policies )---------------------------------------------------- */


	public static function isObjectPolicy($identifier) {
	$prefix = self::OBJECT_POLICY_PREFIX;
	return !strncmp($identifier, $prefix, strlen($prefix));
	}

	public static function getObjectPolicy($identifier) {
	if (!self::isObjectPolicy($identifier)) {
	return null;
	}

	$policies = self::getObjectPolicies(null);
	return idx($policies, $identifier);
	}

	public static function getObjectPolicyRule($identifier) {
	if (!self::isObjectPolicy($identifier)) {
	return null;
	}

	$rules = self::getObjectPolicyRules(null);
	return idx($rules, $identifier);
	}

	public static function getObjectPolicies($object) {
	$rule_map = self::getObjectPolicyRules($object);

	$results = array();
	foreach ($rule_map as $key => $rule) {
	$results[$key] = id(new PhabricatorPolicy())
	->setType(PhabricatorPolicyType::TYPE_OBJECT)
	->setPHID($key)
	->setIcon($rule->getObjectPolicyIcon())
	->setName($rule->getObjectPolicyName())
	->setShortName($rule->getObjectPolicyShortName())
	->makeEphemeral();
	}

	return $results;
	}

	public static function getObjectPolicyRules($object) {
	$rules = id(new PhutilClassMapQuery())
	->setAncestorClass('PhabricatorPolicyRule')
	->execute();

	$results = array();
	foreach ($rules as $rule) {
	$key = $rule->getObjectPolicyKey();
	if (!$key) {
	continue;
	}

	$full_key = $rule->getObjectPolicyFullKey();
	if (isset($results[$full_key])) {
	throw new Exception(
	pht(
	'Two policy rules (of classes "%s" and "%s") define the same '.
	'object policy key ("%s"), but each object policy rule must use '.
	'a unique key.',
	get_class($rule),
	get_class($results[$full_key]),
	$key));
	}

	$results[$full_key] = $rule;
	}

	if ($object !== null) {
	foreach ($results as $key => $rule) {
	if (!$rule->canApplyToObject($object)) {
	unset($results[$key]);
	}
	}
	}

	return $results;
	}

	public static function getDefaultPolicyForObject(
	PhabricatorUser $viewer,
	PhabricatorPolicyInterface $object,
	$capability) {

	$phid = $object->getPHID();
	if (!$phid) {
	return null;
	}

	$type = phid_get_type($phid);

	$map = self::getDefaultObjectTypePolicyMap();

	if (empty($map[$type][$capability])) {
	return null;
	}

	$policy_phid = $map[$type][$capability];

	return id(new PhabricatorPolicyQuery())
	->setViewer($viewer)
	->withPHIDs(array($policy_phid))
	->executeOne();
	}

	private static function getDefaultObjectTypePolicyMap() {
	static $map;

	if ($map === null) {
	$map = array();

	$apps = PhabricatorApplication::getAllApplications();
	foreach ($apps as $app) {
	$map += $app->getDefaultObjectTypePolicyMap();
	}
	}

	return $map;
	}


	}
	diff --git a/src/applications/search/engine/PhabricatorProfilePanelEngine.php b/src/applications/search/engine/PhabricatorProfilePanelEngine.php
	index b92ba451d0..6e2e74f3b6 100644
	--- a/src/applications/search/engine/PhabricatorProfilePanelEngine.php
	+++ b/src/applications/search/engine/PhabricatorProfilePanelEngine.php
	@@ -1,967 +1,966 @@
	<?php

	abstract class PhabricatorProfilePanelEngine extends Phobject {

	private $viewer;
	private $profileObject;
	private $panels;
	private $defaultPanel;
	private $controller;
	private $navigation;

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

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

	public function setProfileObject($profile_object) {
	$this->profileObject = $profile_object;
	return $this;
	}

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

	public function setController(PhabricatorController $controller) {
	$this->controller = $controller;
	return $this;
	}

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

	private function setDefaultPanel(
	PhabricatorProfilePanelConfiguration $default_panel) {
	$this->defaultPanel = $default_panel;
	return $this;
	}

	public function getDefaultPanel() {
	$this->loadPanels();
	return $this->defaultPanel;
	}

	abstract protected function getPanelURI($path);

	abstract protected function isPanelEngineConfigurable();

	public function buildResponse() {
	$controller = $this->getController();

	$viewer = $controller->getViewer();
	$this->setViewer($viewer);

	$request = $controller->getRequest();

	$panel_action = $request->getURIData('panelAction');

	// If the engine is not configurable, don't respond to any of the editing
	// or configuration routes.
	if (!$this->isPanelEngineConfigurable()) {
	switch ($panel_action) {
	case 'view':
	break;
	default:
	return new Aphront404Response();
	}
	}

	$panel_id = $request->getURIData('panelID');

	$panel_list = $this->loadPanels();

	$selected_panel = null;
	if (strlen($panel_id)) {
	$panel_id_int = (int)$panel_id;
	foreach ($panel_list as $panel) {
	if ($panel_id_int) {
	if ((int)$panel->getID() === $panel_id_int) {
	$selected_panel = $panel;
	break;
	}
	}

	$builtin_key = $panel->getBuiltinKey();
	if ($builtin_key === (string)$panel_id) {
	$selected_panel = $panel;
	break;
	}
	}
	}

	switch ($panel_action) {
	case 'view':
	case 'info':
	case 'hide':
	case 'default':
	case 'builtin':
	if (!$selected_panel) {
	return new Aphront404Response();
	}
	break;
	}

	$navigation = $this->buildNavigation();
	$navigation->selectFilter('panel.configure');

	$crumbs = $controller->buildApplicationCrumbsForEditEngine();

	switch ($panel_action) {
	case 'view':
	$content = $this->buildPanelViewContent($selected_panel);
	break;
	case 'configure':
	$content = $this->buildPanelConfigureContent($panel_list);
	$crumbs->addTextCrumb(pht('Configure Menu'));
	break;
	case 'reorder':
	$content = $this->buildPanelReorderContent($panel_list);
	break;
	case 'new':
	$panel_key = $request->getURIData('panelKey');
	$content = $this->buildPanelNewContent($panel_key);
	break;
	case 'builtin':
	$content = $this->buildPanelBuiltinContent($selected_panel);
	break;
	case 'hide':
	$content = $this->buildPanelHideContent($selected_panel);
	break;
	case 'default':
	$content = $this->buildPanelDefaultContent(
	$selected_panel,
	$panel_list);
	break;
	case 'edit':
	$content = $this->buildPanelEditContent();
	break;
	default:
	throw new Exception(
	pht(
	'Unsupported panel action "%s".',
	$panel_action));
	}

	if ($content instanceof AphrontResponse) {
	return $content;
	}

	if ($content instanceof AphrontResponseProducerInterface) {
	return $content;
	}

	return $controller->newPage()
	->setTitle(pht('Profile Stuff'))
	->setNavigation($navigation)
	->setCrumbs($crumbs)
	->appendChild($content);
	}

	public function buildNavigation() {
	if ($this->navigation) {
	return $this->navigation;
	}

	$nav = id(new AphrontSideNavFilterView())
	->setIsProfileMenu(true)
	->setBaseURI(new PhutilURI($this->getPanelURI('')));

	$panels = $this->getPanels();

	foreach ($panels as $panel) {
	if ($panel->isDisabled()) {
	continue;
	}

	$items = $panel->buildNavigationMenuItems();
	foreach ($items as $item) {
	$this->validateNavigationMenuItem($item);
	}

	// If the panel produced only a single item which does not otherwise
	// have a key, try to automatically assign it a reasonable key. This
	// makes selecting the correct item simpler.

	if (count($items) == 1) {
	$item = head($items);
	if ($item->getKey() === null) {
	$builtin_key = $panel->getBuiltinKey();
	$panel_phid = $panel->getPHID();
	if ($builtin_key !== null) {
	$item->setKey($builtin_key);
	} else if ($panel_phid !== null) {
	$item->setKey($panel_phid);
	}
	}
	}

	foreach ($items as $item) {
	$nav->addMenuItem($item);
	}
	}

	$more_items = $this->newAutomaticMenuItems($nav);
	foreach ($more_items as $item) {
	$nav->addMenuItem($item);
	}

	$nav->selectFilter(null);

	$this->navigation = $nav;
	return $this->navigation;
	}

	private function getPanels() {
	if ($this->panels === null) {
	$this->panels = $this->loadPanels();
	}

	return $this->panels;
	}

	private function loadPanels() {
	$viewer = $this->getViewer();
	$object = $this->getProfileObject();

	$panels = $this->loadBuiltinProfilePanels();

	$stored_panels = id(new PhabricatorProfilePanelConfigurationQuery())
	->setViewer($viewer)
	->withProfilePHIDs(array($object->getPHID()))
	->execute();

	foreach ($stored_panels as $stored_panel) {
	$impl = $stored_panel->getPanel();
	$impl->setViewer($viewer);
	}

	// Merge the stored panels into the builtin panels. If a builtin panel has
	// a stored version, replace the defaults with the stored changes.
	foreach ($stored_panels as $stored_panel) {
	if (!$stored_panel->shouldEnableForObject($object)) {
	continue;
	}

	$builtin_key = $stored_panel->getBuiltinKey();
	if ($builtin_key !== null) {
	// If this builtin actually exists, replace the builtin with the
	// stored configuration. Otherwise, we're just going to drop the
	// stored config: it corresponds to an out-of-date or uninstalled
	// panel.
	if (isset($panels[$builtin_key])) {
	$panels[$builtin_key] = $stored_panel;
	} else {
	continue;
	}
	} else {
	$panels[] = $stored_panel;
	}
	}

	$panels = msort($panels, 'getSortKey');

	// Normalize keys since callers shouldn't rely on this array being
	// partially keyed.
	$panels = array_values($panels);


	// Make sure exactly one valid panel is marked as default.
	$default = null;
	$first = null;
	foreach ($panels as $panel) {
	if (!$panel->canMakeDefault()) {
	continue;
	}

	if ($panel->isDefault()) {
	$default = $panel;
	break;
	}

	if ($first === null) {
	$first = $panel;
	}
	}

	if (!$default) {
	$default = $first;
	}

	if ($default) {
	$this->setDefaultPanel($default);
	}

	return $panels;
	}

	private function loadBuiltinProfilePanels() {
	$object = $this->getProfileObject();
	$builtins = $this->getBuiltinProfilePanels($object);

	$panels = PhabricatorProfilePanel::getAllPanels();
	$viewer = $this->getViewer();

	$order = 1;
	$map = array();
	foreach ($builtins as $builtin) {
	$builtin_key = $builtin->getBuiltinKey();

	if (!$builtin_key) {
	throw new Exception(
	pht(
	'Object produced a builtin panel with no builtin panel key! '.
	'Builtin panels must have a unique key.'));
	}

	if (isset($map[$builtin_key])) {
	throw new Exception(
	pht(
	'Object produced two panels with the same builtin key ("%s"). '.
	'Each panel must have a unique builtin key.',
	$builtin_key));
	}

	$panel_key = $builtin->getPanelKey();

	$panel = idx($panels, $panel_key);
	if (!$panel) {
	throw new Exception(
	pht(
	'Builtin panel ("%s") specifies a bad panel key ("%s"); there '.
	'is no corresponding panel implementation available.',
	$builtin_key,
	$panel_key));
	}

	$panel = clone $panel;
	$panel->setViewer($viewer);

	$builtin
	->setProfilePHID($object->getPHID())
	->attachPanel($panel)
	->attachProfileObject($object)
	->setPanelOrder($order);

	if (!$builtin->shouldEnableForObject($object)) {
	continue;
	}

	$map[$builtin_key] = $builtin;

	$order++;
	}

	return $map;
	}

	private function validateNavigationMenuItem($item) {
	if (!($item instanceof PHUIListItemView)) {
	throw new Exception(
	pht(
	'Expected buildNavigationMenuItems() to return a list of '.
	'PHUIListItemView objects, but got a surprise.'));
	}
	}

	private function newAutomaticMenuItems(AphrontSideNavFilterView $nav) {
	$items = array();

	// NOTE: We're adding a spacer item for the fixed footer, so that if the
	// menu taller than the page content you can still scroll down the page far
	// enough to access the last item without the content being obscured by the
	// fixed items.
	$items[] = id(new PHUIListItemView())
	->setHideInApplicationMenu(true)
	->addClass('phui-profile-menu-spacer');

	$collapse_id = celerity_generate_unique_node_id();
	$viewer = $this->getViewer();
	$collapse_key =
	PhabricatorUserPreferences::PREFERENCE_PROFILE_MENU_COLLAPSED;

	- $preferences = $viewer->loadPreferences();
	- $is_collapsed = $preferences->getPreference($collapse_key, false);
	+ $is_collapsed = $viewer->getUserSetting($collapse_key);

	if ($is_collapsed) {
	$nav->addClass('phui-profile-menu-collapsed');
	} else {
	$nav->addClass('phui-profile-menu-expanded');
	}

	if ($viewer->isLoggedIn()) {
	$settings_uri = '/settings/adjust/?key='.$collapse_key;
	} else {
	$settings_uri = null;
	}

	Javelin::initBehavior(
	'phui-profile-menu',
	array(
	'menuID' => $nav->getMainID(),
	'collapseID' => $collapse_id,
	'isCollapsed' => (bool)$is_collapsed,
	'settingsURI' => $settings_uri,
	));

	$collapse_icon = id(new PHUIIconCircleView())
	->addClass('phui-list-item-icon')
	->addClass('phui-profile-menu-visible-when-expanded')
	->setIcon('fa-chevron-left');

	$expand_icon = id(new PHUIIconCircleView())
	->addClass('phui-list-item-icon')
	->addClass('phui-profile-menu-visible-when-collapsed')
	->addSigil('has-tooltip')
	->setMetadata(
	array(
	'tip' => pht('Expand'),
	'align' => 'E',
	))
	->setIcon('fa-chevron-right');

	$items[] = id(new PHUIListItemView())
	->setName('Collapse')
	->addIcon($collapse_icon)
	->addIcon($expand_icon)
	->setID($collapse_id)
	->addClass('phui-profile-menu-footer')
	->addClass('phui-profile-menu-footer-1')
	->setHideInApplicationMenu(true)
	->setHref('#');

	return $items;
	}

	public function getConfigureURI() {
	return $this->getPanelURI('configure/');
	}

	private function buildPanelReorderContent(array $panels) {
	$viewer = $this->getViewer();
	$object = $this->getProfileObject();

	PhabricatorPolicyFilter::requireCapability(
	$viewer,
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);

	$controller = $this->getController();
	$request = $controller->getRequest();

	$request->validateCSRF();

	$order = $request->getStrList('order');

	$by_builtin = array();
	$by_id = array();

	foreach ($panels as $key => $panel) {
	$id = $panel->getID();
	if ($id) {
	$by_id[$id] = $key;
	continue;
	}

	$builtin_key = $panel->getBuiltinKey();
	if ($builtin_key) {
	$by_builtin[$builtin_key] = $key;
	continue;
	}
	}

	$key_order = array();
	foreach ($order as $order_item) {
	if (isset($by_id[$order_item])) {
	$key_order[] = $by_id[$order_item];
	continue;
	}
	if (isset($by_builtin[$order_item])) {
	$key_order[] = $by_builtin[$order_item];
	continue;
	}
	}

	$panels = array_select_keys($panels, $key_order) + $panels;

	$type_order =
	PhabricatorProfilePanelConfigurationTransaction::TYPE_ORDER;

	$order = 1;
	foreach ($panels as $panel) {
	$xactions = array();

	$xactions[] = id(new PhabricatorProfilePanelConfigurationTransaction())
	->setTransactionType($type_order)
	->setNewValue($order);

	$editor = id(new PhabricatorProfilePanelEditor())
	->setContentSourceFromRequest($request)
	->setActor($viewer)
	->setContinueOnMissingFields(true)
	->setContinueOnNoEffect(true)
	->applyTransactions($panel, $xactions);

	$order++;
	}

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


	private function buildPanelConfigureContent(array $panels) {
	$viewer = $this->getViewer();
	$object = $this->getProfileObject();

	PhabricatorPolicyFilter::requireCapability(
	$viewer,
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);

	$list_id = celerity_generate_unique_node_id();

	Javelin::initBehavior(
	'reorder-profile-menu-items',
	array(
	'listID' => $list_id,
	'orderURI' => $this->getPanelURI('reorder/'),
	));

	$list = id(new PHUIObjectItemListView())
	->setID($list_id);

	foreach ($panels as $panel) {
	$id = $panel->getID();
	$builtin_key = $panel->getBuiltinKey();

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

	$item = id(new PHUIObjectItemView());

	$name = $panel->getDisplayName();
	$type = $panel->getPanelTypeName();
	if (!strlen(trim($name))) {
	$name = pht('Untitled "%s" Item', $type);
	}

	$item->setHeader($name);
	$item->addAttribute($type);

	if ($can_edit) {
	$item
	->setGrippable(true)
	->addSigil('profile-menu-item')
	->setMetadata(
	array(
	'key' => nonempty($id, $builtin_key),
	));

	if ($id) {
	$default_uri = $this->getPanelURI("default/{$id}/");
	} else {
	$default_uri = $this->getPanelURI("default/{$builtin_key}/");
	}

	if ($panel->isDefault()) {
	$default_icon = 'fa-thumb-tack green';
	$default_text = pht('Current Default');
	} else if ($panel->canMakeDefault()) {
	$default_icon = 'fa-thumb-tack';
	$default_text = pht('Make Default');
	} else {
	$default_text = null;
	}

	if ($default_text !== null) {
	$item->addAction(
	id(new PHUIListItemView())
	->setHref($default_uri)
	->setWorkflow(true)
	->setName($default_text)
	->setIcon($default_icon));
	}

	if ($id) {
	$item->setHref($this->getPanelURI("edit/{$id}/"));
	$hide_uri = $this->getPanelURI("hide/{$id}/");
	} else {
	$item->setHref($this->getPanelURI("builtin/{$builtin_key}/"));
	$hide_uri = $this->getPanelURI("hide/{$builtin_key}/");
	}

	if ($panel->isDisabled()) {
	$hide_icon = 'fa-plus';
	$hide_text = pht('Enable');
	} else if ($panel->getBuiltinKey() !== null) {
	$hide_icon = 'fa-times';
	$hide_text = pht('Disable');
	} else {
	$hide_icon = 'fa-times';
	$hide_text = pht('Delete');
	}

	$can_disable = $panel->canHidePanel();

	$item->addAction(
	id(new PHUIListItemView())
	->setHref($hide_uri)
	->setWorkflow(true)
	->setDisabled(!$can_disable)
	->setName($hide_text)
	->setIcon($hide_icon));
	}

	if ($panel->isDisabled()) {
	$item->setDisabled(true);
	}

	$list->addItem($item);
	}

	$action_view = id(new PhabricatorActionListView())
	->setUser($viewer);

	$panel_types = PhabricatorProfilePanel::getAllPanels();

	$action_view->addAction(
	id(new PhabricatorActionView())
	->setLabel(true)
	->setName(pht('Add New Menu Item...')));

	foreach ($panel_types as $panel_type) {
	if (!$panel_type->canAddToObject($object)) {
	continue;
	}

	$panel_key = $panel_type->getPanelKey();

	$action_view->addAction(
	id(new PhabricatorActionView())
	->setIcon($panel_type->getPanelTypeIcon())
	->setName($panel_type->getPanelTypeName())
	->setHref($this->getPanelURI("new/{$panel_key}/")));
	}

	$action_view->addAction(
	id(new PhabricatorActionView())
	->setLabel(true)
	->setName(pht('Documentation')));

	$doc_link = PhabricatorEnv::getDoclink('Profile Menu User Guide');
	$doc_name = pht('Profile Menu User Guide');

	$action_view->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-book')
	->setHref($doc_link)
	->setName($doc_name));

	$action_button = id(new PHUIButtonView())
	->setTag('a')
	->setText(pht('Configure Menu'))
	->setHref('#')
	->setIcon('fa-gear')
	->setDropdownMenu($action_view);

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Profile Menu Items'))
	->setSubHeader(pht('Drag tabs to reorder menu'))
	->addActionLink($action_button);

	$box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->setObjectList($list);

	return $box;
	}

	private function buildPanelNewContent($panel_key) {
	$panel_types = PhabricatorProfilePanel::getAllPanels();
	$panel_type = idx($panel_types, $panel_key);
	if (!$panel_type) {
	return new Aphront404Response();
	}

	$object = $this->getProfileObject();
	if (!$panel_type->canAddToObject($object)) {
	return new Aphront404Response();
	}

	$configuration =
	PhabricatorProfilePanelConfiguration::initializeNewPanelConfiguration(
	$object,
	$panel_type);

	$viewer = $this->getViewer();

	PhabricatorPolicyFilter::requireCapability(
	$viewer,
	$configuration,
	PhabricatorPolicyCapability::CAN_EDIT);

	$controller = $this->getController();

	return id(new PhabricatorProfilePanelEditEngine())
	->setPanelEngine($this)
	->setProfileObject($object)
	->setNewPanelConfiguration($configuration)
	->setController($controller)
	->buildResponse();
	}

	private function buildPanelEditContent() {
	$viewer = $this->getViewer();
	$object = $this->getProfileObject();
	$controller = $this->getController();

	return id(new PhabricatorProfilePanelEditEngine())
	->setPanelEngine($this)
	->setProfileObject($object)
	->setController($controller)
	->buildResponse();
	}

	private function buildPanelBuiltinContent(
	PhabricatorProfilePanelConfiguration $configuration) {

	// If this builtin panel has already been persisted, redirect to the
	// edit page.
	$id = $configuration->getID();
	if ($id) {
	return id(new AphrontRedirectResponse())
	->setURI($this->getPanelURI("edit/{$id}/"));
	}

	// Otherwise, act like we're creating a new panel, we're just starting
	// with the builtin template.
	$viewer = $this->getViewer();

	PhabricatorPolicyFilter::requireCapability(
	$viewer,
	$configuration,
	PhabricatorPolicyCapability::CAN_EDIT);

	$object = $this->getProfileObject();
	$controller = $this->getController();

	return id(new PhabricatorProfilePanelEditEngine())
	->setIsBuiltin(true)
	->setPanelEngine($this)
	->setProfileObject($object)
	->setNewPanelConfiguration($configuration)
	->setController($controller)
	->buildResponse();
	}

	private function buildPanelHideContent(
	PhabricatorProfilePanelConfiguration $configuration) {

	$controller = $this->getController();
	$request = $controller->getRequest();
	$viewer = $this->getViewer();

	PhabricatorPolicyFilter::requireCapability(
	$viewer,
	$configuration,
	PhabricatorPolicyCapability::CAN_EDIT);

	if (!$configuration->canHidePanel()) {
	return $controller->newDialog()
	->setTitle(pht('Mandatory Panel'))
	->appendParagraph(
	pht('This panel is very important, and can not be disabled.'))
	->addCancelButton($this->getConfigureURI());
	}

	if ($configuration->getBuiltinKey() === null) {
	$new_value = null;

	$title = pht('Delete Menu Item');
	$body = pht('Delete this menu item?');
	$button = pht('Delete Menu Item');
	} else if ($configuration->isDisabled()) {
	$new_value = PhabricatorProfilePanelConfiguration::VISIBILITY_VISIBLE;

	$title = pht('Enable Menu Item');
	$body = pht(
	'Enable this menu item? It will appear in the menu again.');
	$button = pht('Enable Menu Item');
	} else {
	$new_value = PhabricatorProfilePanelConfiguration::VISIBILITY_DISABLED;

	$title = pht('Disable Menu Item');
	$body = pht(
	'Disable this menu item? It will no longer appear in the menu, but '.
	'you can re-enable it later.');
	$button = pht('Disable Menu Item');
	}

	$v_visibility = $configuration->getVisibility();
	if ($request->isFormPost()) {
	if ($new_value === null) {
	$configuration->delete();
	} else {
	$type_visibility =
	PhabricatorProfilePanelConfigurationTransaction::TYPE_VISIBILITY;

	$xactions = array();

	$xactions[] = id(new PhabricatorProfilePanelConfigurationTransaction())
	->setTransactionType($type_visibility)
	->setNewValue($new_value);

	$editor = id(new PhabricatorProfilePanelEditor())
	->setContentSourceFromRequest($request)
	->setActor($viewer)
	->setContinueOnMissingFields(true)
	->setContinueOnNoEffect(true)
	->applyTransactions($configuration, $xactions);
	}

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

	return $controller->newDialog()
	->setTitle($title)
	->appendParagraph($body)
	->addCancelButton($this->getConfigureURI())
	->addSubmitButton($button);
	}

	private function buildPanelDefaultContent(
	PhabricatorProfilePanelConfiguration $configuration,
	array $panels) {

	$controller = $this->getController();
	$request = $controller->getRequest();
	$viewer = $this->getViewer();

	PhabricatorPolicyFilter::requireCapability(
	$viewer,
	$configuration,
	PhabricatorPolicyCapability::CAN_EDIT);

	$done_uri = $this->getConfigureURI();

	if (!$configuration->canMakeDefault()) {
	return $controller->newDialog()
	->setTitle(pht('Not Defaultable'))
	->appendParagraph(
	pht(
	'This item can not be set as the default item. This is usually '.
	'because the item has no page of its own, or links to an '.
	'external page.'))
	->addCancelButton($done_uri);
	}

	if ($configuration->isDefault()) {
	return $controller->newDialog()
	->setTitle(pht('Already Default'))
	->appendParagraph(
	pht(
	'This item is already set as the default item for this menu.'))
	->addCancelButton($done_uri);
	}

	if ($request->isFormPost()) {
	$key = $configuration->getID();
	if (!$key) {
	$key = $configuration->getBuiltinKey();
	}

	$this->adjustDefault($key);

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

	return $controller->newDialog()
	->setTitle(pht('Make Default'))
	->appendParagraph(
	pht(
	'Set this item as the default for this menu? Users arriving on '.
	'this page will be shown the content of this item by default.'))
	->addCancelButton($done_uri)
	->addSubmitButton(pht('Make Default'));
	}

	protected function newPanel() {
	return PhabricatorProfilePanelConfiguration::initializeNewBuiltin();
	}

	public function adjustDefault($key) {
	$controller = $this->getController();
	$request = $controller->getRequest();
	$viewer = $request->getViewer();

	$panels = $this->loadPanels();

	// To adjust the default panel, we first change any existing panels that
	// are marked as defaults to "visible", then make the new default panel
	// the default.

	$default = array();
	$visible = array();

	foreach ($panels as $panel) {
	$builtin_key = $panel->getBuiltinKey();
	$id = $panel->getID();

	$is_target =
	(($builtin_key !== null) && ($builtin_key === $key)) \|\|
	(($id !== null) && ((int)$id === (int)$key));

	if ($is_target) {
	if (!$panel->isDefault()) {
	$default[] = $panel;
	}
	} else {
	if ($panel->isDefault()) {
	$visible[] = $panel;
	}
	}
	}

	$type_visibility =
	PhabricatorProfilePanelConfigurationTransaction::TYPE_VISIBILITY;

	$v_visible = PhabricatorProfilePanelConfiguration::VISIBILITY_VISIBLE;
	$v_default = PhabricatorProfilePanelConfiguration::VISIBILITY_DEFAULT;

	$apply = array(
	array($v_visible, $visible),
	array($v_default, $default),
	);

	foreach ($apply as $group) {
	list($value, $panels) = $group;
	foreach ($panels as $panel) {
	$xactions = array();

	$xactions[] = id(new PhabricatorProfilePanelConfigurationTransaction())
	->setTransactionType($type_visibility)
	->setNewValue($value);

	$editor = id(new PhabricatorProfilePanelEditor())
	->setContentSourceFromRequest($request)
	->setActor($viewer)
	->setContinueOnMissingFields(true)
	->setContinueOnNoEffect(true)
	->applyTransactions($panel, $xactions);
	}
	}

	return $this;
	}

	}
	diff --git a/src/view/form/control/PhabricatorRemarkupControl.php b/src/view/form/control/PhabricatorRemarkupControl.php
	index eeec4971da..f32e58fb29 100644
	--- a/src/view/form/control/PhabricatorRemarkupControl.php
	+++ b/src/view/form/control/PhabricatorRemarkupControl.php
	@@ -1,290 +1,289 @@
	<?php

	final class PhabricatorRemarkupControl extends AphrontFormTextAreaControl {
	private $disableMacro = false;

	private $disableFullScreen = false;

	public function setDisableMacros($disable) {
	$this->disableMacro = $disable;
	return $this;
	}

	public function setDisableFullScreen($disable) {
	$this->disableFullScreen = $disable;
	return $this;
	}

	protected function renderInput() {
	$id = $this->getID();
	if (!$id) {
	$id = celerity_generate_unique_node_id();
	$this->setID($id);
	}

	$viewer = $this->getUser();
	if (!$viewer) {
	throw new PhutilInvalidStateException('setUser');
	}

	// We need to have this if previews render images, since Ajax can not
	// currently ship JS or CSS.
	require_celerity_resource('lightbox-attachment-css');

	if (!$this->getDisabled()) {
	Javelin::initBehavior(
	'aphront-drag-and-drop-textarea',
	array(
	'target' => $id,
	'activatedClass' => 'aphront-textarea-drag-and-drop',
	'uri' => '/file/dropupload/',
	'chunkThreshold' => PhabricatorFileStorageEngine::getChunkThreshold(),
	));
	}

	$root_id = celerity_generate_unique_node_id();

	$user_datasource = new PhabricatorPeopleDatasource();
	$proj_datasource = id(new PhabricatorProjectDatasource())
	->setParameters(
	array(
	'autocomplete' => 1,
	));

	Javelin::initBehavior(
	'phabricator-remarkup-assist',
	array(
	'pht' => array(
	'bold text' => pht('bold text'),
	'italic text' => pht('italic text'),
	'monospaced text' => pht('monospaced text'),
	'List Item' => pht('List Item'),
	'Quoted Text' => pht('Quoted Text'),
	'data' => pht('data'),
	'name' => pht('name'),
	'URL' => pht('URL'),
	),
	'disabled' => $this->getDisabled(),
	'rootID' => $root_id,
	'autocompleteMap' => (object)array(
	64 => array( // "@"
	'datasourceURI' => $user_datasource->getDatasourceURI(),
	'headerIcon' => 'fa-user',
	'headerText' => pht('Find User:'),
	'hintText' => $user_datasource->getPlaceholderText(),
	),
	35 => array( // "#"
	'datasourceURI' => $proj_datasource->getDatasourceURI(),
	'headerIcon' => 'fa-briefcase',
	'headerText' => pht('Find Project:'),
	'hintText' => $proj_datasource->getPlaceholderText(),
	),
	),
	));
	Javelin::initBehavior('phabricator-tooltips', array());

	$actions = array(
	'fa-bold' => array(
	'tip' => pht('Bold'),
	'nodevice' => true,
	),
	'fa-italic' => array(
	'tip' => pht('Italics'),
	'nodevice' => true,
	),
	'fa-text-width' => array(
	'tip' => pht('Monospaced'),
	'nodevice' => true,
	),
	'fa-link' => array(
	'tip' => pht('Link'),
	'nodevice' => true,
	),
	array(
	'spacer' => true,
	'nodevice' => true,
	),
	'fa-list-ul' => array(
	'tip' => pht('Bulleted List'),
	'nodevice' => true,
	),
	'fa-list-ol' => array(
	'tip' => pht('Numbered List'),
	'nodevice' => true,
	),
	'fa-code' => array(
	'tip' => pht('Code Block'),
	'nodevice' => true,
	),
	'fa-quote-right' => array(
	'tip' => pht('Quote'),
	'nodevice' => true,
	),
	'fa-table' => array(
	'tip' => pht('Table'),
	'nodevice' => true,
	),
	'fa-cloud-upload' => array(
	'tip' => pht('Upload File'),
	),
	);

	$can_use_macros =
	(!$this->disableMacro) &&
	(function_exists('imagettftext'));

	if ($can_use_macros) {
	$can_use_macros = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorMacroApplication',
	$viewer);
	}

	if ($can_use_macros) {
	$actions[] = array(
	'spacer' => true,
	);
	$actions['fa-meh-o'] = array(
	'tip' => pht('Meme'),
	);
	}

	$actions['fa-eye'] = array(
	'tip' => pht('Preview'),
	'align' => 'right',
	);

	$actions[] = array(
	'spacer' => true,
	'align' => 'right',
	);

	$actions['fa-life-bouy'] = array(
	'tip' => pht('Help'),
	'align' => 'right',
	'href' => PhabricatorEnv::getDoclink('Remarkup Reference'),
	);


	if (!$this->disableFullScreen) {
	$actions[] = array(
	'spacer' => true,
	'align' => 'right',
	);

	$actions['fa-arrows-alt'] = array(
	'tip' => pht('Fullscreen Mode'),
	'align' => 'right',
	);
	}

	$buttons = array();
	foreach ($actions as $action => $spec) {

	$classes = array();

	if (idx($spec, 'align') == 'right') {
	$classes[] = 'remarkup-assist-right';
	}

	if (idx($spec, 'nodevice')) {
	$classes[] = 'remarkup-assist-nodevice';
	}

	if (idx($spec, 'spacer')) {
	$classes[] = 'remarkup-assist-separator';
	$buttons[] = phutil_tag(
	'span',
	array(
	'class' => implode(' ', $classes),
	),
	'');
	continue;
	} else {
	$classes[] = 'remarkup-assist-button';
	}

	$href = idx($spec, 'href', '#');
	if ($href == '#') {
	$meta = array('action' => $action);
	$mustcapture = true;
	$target = null;
	} else {
	$meta = array();
	$mustcapture = null;
	$target = '_blank';
	}

	$content = null;

	$tip = idx($spec, 'tip');
	if ($tip) {
	$meta['tip'] = $tip;
	$content = javelin_tag(
	'span',
	array(
	'aural' => true,
	),
	$tip);
	}

	$sigils = array();
	$sigils[] = 'remarkup-assist';
	if (!$this->getDisabled()) {
	$sigils[] = 'has-tooltip';
	}

	$buttons[] = javelin_tag(
	'a',
	array(
	'class' => implode(' ', $classes),
	'href' => $href,
	'sigil' => implode(' ', $sigils),
	'meta' => $meta,
	'mustcapture' => $mustcapture,
	'target' => $target,
	'tabindex' => -1,
	),
	phutil_tag(
	'div',
	array(
	'class' =>
	'remarkup-assist phui-icon-view phui-font-fa bluegrey '.$action,
	),
	$content));
	}

	$buttons = phutil_tag(
	'div',
	array(
	'class' => 'remarkup-assist-bar',
	),
	$buttons);

	- $monospaced_textareas = null;
	- $monospaced_textareas_class = null;
	-
	- $monospaced_textareas = $viewer
	- ->loadPreferences()
	- ->getPreference(
	- PhabricatorUserPreferences::PREFERENCE_MONOSPACED_TEXTAREAS);
	- if ($monospaced_textareas == 'enabled') {
	+ $use_monospaced = $viewer->compareUserSetting(
	+ PhabricatorMonospacedTextareasSetting::SETTINGKEY,
	+ PhabricatorMonospacedTextareasSetting::VALUE_TEXT_MONOSPACED);
	+
	+ if ($use_monospaced) {
	$monospaced_textareas_class = 'PhabricatorMonospaced';
	+ } else {
	+ $monospaced_textareas_class = null;
	}

	$this->setCustomClass(
	'remarkup-assist-textarea '.$monospaced_textareas_class);

	return javelin_tag(
	'div',
	array(
	'sigil' => 'remarkup-assist-control',
	'class' => $this->getDisabled() ? 'disabled-control' : null,
	'id' => $root_id,
	),
	array(
	$buttons,
	parent::renderInput(),
	));
	}

	}
	diff --git a/src/view/page/PhabricatorStandardPageView.php b/src/view/page/PhabricatorStandardPageView.php
	index e859163272..e2d373ab5a 100644
	--- a/src/view/page/PhabricatorStandardPageView.php
	+++ b/src/view/page/PhabricatorStandardPageView.php
	@@ -1,873 +1,872 @@
	<?php

	/**
	* This is a standard Phabricator page with menus, Javelin, DarkConsole, and
	* basic styles.
	*/
	final class PhabricatorStandardPageView extends PhabricatorBarePageView
	implements AphrontResponseProducerInterface {

	private $baseURI;
	private $applicationName;
	private $glyph;
	private $menuContent;
	private $showChrome = true;
	private $classes = array();
	private $disableConsole;
	private $pageObjects = array();
	private $applicationMenu;
	private $showFooter = true;
	private $showDurableColumn = true;
	private $quicksandConfig = array();
	private $crumbs;
	private $navigation;

	public function setShowFooter($show_footer) {
	$this->showFooter = $show_footer;
	return $this;
	}

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

	public function setApplicationMenu($application_menu) {
	// NOTE: For now, this can either be a PHUIListView or a
	// PHUIApplicationMenuView.

	$this->applicationMenu = $application_menu;
	return $this;
	}

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

	public function setApplicationName($application_name) {
	$this->applicationName = $application_name;
	return $this;
	}

	public function setDisableConsole($disable) {
	$this->disableConsole = $disable;
	return $this;
	}

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

	public function setBaseURI($base_uri) {
	$this->baseURI = $base_uri;
	return $this;
	}

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

	public function setShowChrome($show_chrome) {
	$this->showChrome = $show_chrome;
	return $this;
	}

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

	public function addClass($class) {
	$this->classes[] = $class;
	return $this;
	}

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

	public function setShowDurableColumn($show) {
	$this->showDurableColumn = $show;
	return $this;
	}

	public function getShowDurableColumn() {
	$request = $this->getRequest();
	if (!$request) {
	return false;
	}

	$viewer = $request->getUser();
	if (!$viewer->isLoggedIn()) {
	return false;
	}

	$conpherence_installed = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorConpherenceApplication',
	$viewer);
	if (!$conpherence_installed) {
	return false;
	}

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

	return true;
	}

	private function isQuicksandBlacklistURI() {
	$request = $this->getRequest();
	if (!$request) {
	return false;
	}

	$patterns = $this->getQuicksandURIPatternBlacklist();
	$path = $request->getRequestURI()->getPath();
	foreach ($patterns as $pattern) {
	if (preg_match('(^'.$pattern.'$)', $path)) {
	return true;
	}
	}
	return false;
	}

	public function getDurableColumnVisible() {
	$column_key = PhabricatorUserPreferences::PREFERENCE_CONPHERENCE_COLUMN;
	- return (bool)$this->getUserPreference($column_key, 0);
	+ return (bool)$this->getUserPreference($column_key, false);
	}

	public function addQuicksandConfig(array $config) {
	$this->quicksandConfig = $config + $this->quicksandConfig;
	return $this;
	}

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

	public function setCrumbs(PHUICrumbsView $crumbs) {
	$this->crumbs = $crumbs;
	return $this;
	}

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

	public function setNavigation(AphrontSideNavFilterView $navigation) {
	$this->navigation = $navigation;
	return $this;
	}

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

	public function getTitle() {
	- $glyph_key = PhabricatorUserPreferences::PREFERENCE_TITLES;
	- if ($this->getUserPreference($glyph_key) == 'text') {
	- $use_glyph = false;
	- } else {
	- $use_glyph = true;
	- }
	+ $glyph_key = PhabricatorTitleGlyphsSetting::SETTINGKEY;
	+ $glyph_on = PhabricatorTitleGlyphsSetting::VALUE_TITLE_GLYPHS;
	+ $glyph_setting = $this->getUserPreference($glyph_key, $glyph_on);
	+
	+ $use_glyph = ($glyph_setting == $glyph_on);

	$title = parent::getTitle();

	$prefix = null;
	if ($use_glyph) {
	$prefix = $this->getGlyph();
	} else {
	$application_name = $this->getApplicationName();
	if (strlen($application_name)) {
	$prefix = '['.$application_name.']';
	}
	}

	if (strlen($prefix)) {
	$title = $prefix.' '.$title;
	}

	return $title;
	}


	protected function willRenderPage() {
	parent::willRenderPage();

	if (!$this->getRequest()) {
	throw new Exception(
	pht(
	'You must set the %s to render a %s.',
	'Request',
	__CLASS__));
	}

	$console = $this->getConsole();

	require_celerity_resource('phabricator-core-css');
	require_celerity_resource('phabricator-zindex-css');
	require_celerity_resource('phui-button-css');
	require_celerity_resource('phui-spacing-css');
	require_celerity_resource('phui-form-css');
	require_celerity_resource('phabricator-standard-page-view');
	require_celerity_resource('conpherence-durable-column-view');
	require_celerity_resource('font-lato');
	require_celerity_resource('font-aleo');

	Javelin::initBehavior('workflow', array());

	$request = $this->getRequest();
	$user = null;
	if ($request) {
	$user = $request->getUser();
	}

	if ($user) {
	if ($user->isLoggedIn()) {
	$offset = $user->getTimeZoneOffset();

	$preferences = $user->loadPreferences();
	$ignore_key = PhabricatorUserPreferences::PREFERENCE_IGNORE_OFFSET;

	$ignore = $preferences->getPreference($ignore_key);
	if (!strlen($ignore)) {
	$ignore = null;
	}

	Javelin::initBehavior(
	'detect-timezone',
	array(
	'offset' => $offset,
	'uri' => '/settings/timezone/',
	'message' => pht(
	'Your browser timezone setting differs from the timezone '.
	'setting in your profile, click to reconcile.'),
	'ignoreKey' => $ignore_key,
	'ignore' => $ignore,
	));
	}

	$default_img_uri =
	celerity_get_resource_uri(
	'rsrc/image/icon/fatcow/document_black.png');
	$download_form = phabricator_form(
	$user,
	array(
	'action' => '#',
	'method' => 'POST',
	'class' => 'lightbox-download-form',
	'sigil' => 'download',
	),
	phutil_tag(
	'button',
	array(),
	pht('Download')));

	Javelin::initBehavior(
	'lightbox-attachments',
	array(
	'defaultImageUri' => $default_img_uri,
	'downloadForm' => $download_form,
	));
	}

	Javelin::initBehavior('aphront-form-disable-on-submit');
	Javelin::initBehavior('toggle-class', array());
	Javelin::initBehavior('history-install');
	Javelin::initBehavior('phabricator-gesture');

	$current_token = null;
	if ($user) {
	$current_token = $user->getCSRFToken();
	}

	Javelin::initBehavior(
	'refresh-csrf',
	array(
	'tokenName' => AphrontRequest::getCSRFTokenName(),
	'header' => AphrontRequest::getCSRFHeaderName(),
	'viaHeader' => AphrontRequest::getViaHeaderName(),
	'current' => $current_token,
	));

	Javelin::initBehavior('device');

	Javelin::initBehavior(
	'high-security-warning',
	$this->getHighSecurityWarningConfig());

	if (PhabricatorEnv::isReadOnly()) {
	Javelin::initBehavior(
	'read-only-warning',
	array(
	'message' => PhabricatorEnv::getReadOnlyMessage(),
	'uri' => PhabricatorEnv::getReadOnlyURI(),
	));
	}

	if ($console) {
	require_celerity_resource('aphront-dark-console-css');

	$headers = array();
	if (DarkConsoleXHProfPluginAPI::isProfilerStarted()) {
	$headers[DarkConsoleXHProfPluginAPI::getProfilerHeader()] = 'page';
	}
	if (DarkConsoleServicesPlugin::isQueryAnalyzerRequested()) {
	$headers[DarkConsoleServicesPlugin::getQueryAnalyzerHeader()] = true;
	}

	Javelin::initBehavior(
	'dark-console',
	$this->getConsoleConfig());

	// Change this to initBehavior when there is some behavior to initialize
	require_celerity_resource('javelin-behavior-error-log');
	}

	if ($user) {
	$viewer = $user;
	} else {
	$viewer = new PhabricatorUser();
	}

	$menu = id(new PhabricatorMainMenuView())
	->setUser($viewer);

	if ($this->getController()) {
	$menu->setController($this->getController());
	}

	$application_menu = $this->getApplicationMenu();
	if ($application_menu) {
	if ($application_menu instanceof PHUIApplicationMenuView) {
	$crumbs = $this->getCrumbs();
	if ($crumbs) {
	$application_menu->setCrumbs($crumbs);
	}

	$application_menu = $application_menu->buildListView();
	}

	$menu->setApplicationMenu($application_menu);
	}

	$this->menuContent = $menu->render();
	}


	protected function getHead() {
	$monospaced = null;

	$request = $this->getRequest();
	if ($request) {
	$user = $request->getUser();
	if ($user) {
	- $monospaced = $user->loadPreferences()->getPreference(
	- PhabricatorUserPreferences::PREFERENCE_MONOSPACED);
	+ $monospaced = $user->getUserSetting(
	+ PhabricatorMonospacedFontSetting::SETTINGKEY);
	}
	}

	$response = CelerityAPI::getStaticResourceResponse();

	$font_css = null;
	if (!empty($monospaced)) {
	// We can't print this normally because escaping quotation marks will
	// break the CSS. Instead, filter it strictly and then mark it as safe.
	$monospaced = new PhutilSafeHTML(
	PhabricatorMonospacedFontSetting::filterMonospacedCSSRule(
	$monospaced));

	$font_css = hsprintf(
	'<style type="text/css">'.
	'.PhabricatorMonospaced, '.
	'.phabricator-remarkup .remarkup-code-block '.
	'.remarkup-code { font: %s !important; } '.
	'</style>',
	$monospaced);
	}

	return hsprintf(
	'%s%s%s',
	parent::getHead(),
	$font_css,
	$response->renderSingleResource('javelin-magical-init', 'phabricator'));
	}

	public function setGlyph($glyph) {
	$this->glyph = $glyph;
	return $this;
	}

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

	protected function willSendResponse($response) {
	$request = $this->getRequest();
	$response = parent::willSendResponse($response);

	$console = $request->getApplicationConfiguration()->getConsole();

	if ($console) {
	$response = PhutilSafeHTML::applyFunction(
	'str_replace',
	hsprintf('<darkconsole />'),
	$console->render($request),
	$response);
	}

	return $response;
	}

	protected function getBody() {
	$user = null;
	$request = $this->getRequest();
	if ($request) {
	$user = $request->getUser();
	}

	$header_chrome = null;
	if ($this->getShowChrome()) {
	$header_chrome = $this->menuContent;
	}

	$classes = array();
	$classes[] = 'main-page-frame';
	$developer_warning = null;
	if (PhabricatorEnv::getEnvConfig('phabricator.developer-mode') &&
	DarkConsoleErrorLogPluginAPI::getErrors()) {
	$developer_warning = phutil_tag_div(
	'aphront-developer-error-callout',
	pht(
	'This page raised PHP errors. Find them in DarkConsole '.
	'or the error log.'));
	}

	// Render the "you have unresolved setup issues..." warning.
	$setup_warning = null;
	if ($user && $user->getIsAdmin()) {
	$open = PhabricatorSetupCheck::getOpenSetupIssueKeys();
	if ($open) {
	$classes[] = 'page-has-warning';
	$setup_warning = phutil_tag_div(
	'setup-warning-callout',
	phutil_tag(
	'a',
	array(
	'href' => '/config/issue/',
	'title' => implode(', ', $open),
	),
	pht('You have %d unresolved setup issue(s)...', count($open))));
	}
	}

	$main_page = phutil_tag(
	'div',
	array(
	'id' => 'phabricator-standard-page',
	'class' => 'phabricator-standard-page',
	),
	array(
	$developer_warning,
	$header_chrome,
	$setup_warning,
	phutil_tag(
	'div',
	array(
	'id' => 'phabricator-standard-page-body',
	'class' => 'phabricator-standard-page-body',
	),
	$this->renderPageBodyContent()),
	));

	$durable_column = null;
	if ($this->getShowDurableColumn()) {
	$is_visible = $this->getDurableColumnVisible();
	$durable_column = id(new ConpherenceDurableColumnView())
	->setSelectedConpherence(null)
	->setUser($user)
	->setQuicksandConfig($this->buildQuicksandConfig())
	->setVisible($is_visible)
	->setInitialLoad(true);
	}

	Javelin::initBehavior('quicksand-blacklist', array(
	'patterns' => $this->getQuicksandURIPatternBlacklist(),
	));

	return phutil_tag(
	'div',
	array(
	'class' => implode(' ', $classes),
	),
	array(
	$main_page,
	$durable_column,
	));
	}

	private function renderPageBodyContent() {
	$console = $this->getConsole();

	$body = parent::getBody();

	$footer = $this->renderFooter();

	$nav = $this->getNavigation();
	if ($nav) {
	$crumbs = $this->getCrumbs();
	if ($crumbs) {
	$nav->setCrumbs($crumbs);
	}
	$nav->appendChild($body);
	$nav->appendFooter($footer);
	$content = phutil_implode_html('', array($nav->render()));
	} else {
	$content = array();

	$crumbs = $this->getCrumbs();
	if ($crumbs) {
	$content[] = $crumbs;
	}

	$content[] = $body;
	$content[] = $footer;

	$content = phutil_implode_html('', $content);
	}

	return array(
	($console ? hsprintf('<darkconsole />') : null),
	$content,
	);
	}

	protected function getTail() {
	$request = $this->getRequest();
	$user = $request->getUser();

	$tail = array(
	parent::getTail(),
	);

	$response = CelerityAPI::getStaticResourceResponse();

	if ($request->isHTTPS()) {
	$with_protocol = 'https';
	} else {
	$with_protocol = 'http';
	}

	$servers = PhabricatorNotificationServerRef::getEnabledClientServers(
	$with_protocol);

	if ($servers) {
	if ($user && $user->isLoggedIn()) {
	// TODO: We could tell the browser about all the servers and let it
	// do random reconnects to improve reliability.
	shuffle($servers);
	$server = head($servers);

	$client_uri = $server->getWebsocketURI();

	Javelin::initBehavior(
	'aphlict-listen',
	array(
	'websocketURI' => (string)$client_uri,
	) + $this->buildAphlictListenConfigData());
	}
	}

	$tail[] = $response->renderHTMLFooter();

	return $tail;
	}

	protected function getBodyClasses() {
	$classes = array();

	if (!$this->getShowChrome()) {
	$classes[] = 'phabricator-chromeless-page';
	}

	$agent = AphrontRequest::getHTTPHeader('User-Agent');

	// Try to guess the device resolution based on UA strings to avoid a flash
	// of incorrectly-styled content.
	$device_guess = 'device-desktop';
	if (preg_match('@iPhone\|iPod\|(Android.Chrome/[.0-9] Mobile)@', $agent)) {
	$device_guess = 'device-phone device';
	} else if (preg_match('@iPad\|(Android.*Chrome/)@', $agent)) {
	$device_guess = 'device-tablet device';
	}

	$classes[] = $device_guess;

	if (preg_match('@Windows@', $agent)) {
	$classes[] = 'platform-windows';
	} else if (preg_match('@Macintosh@', $agent)) {
	$classes[] = 'platform-mac';
	} else if (preg_match('@X11@', $agent)) {
	$classes[] = 'platform-linux';
	}

	if ($this->getRequest()->getStr('__print__')) {
	$classes[] = 'printable';
	}

	if ($this->getRequest()->getStr('__aural__')) {
	$classes[] = 'audible';
	}

	$classes[] = 'phui-theme-'.PhabricatorEnv::getEnvConfig('ui.header-color');
	foreach ($this->classes as $class) {
	$classes[] = $class;
	}

	return implode(' ', $classes);
	}

	private function getConsole() {
	if ($this->disableConsole) {
	return null;
	}
	return $this->getRequest()->getApplicationConfiguration()->getConsole();
	}

	private function getConsoleConfig() {
	$user = $this->getRequest()->getUser();

	$headers = array();
	if (DarkConsoleXHProfPluginAPI::isProfilerStarted()) {
	$headers[DarkConsoleXHProfPluginAPI::getProfilerHeader()] = 'page';
	}
	if (DarkConsoleServicesPlugin::isQueryAnalyzerRequested()) {
	$headers[DarkConsoleServicesPlugin::getQueryAnalyzerHeader()] = true;
	}

	return array(
	// NOTE: We use a generic label here to prevent input reflection
	// and mitigate compression attacks like BREACH. See discussion in
	// T3684.
	'uri' => pht('Main Request'),
	'selected' => $user ? $user->getConsoleTab() : null,
	'visible' => $user ? (int)$user->getConsoleVisible() : true,
	'headers' => $headers,
	);
	}

	private function getHighSecurityWarningConfig() {
	$user = $this->getRequest()->getUser();

	$show = false;
	if ($user->hasSession()) {
	$hisec = ($user->getSession()->getHighSecurityUntil() - time());
	if ($hisec > 0) {
	$show = true;
	}
	}

	return array(
	'show' => $show,
	'uri' => '/auth/session/downgrade/',
	'message' => pht(
	'Your session is in high security mode. When you '.
	'finish using it, click here to leave.'),
	);
	}

	private function renderFooter() {
	if (!$this->getShowChrome()) {
	return null;
	}

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

	$items = PhabricatorEnv::getEnvConfig('ui.footer-items');
	if (!$items) {
	return null;
	}

	$foot = array();
	foreach ($items as $item) {
	$name = idx($item, 'name', pht('Unnamed Footer Item'));

	$href = idx($item, 'href');
	if (!PhabricatorEnv::isValidURIForLink($href)) {
	$href = null;
	}

	if ($href !== null) {
	$tag = 'a';
	} else {
	$tag = 'span';
	}

	$foot[] = phutil_tag(
	$tag,
	array(
	'href' => $href,
	),
	$name);
	}
	$foot = phutil_implode_html(" \xC2\xB7 ", $foot);

	return phutil_tag(
	'div',
	array(
	'class' => 'phabricator-standard-page-footer grouped',
	),
	$foot);
	}

	public function renderForQuicksand() {
	parent::willRenderPage();
	$response = $this->renderPageBodyContent();
	$response = $this->willSendResponse($response);

	$extra_config = $this->getQuicksandConfig();

	return array(
	'content' => hsprintf('%s', $response),
	) + $this->buildQuicksandConfig()
	+ $extra_config;
	}

	private function buildQuicksandConfig() {
	$viewer = $this->getRequest()->getUser();
	$controller = $this->getController();

	$dropdown_query = id(new AphlictDropdownDataQuery())
	->setViewer($viewer);
	$dropdown_query->execute();

	$rendered_dropdowns = array();
	$applications = array(
	'PhabricatorHelpApplication',
	);
	foreach ($applications as $application_class) {
	if (!PhabricatorApplication::isClassInstalledForViewer(
	$application_class,
	$viewer)) {
	continue;
	}
	$application = PhabricatorApplication::getByClass($application_class);
	$rendered_dropdowns[$application_class] =
	$application->buildMainMenuExtraNodes(
	$viewer,
	$controller);
	}

	$hisec_warning_config = $this->getHighSecurityWarningConfig();

	$console_config = null;
	$console = $this->getConsole();
	if ($console) {
	$console_config = $this->getConsoleConfig();
	}

	$upload_enabled = false;
	if ($controller) {
	$upload_enabled = $controller->isGlobalDragAndDropUploadEnabled();
	}

	$application_class = null;
	$application_search_icon = null;
	$controller = $this->getController();
	if ($controller) {
	$application = $controller->getCurrentApplication();
	if ($application) {
	$application_class = get_class($application);
	if ($application->getApplicationSearchDocumentTypes()) {
	$application_search_icon = $application->getIcon();
	}
	}
	}

	return array(
	'title' => $this->getTitle(),
	'aphlictDropdownData' => array(
	$dropdown_query->getNotificationData(),
	$dropdown_query->getConpherenceData(),
	),
	'globalDragAndDrop' => $upload_enabled,
	'aphlictDropdowns' => $rendered_dropdowns,
	'hisecWarningConfig' => $hisec_warning_config,
	'consoleConfig' => $console_config,
	'applicationClass' => $application_class,
	'applicationSearchIcon' => $application_search_icon,
	) + $this->buildAphlictListenConfigData();
	}

	private function buildAphlictListenConfigData() {
	$user = $this->getRequest()->getUser();
	$subscriptions = $this->pageObjects;
	$subscriptions[] = $user->getPHID();

	return array(
	'pageObjects' => array_fill_keys($this->pageObjects, true),
	'subscriptions' => $subscriptions,
	);
	}

	private function getQuicksandURIPatternBlacklist() {
	$applications = PhabricatorApplication::getAllApplications();

	$blacklist = array();
	foreach ($applications as $application) {
	$blacklist[] = $application->getQuicksandURIPatternBlacklist();
	}

	return array_mergev($blacklist);
	}

	private function getUserPreference($key, $default = null) {
	$request = $this->getRequest();
	if (!$request) {
	return $default;
	}

	$user = $request->getUser();
	if (!$user) {
	return $default;
	}

	- return $user->loadPreferences()->getPreference($key, $default);
	+ return $user->getUserSetting($key);
	}

	public function produceAphrontResponse() {
	$controller = $this->getController();

	if (!$this->getApplicationMenu()) {
	$application_menu = $controller->buildApplicationMenu();
	if ($application_menu) {
	$this->setApplicationMenu($application_menu);
	}
	}

	$viewer = $this->getUser();
	if ($viewer && $viewer->getPHID()) {
	$object_phids = $this->pageObjects;
	foreach ($object_phids as $object_phid) {
	PhabricatorFeedStoryNotification::updateObjectNotificationViews(
	$viewer,
	$object_phid);
	}
	}

	if ($this->getRequest()->isQuicksand()) {
	$content = $this->renderForQuicksand();
	$response = id(new AphrontAjaxResponse())
	->setContent($content);
	} else {
	$content = $this->render();
	$response = id(new AphrontWebpageResponse())
	->setContent($content);
	}

	return $response;
	}

	}
	diff --git a/src/view/phui/calendar/PHUICalendarMonthView.php b/src/view/phui/calendar/PHUICalendarMonthView.php
	index 396947cdbe..f53ef72016 100644
	--- a/src/view/phui/calendar/PHUICalendarMonthView.php
	+++ b/src/view/phui/calendar/PHUICalendarMonthView.php
	@@ -1,597 +1,597 @@
	<?php

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

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

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

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

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

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

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

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

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

	public function render() {
	$viewer = $this->getViewer();

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

	$cell_lists = array();

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

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

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

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

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

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

	$max_daily = 15;
	$counter = 0;

	$list = id(new PHUICalendarListView())
	->setViewer($viewer)
	->setView('month');
	foreach ($all_day_events as $item) {
	if ($counter <= $max_daily) {
	$list->addEvent($item);
	}
	$counter++;
	}
	foreach ($list_events as $item) {
	if ($counter <= $max_daily) {
	$list->addEvent($item);
	}
	$counter++;
	}

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

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

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

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

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

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

	$header = $this->getDayNamesHeader();

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

	$warnings = $this->getQueryRangeWarning();

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

	}

	return $box;
	}

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

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

	return $max_count;
	}

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

	$viewer_is_invited = $list->getIsViewerInvitedOnList();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$sorted_weekday_names = array();

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

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

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

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

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

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

	$button_bar = new PHUIButtonBarView();

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

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

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

	}

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

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

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

	return $header;
	}

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

	$range_start_epoch = null;
	$range_end_epoch = null;

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

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

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

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

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

	return $errors;
	}

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

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

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

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

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

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

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

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

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

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

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

	$day_date = id(clone $first_month_day_date);

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

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

	$days = array();

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

	return $days;
	}

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

	return $today;
	}

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

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

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

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

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

	return array($week_start_date, $week_end_date);
	}

	private function getWeekStartAndEnd() {
	- $preferences = $this->getViewer()->loadPreferences();
	- $pref_week_start = PhabricatorUserPreferences::PREFERENCE_WEEK_START_DAY;
	+ $viewer = $this->getViewer();
	+ $week_key = PhabricatorUserPreferences::PREFERENCE_WEEK_START_DAY;

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

	return array($week_start, $week_end);
	}

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

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

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

	return $date;
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Mar 17, 3:01 AM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 72246
Default Alt Text: (317 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions