No OneTemporary
Actions

Size

87 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/people/query/PhabricatorPeopleQuery.php b/src/applications/people/query/PhabricatorPeopleQuery.php
	index 88e2437dbd..32ae31859b 100644
	--- a/src/applications/people/query/PhabricatorPeopleQuery.php
	+++ b/src/applications/people/query/PhabricatorPeopleQuery.php
	@@ -1,611 +1,628 @@
	<?php

	final class PhabricatorPeopleQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $usernames;
	private $realnames;
	private $emails;
	private $phids;
	private $ids;
	private $dateCreatedAfter;
	private $dateCreatedBefore;
	private $isAdmin;
	private $isSystemAgent;
	private $isMailingList;
	private $isDisabled;
	private $isApproved;
	private $nameLike;
	private $nameTokens;
	+ private $namePrefixes;

	private $needPrimaryEmail;
	private $needProfile;
	private $needProfileImage;
	private $needAvailability;
	private $needBadges;
	private $cacheKeys = array();

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

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

	public function withEmails(array $emails) {
	$this->emails = $emails;
	return $this;
	}

	public function withRealnames(array $realnames) {
	$this->realnames = $realnames;
	return $this;
	}

	public function withUsernames(array $usernames) {
	$this->usernames = $usernames;
	return $this;
	}

	public function withDateCreatedBefore($date_created_before) {
	$this->dateCreatedBefore = $date_created_before;
	return $this;
	}

	public function withDateCreatedAfter($date_created_after) {
	$this->dateCreatedAfter = $date_created_after;
	return $this;
	}

	public function withIsAdmin($admin) {
	$this->isAdmin = $admin;
	return $this;
	}

	public function withIsSystemAgent($system_agent) {
	$this->isSystemAgent = $system_agent;
	return $this;
	}

	public function withIsMailingList($mailing_list) {
	$this->isMailingList = $mailing_list;
	return $this;
	}

	public function withIsDisabled($disabled) {
	$this->isDisabled = $disabled;
	return $this;
	}

	public function withIsApproved($approved) {
	$this->isApproved = $approved;
	return $this;
	}

	public function withNameLike($like) {
	$this->nameLike = $like;
	return $this;
	}

	public function withNameTokens(array $tokens) {
	$this->nameTokens = array_values($tokens);
	return $this;
	}

	+ public function withNamePrefixes(array $prefixes) {
	+ $this->namePrefixes = $prefixes;
	+ return $this;
	+ }
	+
	public function needPrimaryEmail($need) {
	$this->needPrimaryEmail = $need;
	return $this;
	}

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

	public function needProfileImage($need) {
	$cache_key = PhabricatorUserProfileImageCacheType::KEY_URI;

	if ($need) {
	$this->cacheKeys[$cache_key] = true;
	} else {
	unset($this->cacheKeys[$cache_key]);
	}

	return $this;
	}

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

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

	public function needUserSettings($need) {
	$cache_key = PhabricatorUserPreferencesCacheType::KEY_PREFERENCES;

	if ($need) {
	$this->cacheKeys[$cache_key] = true;
	} else {
	unset($this->cacheKeys[$cache_key]);
	}

	return $this;
	}

	public function newResultObject() {
	return new PhabricatorUser();
	}

	protected function loadPage() {
	$table = new PhabricatorUser();
	$data = $this->loadStandardPageRows($table);

	if ($this->needPrimaryEmail) {
	$table->putInSet(new LiskDAOSet());
	}

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

	protected function didFilterPage(array $users) {
	if ($this->needProfile) {
	$user_list = mpull($users, null, 'getPHID');
	$profiles = new PhabricatorUserProfile();
	$profiles = $profiles->loadAllWhere(
	'userPHID IN (%Ls)',
	array_keys($user_list));

	$profiles = mpull($profiles, null, 'getUserPHID');
	foreach ($user_list as $user_phid => $user) {
	$profile = idx($profiles, $user_phid);

	if (!$profile) {
	$profile = PhabricatorUserProfile::initializeNewProfile($user);
	}

	$user->attachUserProfile($profile);
	}
	}

	if ($this->needBadges) {
	$awards = id(new PhabricatorBadgesAwardQuery())
	->setViewer($this->getViewer())
	->withRecipientPHIDs(mpull($users, 'getPHID'))
	->execute();

	$awards = mgroup($awards, 'getRecipientPHID');

	foreach ($users as $user) {
	$user_awards = idx($awards, $user->getPHID(), array());
	$badge_phids = mpull($user_awards, 'getBadgePHID');
	$user->attachBadgePHIDs($badge_phids);
	}
	}

	if ($this->needAvailability) {
	$rebuild = array();
	foreach ($users as $user) {
	$cache = $user->getAvailabilityCache();
	if ($cache !== null) {
	$user->attachAvailability($cache);
	} else {
	$rebuild[] = $user;
	}
	}

	if ($rebuild) {
	$this->rebuildAvailabilityCache($rebuild);
	}
	}

	$this->fillUserCaches($users);

	return $users;
	}

	protected function shouldGroupQueryResultRows() {
	if ($this->nameTokens) {
	return true;
	}

	return parent::shouldGroupQueryResultRows();
	}

	protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
	$joins = parent::buildJoinClauseParts($conn);

	if ($this->emails) {
	$email_table = new PhabricatorUserEmail();
	$joins[] = qsprintf(
	$conn,
	'JOIN %T email ON email.userPHID = user.PHID',
	$email_table->getTableName());
	}

	if ($this->nameTokens) {
	foreach ($this->nameTokens as $key => $token) {
	$token_table = 'token_'.$key;
	$joins[] = qsprintf(
	$conn,
	'JOIN %T %T ON %T.userID = user.id AND %T.token LIKE %>',
	PhabricatorUser::NAMETOKEN_TABLE,
	$token_table,
	$token_table,
	$token_table,
	$token);
	}
	}

	return $joins;
	}

	protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
	$where = parent::buildWhereClauseParts($conn);

	if ($this->usernames !== null) {
	$where[] = qsprintf(
	$conn,
	'user.userName IN (%Ls)',
	$this->usernames);
	}

	+ if ($this->namePrefixes) {
	+ $parts = array();
	+ foreach ($this->namePrefixes as $name_prefix) {
	+ $parts[] = qsprintf(
	+ $conn,
	+ 'user.username LIKE %>',
	+ $name_prefix);
	+ }
	+ $where[] = '('.implode(' OR ', $parts).')';
	+ }
	+
	if ($this->emails !== null) {
	$where[] = qsprintf(
	$conn,
	'email.address IN (%Ls)',
	$this->emails);
	}

	if ($this->realnames !== null) {
	$where[] = qsprintf(
	$conn,
	'user.realName IN (%Ls)',
	$this->realnames);
	}

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

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

	if ($this->dateCreatedAfter) {
	$where[] = qsprintf(
	$conn,
	'user.dateCreated >= %d',
	$this->dateCreatedAfter);
	}

	if ($this->dateCreatedBefore) {
	$where[] = qsprintf(
	$conn,
	'user.dateCreated <= %d',
	$this->dateCreatedBefore);
	}

	if ($this->isAdmin !== null) {
	$where[] = qsprintf(
	$conn,
	'user.isAdmin = %d',
	(int)$this->isAdmin);
	}

	if ($this->isDisabled !== null) {
	$where[] = qsprintf(
	$conn,
	'user.isDisabled = %d',
	(int)$this->isDisabled);
	}

	if ($this->isApproved !== null) {
	$where[] = qsprintf(
	$conn,
	'user.isApproved = %d',
	(int)$this->isApproved);
	}

	if ($this->isSystemAgent !== null) {
	$where[] = qsprintf(
	$conn,
	'user.isSystemAgent = %d',
	(int)$this->isSystemAgent);
	}

	if ($this->isMailingList !== null) {
	$where[] = qsprintf(
	$conn,
	'user.isMailingList = %d',
	(int)$this->isMailingList);
	}

	if (strlen($this->nameLike)) {
	$where[] = qsprintf(
	$conn,
	'user.username LIKE %~ OR user.realname LIKE %~',
	$this->nameLike,
	$this->nameLike);
	}

	return $where;
	}

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

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

	public function getOrderableColumns() {
	return parent::getOrderableColumns() + array(
	'username' => array(
	'table' => 'user',
	'column' => 'username',
	'type' => 'string',
	'reverse' => true,
	'unique' => true,
	),
	);
	}

	protected function getPagingValueMap($cursor, array $keys) {
	$user = $this->loadCursorObject($cursor);
	return array(
	'id' => $user->getID(),
	'username' => $user->getUsername(),
	);
	}

	private function rebuildAvailabilityCache(array $rebuild) {
	$rebuild = mpull($rebuild, null, 'getPHID');

	// Limit the window we look at because far-future events are largely
	// irrelevant and this makes the cache cheaper to build and allows it to
	// self-heal over time.
	$min_range = PhabricatorTime::getNow();
	$max_range = $min_range + phutil_units('72 hours in seconds');

	// NOTE: We don't need to generate ghosts here, because we only care if
	// the user is attending, and you can't attend a ghost event: RSVP'ing
	// to it creates a real event.

	$events = id(new PhabricatorCalendarEventQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withInvitedPHIDs(array_keys($rebuild))
	->withIsCancelled(false)
	->withDateRange($min_range, $max_range)
	->execute();

	// Group all the events by invited user. Only examine events that users
	// are actually attending.
	$map = array();
	$invitee_map = array();
	foreach ($events as $event) {
	foreach ($event->getInvitees() as $invitee) {
	if (!$invitee->isAttending()) {
	continue;
	}

	// If the user is set to "Available" for this event, don't consider it
	// when computin their away status.
	if (!$invitee->getDisplayAvailability($event)) {
	continue;
	}

	$invitee_phid = $invitee->getInviteePHID();
	if (!isset($rebuild[$invitee_phid])) {
	continue;
	}

	$map[$invitee_phid][] = $event;

	$event_phid = $event->getPHID();
	$invitee_map[$invitee_phid][$event_phid] = $invitee;
	}
	}

	// We need to load these users' timezone settings to figure out their
	// availability if they're attending all-day events.
	$this->needUserSettings(true);
	$this->fillUserCaches($rebuild);

	foreach ($rebuild as $phid => $user) {
	$events = idx($map, $phid, array());

	// We loaded events with the omnipotent user, but want to shift them
	// into the user's timezone before building the cache because they will
	// be unavailable during their own local day.
	foreach ($events as $event) {
	$event->applyViewerTimezone($user);
	}

	$cursor = $min_range;
	$next_event = null;
	if ($events) {
	// Find the next time when the user has no meetings. If we move forward
	// because of an event, we check again for events after that one ends.
	while (true) {
	foreach ($events as $event) {
	$from = $event->getStartDateTimeEpochForCache();
	$to = $event->getEndDateTimeEpoch();
	if (($from <= $cursor) && ($to > $cursor)) {
	$cursor = $to;
	if (!$next_event) {
	$next_event = $event;
	}
	continue 2;
	}
	}
	break;
	}
	}

	if ($cursor > $min_range) {
	$invitee = $invitee_map[$phid][$next_event->getPHID()];
	$availability_type = $invitee->getDisplayAvailability($next_event);
	$availability = array(
	'until' => $cursor,
	'eventPHID' => $event->getPHID(),
	'availability' => $availability_type,
	);

	// We only cache this availability until the end of the current event,
	// since the event PHID (and possibly the availability type) are only
	// valid for that long.

	// NOTE: This doesn't handle overlapping events with the greatest
	// possible care. In theory, if you're attenting multiple events
	// simultaneously we should accommodate that. However, it's complex
	// to compute, rare, and probably not confusing most of the time.

	$availability_ttl = $next_event->getStartDateTimeEpochForCache();
	} else {
	$availability = array(
	'until' => null,
	'eventPHID' => null,
	'availability' => null,
	);
	$availability_ttl = $max_range;
	}

	// Never TTL the cache to longer than the maximum range we examined.
	$availability_ttl = min($availability_ttl, $max_range);

	$user->writeAvailabilityCache($availability, $availability_ttl);
	$user->attachAvailability($availability);
	}
	}

	private function fillUserCaches(array $users) {
	if (!$this->cacheKeys) {
	return;
	}

	$user_map = mpull($users, null, 'getPHID');
	$keys = array_keys($this->cacheKeys);

	$hashes = array();
	foreach ($keys as $key) {
	$hashes[] = PhabricatorHash::digestForIndex($key);
	}

	$types = PhabricatorUserCacheType::getAllCacheTypes();

	// First, pull any available caches. If we wanted to be particularly clever
	// we could do this with JOINs in the main query.

	$cache_table = new PhabricatorUserCache();
	$cache_conn = $cache_table->establishConnection('r');

	$cache_data = queryfx_all(
	$cache_conn,
	'SELECT cacheKey, userPHID, cacheData, cacheType FROM %T
	WHERE cacheIndex IN (%Ls) AND userPHID IN (%Ls)',
	$cache_table->getTableName(),
	$hashes,
	array_keys($user_map));

	$skip_validation = array();

	// After we read caches from the database, discard any which have data that
	// invalid or out of date. This allows cache types to implement TTLs or
	// versions instead of or in addition to explicit cache clears.
	foreach ($cache_data as $row_key => $row) {
	$cache_type = $row['cacheType'];

	if (isset($skip_validation[$cache_type])) {
	continue;
	}

	if (empty($types[$cache_type])) {
	unset($cache_data[$row_key]);
	continue;
	}

	$type = $types[$cache_type];
	if (!$type->shouldValidateRawCacheData()) {
	$skip_validation[$cache_type] = true;
	continue;
	}

	$user = $user_map[$row['userPHID']];
	$raw_data = $row['cacheData'];
	if (!$type->isRawCacheDataValid($user, $row['cacheKey'], $raw_data)) {
	unset($cache_data[$row_key]);
	continue;
	}
	}

	$need = array();

	$cache_data = igroup($cache_data, 'userPHID');
	foreach ($user_map as $user_phid => $user) {
	$raw_rows = idx($cache_data, $user_phid, array());
	$raw_data = ipull($raw_rows, 'cacheData', 'cacheKey');

	foreach ($keys as $key) {
	if (isset($raw_data[$key]) \|\| array_key_exists($key, $raw_data)) {
	continue;
	}
	$need[$key][$user_phid] = $user;
	}

	$user->attachRawCacheData($raw_data);
	}

	// If we missed any cache values, bulk-construct them now. This is
	// usually much cheaper than generating them on-demand for each user
	// record.

	if (!$need) {
	return;
	}

	$writes = array();
	foreach ($need as $cache_key => $need_users) {
	$type = PhabricatorUserCacheType::getCacheTypeForKey($cache_key);
	if (!$type) {
	continue;
	}

	$data = $type->newValueForUsers($cache_key, $need_users);

	foreach ($data as $user_phid => $raw_value) {
	$data[$user_phid] = $raw_value;
	$writes[] = array(
	'userPHID' => $user_phid,
	'key' => $cache_key,
	'type' => $type,
	'value' => $raw_value,
	);
	}

	foreach ($need_users as $user_phid => $user) {
	if (isset($data[$user_phid]) \|\| array_key_exists($user_phid, $data)) {
	$user->attachRawCacheData(
	array(
	$cache_key => $data[$user_phid],
	));
	}
	}
	}

	PhabricatorUserCache::writeCaches($writes);
	}
	}
	diff --git a/src/applications/people/typeahead/PhabricatorPeopleDatasource.php b/src/applications/people/typeahead/PhabricatorPeopleDatasource.php
	index 494b68dbfb..df146808bb 100644
	--- a/src/applications/people/typeahead/PhabricatorPeopleDatasource.php
	+++ b/src/applications/people/typeahead/PhabricatorPeopleDatasource.php
	@@ -1,100 +1,105 @@
	<?php

	final class PhabricatorPeopleDatasource
	extends PhabricatorTypeaheadDatasource {

	public function getBrowseTitle() {
	return pht('Browse Users');
	}

	public function getPlaceholderText() {
	return pht('Type a username...');
	}

	public function getDatasourceApplicationClass() {
	return 'PhabricatorPeopleApplication';
	}

	public function loadResults() {
	$viewer = $this->getViewer();
	- $tokens = $this->getTokens();

	$query = id(new PhabricatorPeopleQuery())
	->setOrderVector(array('username'));

	- if ($tokens) {
	- $query->withNameTokens($tokens);
	+ if ($this->getPhase() == self::PHASE_PREFIX) {
	+ $prefix = $this->getPrefixQuery();
	+ $query->withNamePrefixes(array($prefix));
	+ } else {
	+ $tokens = $this->getTokens();
	+ if ($tokens) {
	+ $query->withNameTokens($tokens);
	+ }
	}

	$users = $this->executeQuery($query);

	$is_browse = $this->getIsBrowse();

	if ($is_browse && $users) {
	$phids = mpull($users, 'getPHID');
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($viewer)
	->withPHIDs($phids)
	->execute();
	}

	$results = array();
	foreach ($users as $user) {
	$phid = $user->getPHID();

	$closed = null;
	if ($user->getIsDisabled()) {
	$closed = pht('Disabled');
	} else if ($user->getIsSystemAgent()) {
	$closed = pht('Bot');
	} else if ($user->getIsMailingList()) {
	$closed = pht('Mailing List');
	}

	$username = $user->getUsername();

	$result = id(new PhabricatorTypeaheadResult())
	->setName($user->getFullName())
	->setURI('/p/'.$username.'/')
	->setPHID($phid)
	->setPriorityString($username)
	->setPriorityType('user')
	->setAutocomplete('@'.$username)
	->setClosed($closed);

	if ($user->getIsMailingList()) {
	$result->setIcon('fa-envelope-o');
	}

	if ($is_browse) {
	$handle = $handles[$phid];

	$result
	->setIcon($handle->getIcon())
	->setImageURI($handle->getImageURI())
	->addAttribute($handle->getSubtitle());

	if ($user->getIsAdmin()) {
	$result->addAttribute(
	array(
	id(new PHUIIconView())->setIcon('fa-star'),
	' ',
	pht('Administrator'),
	));
	}

	if ($user->getIsAdmin()) {
	$display_type = pht('Administrator');
	} else {
	$display_type = pht('User');
	}
	$result->setDisplayType($display_type);
	}

	$results[] = $result;
	}

	return $results;
	}

	}
	diff --git a/src/applications/project/query/PhabricatorProjectQuery.php b/src/applications/project/query/PhabricatorProjectQuery.php
	index ab41ecf0ac..87c6bb805e 100644
	--- a/src/applications/project/query/PhabricatorProjectQuery.php
	+++ b/src/applications/project/query/PhabricatorProjectQuery.php
	@@ -1,787 +1,804 @@
	<?php

	final class PhabricatorProjectQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $memberPHIDs;
	private $watcherPHIDs;
	private $slugs;
	private $slugNormals;
	private $slugMap;
	private $allSlugs;
	private $names;
	+ private $namePrefixes;
	private $nameTokens;
	private $icons;
	private $colors;
	private $ancestorPHIDs;
	private $parentPHIDs;
	private $isMilestone;
	private $hasSubprojects;
	private $minDepth;
	private $maxDepth;
	private $minMilestoneNumber;
	private $maxMilestoneNumber;

	private $status = 'status-any';
	const STATUS_ANY = 'status-any';
	const STATUS_OPEN = 'status-open';
	const STATUS_CLOSED = 'status-closed';
	const STATUS_ACTIVE = 'status-active';
	const STATUS_ARCHIVED = 'status-archived';
	private $statuses;

	private $needSlugs;
	private $needMembers;
	private $needAncestorMembers;
	private $needWatchers;
	private $needImages;

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

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

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

	public function withStatuses(array $statuses) {
	$this->statuses = $statuses;
	return $this;
	}

	public function withMemberPHIDs(array $member_phids) {
	$this->memberPHIDs = $member_phids;
	return $this;
	}

	public function withWatcherPHIDs(array $watcher_phids) {
	$this->watcherPHIDs = $watcher_phids;
	return $this;
	}

	public function withSlugs(array $slugs) {
	$this->slugs = $slugs;
	return $this;
	}

	public function withNames(array $names) {
	$this->names = $names;
	return $this;
	}

	+ public function withNamePrefixes(array $prefixes) {
	+ $this->namePrefixes = $prefixes;
	+ return $this;
	+ }
	+
	public function withNameTokens(array $tokens) {
	$this->nameTokens = array_values($tokens);
	return $this;
	}

	public function withIcons(array $icons) {
	$this->icons = $icons;
	return $this;
	}

	public function withColors(array $colors) {
	$this->colors = $colors;
	return $this;
	}

	public function withParentProjectPHIDs($parent_phids) {
	$this->parentPHIDs = $parent_phids;
	return $this;
	}

	public function withAncestorProjectPHIDs($ancestor_phids) {
	$this->ancestorPHIDs = $ancestor_phids;
	return $this;
	}

	public function withIsMilestone($is_milestone) {
	$this->isMilestone = $is_milestone;
	return $this;
	}

	public function withHasSubprojects($has_subprojects) {
	$this->hasSubprojects = $has_subprojects;
	return $this;
	}

	public function withDepthBetween($min, $max) {
	$this->minDepth = $min;
	$this->maxDepth = $max;
	return $this;
	}

	public function withMilestoneNumberBetween($min, $max) {
	$this->minMilestoneNumber = $min;
	$this->maxMilestoneNumber = $max;
	return $this;
	}

	public function needMembers($need_members) {
	$this->needMembers = $need_members;
	return $this;
	}

	public function needAncestorMembers($need_ancestor_members) {
	$this->needAncestorMembers = $need_ancestor_members;
	return $this;
	}

	public function needWatchers($need_watchers) {
	$this->needWatchers = $need_watchers;
	return $this;
	}

	public function needImages($need_images) {
	$this->needImages = $need_images;
	return $this;
	}

	public function needSlugs($need_slugs) {
	$this->needSlugs = $need_slugs;
	return $this;
	}

	public function newResultObject() {
	return new PhabricatorProject();
	}

	protected function getDefaultOrderVector() {
	return array('name');
	}

	public function getBuiltinOrders() {
	return array(
	'name' => array(
	'vector' => array('name'),
	'name' => pht('Name'),
	),
	) + parent::getBuiltinOrders();
	}

	public function getOrderableColumns() {
	return parent::getOrderableColumns() + array(
	'name' => array(
	'table' => $this->getPrimaryTableAlias(),
	'column' => 'name',
	'reverse' => true,
	'type' => 'string',
	'unique' => true,
	),
	'milestoneNumber' => array(
	'table' => $this->getPrimaryTableAlias(),
	'column' => 'milestoneNumber',
	'type' => 'int',
	),
	);
	}

	protected function getPagingValueMap($cursor, array $keys) {
	$project = $this->loadCursorObject($cursor);
	return array(
	'id' => $project->getID(),
	'name' => $project->getName(),
	);
	}

	public function getSlugMap() {
	if ($this->slugMap === null) {
	throw new PhutilInvalidStateException('execute');
	}
	return $this->slugMap;
	}

	protected function willExecute() {
	$this->slugMap = array();
	$this->slugNormals = array();
	$this->allSlugs = array();
	if ($this->slugs) {
	foreach ($this->slugs as $slug) {
	if (PhabricatorSlug::isValidProjectSlug($slug)) {
	$normal = PhabricatorSlug::normalizeProjectSlug($slug);
	$this->slugNormals[$slug] = $normal;
	$this->allSlugs[$normal] = $normal;
	}

	// NOTE: At least for now, we query for the normalized slugs but also
	// for the slugs exactly as entered. This allows older projects with
	// slugs that are no longer valid to continue to work.
	$this->allSlugs[$slug] = $slug;
	}
	}
	}

	protected function loadPage() {
	return $this->loadStandardPage($this->newResultObject());
	}

	protected function willFilterPage(array $projects) {
	$ancestor_paths = array();
	foreach ($projects as $project) {
	foreach ($project->getAncestorProjectPaths() as $path) {
	$ancestor_paths[$path] = $path;
	}
	}

	if ($ancestor_paths) {
	$ancestors = id(new PhabricatorProject())->loadAllWhere(
	'projectPath IN (%Ls)',
	$ancestor_paths);
	} else {
	$ancestors = array();
	}

	$projects = $this->linkProjectGraph($projects, $ancestors);

	$viewer_phid = $this->getViewer()->getPHID();

	$material_type = PhabricatorProjectMaterializedMemberEdgeType::EDGECONST;
	$watcher_type = PhabricatorObjectHasWatcherEdgeType::EDGECONST;

	$types = array();
	$types[] = $material_type;
	if ($this->needWatchers) {
	$types[] = $watcher_type;
	}

	$all_graph = $this->getAllReachableAncestors($projects);

	if ($this->needAncestorMembers \|\| $this->needWatchers) {
	$src_projects = $all_graph;
	} else {
	$src_projects = $projects;
	}

	$all_sources = array();
	foreach ($src_projects as $project) {
	// For milestones, we need parent members.
	if ($project->isMilestone()) {
	$parent_phid = $project->getParentProjectPHID();
	$all_sources[$parent_phid] = $parent_phid;
	}

	$phid = $project->getPHID();
	$all_sources[$phid] = $phid;
	}

	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs($all_sources)
	->withEdgeTypes($types);

	$need_all_edges =
	$this->needMembers \|\|
	$this->needWatchers \|\|
	$this->needAncestorMembers;

	// If we only need to know if the viewer is a member, we can restrict
	// the query to just their PHID.
	$any_edges = true;
	if (!$need_all_edges) {
	if ($viewer_phid) {
	$edge_query->withDestinationPHIDs(array($viewer_phid));
	} else {
	// If we don't need members or watchers and don't have a viewer PHID
	// (viewer is logged-out or omnipotent), they'll never be a member
	// so we don't need to issue this query at all.
	$any_edges = false;
	}
	}

	if ($any_edges) {
	$edge_query->execute();
	}

	$membership_projects = array();
	foreach ($src_projects as $project) {
	$project_phid = $project->getPHID();

	if ($project->isMilestone()) {
	$source_phids = array($project->getParentProjectPHID());
	} else {
	$source_phids = array($project_phid);
	}

	if ($any_edges) {
	$member_phids = $edge_query->getDestinationPHIDs(
	$source_phids,
	array($material_type));
	} else {
	$member_phids = array();
	}

	if (in_array($viewer_phid, $member_phids)) {
	$membership_projects[$project_phid] = $project;
	}

	if ($this->needMembers \|\| $this->needAncestorMembers) {
	$project->attachMemberPHIDs($member_phids);
	}

	if ($this->needWatchers) {
	$watcher_phids = $edge_query->getDestinationPHIDs(
	array($project_phid),
	array($watcher_type));
	$project->attachWatcherPHIDs($watcher_phids);
	$project->setIsUserWatcher(
	$viewer_phid,
	in_array($viewer_phid, $watcher_phids));
	}
	}

	// If we loaded ancestor members, we've already populated membership
	// lists above, so we can skip this step.
	if (!$this->needAncestorMembers) {
	$member_graph = $this->getAllReachableAncestors($membership_projects);

	foreach ($all_graph as $phid => $project) {
	$is_member = isset($member_graph[$phid]);
	$project->setIsUserMember($viewer_phid, $is_member);
	}
	}

	return $projects;
	}

	protected function didFilterPage(array $projects) {
	if ($this->needImages) {
	$default = null;

	$file_phids = mpull($projects, 'getProfileImagePHID');
	$file_phids = array_filter($file_phids);
	if ($file_phids) {
	$files = id(new PhabricatorFileQuery())
	->setParentQuery($this)
	->setViewer($this->getViewer())
	->withPHIDs($file_phids)
	->execute();
	$files = mpull($files, null, 'getPHID');
	} else {
	$files = array();
	}

	foreach ($projects as $project) {
	$file = idx($files, $project->getProfileImagePHID());
	if (!$file) {
	if (!$default) {
	$default = PhabricatorFile::loadBuiltin(
	$this->getViewer(),
	'project.png');
	}
	$file = $default;
	}
	$project->attachProfileImageFile($file);
	}
	}

	$this->loadSlugs($projects);

	return $projects;
	}

	protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
	$where = parent::buildWhereClauseParts($conn);

	if ($this->status != self::STATUS_ANY) {
	switch ($this->status) {
	case self::STATUS_OPEN:
	case self::STATUS_ACTIVE:
	$filter = array(
	PhabricatorProjectStatus::STATUS_ACTIVE,
	);
	break;
	case self::STATUS_CLOSED:
	case self::STATUS_ARCHIVED:
	$filter = array(
	PhabricatorProjectStatus::STATUS_ARCHIVED,
	);
	break;
	default:
	throw new Exception(
	pht(
	"Unknown project status '%s'!",
	$this->status));
	}
	$where[] = qsprintf(
	$conn,
	'status IN (%Ld)',
	$filter);
	}

	if ($this->statuses !== null) {
	$where[] = qsprintf(
	$conn,
	'status IN (%Ls)',
	$this->statuses);
	}

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

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

	if ($this->memberPHIDs !== null) {
	$where[] = qsprintf(
	$conn,
	'e.dst IN (%Ls)',
	$this->memberPHIDs);
	}

	if ($this->watcherPHIDs !== null) {
	$where[] = qsprintf(
	$conn,
	'w.dst IN (%Ls)',
	$this->watcherPHIDs);
	}

	if ($this->slugs !== null) {
	$where[] = qsprintf(
	$conn,
	'slug.slug IN (%Ls)',
	$this->allSlugs);
	}

	if ($this->names !== null) {
	$where[] = qsprintf(
	$conn,
	'name IN (%Ls)',
	$this->names);
	}

	+ if ($this->namePrefixes) {
	+ $parts = array();
	+ foreach ($this->namePrefixes as $name_prefix) {
	+ $parts[] = qsprintf(
	+ $conn,
	+ 'name LIKE %>',
	+ $name_prefix);
	+ }
	+ $where[] = '('.implode(' OR ', $parts).')';
	+ }
	+
	if ($this->icons !== null) {
	$where[] = qsprintf(
	$conn,
	'icon IN (%Ls)',
	$this->icons);
	}

	if ($this->colors !== null) {
	$where[] = qsprintf(
	$conn,
	'color IN (%Ls)',
	$this->colors);
	}

	if ($this->parentPHIDs !== null) {
	$where[] = qsprintf(
	$conn,
	'parentProjectPHID IN (%Ls)',
	$this->parentPHIDs);
	}

	if ($this->ancestorPHIDs !== null) {
	$ancestor_paths = queryfx_all(
	$conn,
	'SELECT projectPath, projectDepth FROM %T WHERE phid IN (%Ls)',
	id(new PhabricatorProject())->getTableName(),
	$this->ancestorPHIDs);
	if (!$ancestor_paths) {
	throw new PhabricatorEmptyQueryException();
	}

	$sql = array();
	foreach ($ancestor_paths as $ancestor_path) {
	$sql[] = qsprintf(
	$conn,
	'(projectPath LIKE %> AND projectDepth > %d)',
	$ancestor_path['projectPath'],
	$ancestor_path['projectDepth']);
	}

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

	$where[] = qsprintf(
	$conn,
	'parentProjectPHID IS NOT NULL');
	}

	if ($this->isMilestone !== null) {
	if ($this->isMilestone) {
	$where[] = qsprintf(
	$conn,
	'milestoneNumber IS NOT NULL');
	} else {
	$where[] = qsprintf(
	$conn,
	'milestoneNumber IS NULL');
	}
	}


	if ($this->hasSubprojects !== null) {
	$where[] = qsprintf(
	$conn,
	'hasSubprojects = %d',
	(int)$this->hasSubprojects);
	}

	if ($this->minDepth !== null) {
	$where[] = qsprintf(
	$conn,
	'projectDepth >= %d',
	$this->minDepth);
	}

	if ($this->maxDepth !== null) {
	$where[] = qsprintf(
	$conn,
	'projectDepth <= %d',
	$this->maxDepth);
	}

	if ($this->minMilestoneNumber !== null) {
	$where[] = qsprintf(
	$conn,
	'milestoneNumber >= %d',
	$this->minMilestoneNumber);
	}

	if ($this->maxMilestoneNumber !== null) {
	$where[] = qsprintf(
	$conn,
	'milestoneNumber <= %d',
	$this->maxMilestoneNumber);
	}

	return $where;
	}

	protected function shouldGroupQueryResultRows() {
	if ($this->memberPHIDs \|\| $this->watcherPHIDs \|\| $this->nameTokens) {
	return true;
	}
	return parent::shouldGroupQueryResultRows();
	}

	protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
	$joins = parent::buildJoinClauseParts($conn);

	if ($this->memberPHIDs !== null) {
	$joins[] = qsprintf(
	$conn,
	'JOIN %T e ON e.src = p.phid AND e.type = %d',
	PhabricatorEdgeConfig::TABLE_NAME_EDGE,
	PhabricatorProjectMaterializedMemberEdgeType::EDGECONST);
	}

	if ($this->watcherPHIDs !== null) {
	$joins[] = qsprintf(
	$conn,
	'JOIN %T w ON w.src = p.phid AND w.type = %d',
	PhabricatorEdgeConfig::TABLE_NAME_EDGE,
	PhabricatorObjectHasWatcherEdgeType::EDGECONST);
	}

	if ($this->slugs !== null) {
	$joins[] = qsprintf(
	$conn,
	'JOIN %T slug on slug.projectPHID = p.phid',
	id(new PhabricatorProjectSlug())->getTableName());
	}

	if ($this->nameTokens !== null) {
	foreach ($this->nameTokens as $key => $token) {
	$token_table = 'token_'.$key;
	$joins[] = qsprintf(
	$conn,
	'JOIN %T %T ON %T.projectID = p.id AND %T.token LIKE %>',
	PhabricatorProject::TABLE_DATASOURCE_TOKEN,
	$token_table,
	$token_table,
	$token_table,
	$token);
	}
	}

	return $joins;
	}

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

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

	private function linkProjectGraph(array $projects, array $ancestors) {
	$ancestor_map = mpull($ancestors, null, 'getPHID');
	$projects_map = mpull($projects, null, 'getPHID');

	$all_map = $projects_map + $ancestor_map;

	$done = array();
	foreach ($projects as $key => $project) {
	$seen = array($project->getPHID() => true);

	if (!$this->linkProject($project, $all_map, $done, $seen)) {
	$this->didRejectResult($project);
	unset($projects[$key]);
	continue;
	}

	foreach ($project->getAncestorProjects() as $ancestor) {
	$seen[$ancestor->getPHID()] = true;
	}
	}

	return $projects;
	}

	private function linkProject($project, array $all, array $done, array $seen) {
	$parent_phid = $project->getParentProjectPHID();

	// This project has no parent, so just attach `null` and return.
	if (!$parent_phid) {
	$project->attachParentProject(null);
	return true;
	}

	// This project has a parent, but it failed to load.
	if (empty($all[$parent_phid])) {
	return false;
	}

	// Test for graph cycles. If we encounter one, we're going to hide the
	// entire cycle since we can't meaningfully resolve it.
	if (isset($seen[$parent_phid])) {
	return false;
	}

	$seen[$parent_phid] = true;

	$parent = $all[$parent_phid];
	$project->attachParentProject($parent);

	if (!empty($done[$parent_phid])) {
	return true;
	}

	return $this->linkProject($parent, $all, $done, $seen);
	}

	private function getAllReachableAncestors(array $projects) {
	$ancestors = array();

	$seen = mpull($projects, null, 'getPHID');

	$stack = $projects;
	while ($stack) {
	$project = array_pop($stack);

	$phid = $project->getPHID();
	$ancestors[$phid] = $project;

	$parent_phid = $project->getParentProjectPHID();
	if (!$parent_phid) {
	continue;
	}

	if (isset($seen[$parent_phid])) {
	continue;
	}

	$seen[$parent_phid] = true;
	$stack[] = $project->getParentProject();
	}

	return $ancestors;
	}

	private function loadSlugs(array $projects) {
	// Build a map from primary slugs to projects.
	$primary_map = array();
	foreach ($projects as $project) {
	$primary_slug = $project->getPrimarySlug();
	if ($primary_slug === null) {
	continue;
	}

	$primary_map[$primary_slug] = $project;
	}

	// Link up all of the queried slugs which correspond to primary
	// slugs. If we can link up everything from this (no slugs were queried,
	// or only primary slugs were queried) we don't need to load anything
	// else.
	$unknown = $this->slugNormals;
	foreach ($unknown as $input => $normal) {
	if (isset($primary_map[$input])) {
	$match = $input;
	} else if (isset($primary_map[$normal])) {
	$match = $normal;
	} else {
	continue;
	}

	$this->slugMap[$input] = array(
	'slug' => $match,
	'projectPHID' => $primary_map[$match]->getPHID(),
	);

	unset($unknown[$input]);
	}

	// If we need slugs, we have to load everything.
	// If we still have some queried slugs which we haven't mapped, we only
	// need to look for them.
	// If we've mapped everything, we don't have to do any work.
	$project_phids = mpull($projects, 'getPHID');
	if ($this->needSlugs) {
	$slugs = id(new PhabricatorProjectSlug())->loadAllWhere(
	'projectPHID IN (%Ls)',
	$project_phids);
	} else if ($unknown) {
	$slugs = id(new PhabricatorProjectSlug())->loadAllWhere(
	'projectPHID IN (%Ls) AND slug IN (%Ls)',
	$project_phids,
	$unknown);
	} else {
	$slugs = array();
	}

	// Link up any slugs we were not able to link up earlier.
	$extra_map = mpull($slugs, 'getProjectPHID', 'getSlug');
	foreach ($unknown as $input => $normal) {
	if (isset($extra_map[$input])) {
	$match = $input;
	} else if (isset($extra_map[$normal])) {
	$match = $normal;
	} else {
	continue;
	}

	$this->slugMap[$input] = array(
	'slug' => $match,
	'projectPHID' => $extra_map[$match],
	);

	unset($unknown[$input]);
	}

	if ($this->needSlugs) {
	$slug_groups = mgroup($slugs, 'getProjectPHID');
	foreach ($projects as $project) {
	$project_slugs = idx($slug_groups, $project->getPHID(), array());
	$project->attachSlugs($project_slugs);
	}
	}
	}

	}
	diff --git a/src/applications/project/typeahead/PhabricatorProjectDatasource.php b/src/applications/project/typeahead/PhabricatorProjectDatasource.php
	index 03c2424f4a..03a6e39c33 100644
	--- a/src/applications/project/typeahead/PhabricatorProjectDatasource.php
	+++ b/src/applications/project/typeahead/PhabricatorProjectDatasource.php
	@@ -1,146 +1,149 @@
	<?php

	final class PhabricatorProjectDatasource
	extends PhabricatorTypeaheadDatasource {

	public function getBrowseTitle() {
	return pht('Browse Projects');
	}

	public function getPlaceholderText() {
	return pht('Type a project name...');
	}

	public function getDatasourceApplicationClass() {
	return 'PhabricatorProjectApplication';
	}

	public function loadResults() {
	$viewer = $this->getViewer();

	$raw_query = $this->getRawQuery();

	// Allow users to type "#qa" or "qa" to find "Quality Assurance".
	$raw_query = ltrim($raw_query, '#');
	$tokens = self::tokenizeString($raw_query);

	$query = id(new PhabricatorProjectQuery())
	->needImages(true)
	->needSlugs(true);

	- if ($tokens) {
	+ if ($this->getPhase() == self::PHASE_PREFIX) {
	+ $prefix = $this->getPrefixQuery();
	+ $query->withNamePrefixes(array($prefix));
	+ } else if ($tokens) {
	$query->withNameTokens($tokens);
	}

	// If this is for policy selection, prevent users from using milestones.
	$for_policy = $this->getParameter('policy');
	if ($for_policy) {
	$query->withIsMilestone(false);
	}

	$for_autocomplete = $this->getParameter('autocomplete');

	$projs = $this->executeQuery($query);

	$projs = mpull($projs, null, 'getPHID');

	$must_have_cols = $this->getParameter('mustHaveColumns', false);
	if ($must_have_cols) {
	$columns = id(new PhabricatorProjectColumnQuery())
	->setViewer($viewer)
	->withProjectPHIDs(array_keys($projs))
	->execute();
	$has_cols = mgroup($columns, 'getProjectPHID');
	} else {
	$has_cols = array_fill_keys(array_keys($projs), true);
	}

	$is_browse = $this->getIsBrowse();
	if ($is_browse && $projs) {
	// TODO: This is a little ad-hoc, but we don't currently have
	// infrastructure for bulk querying custom fields efficiently.
	$table = new PhabricatorProjectCustomFieldStorage();
	$descriptions = $table->loadAllWhere(
	'objectPHID IN (%Ls) AND fieldIndex = %s',
	array_keys($projs),
	PhabricatorHash::digestForIndex('std:project:internal:description'));
	$descriptions = mpull($descriptions, 'getFieldValue', 'getObjectPHID');
	} else {
	$descriptions = array();
	}

	$results = array();
	foreach ($projs as $proj) {
	$phid = $proj->getPHID();

	if (!isset($has_cols[$phid])) {
	continue;
	}

	$slug = $proj->getPrimarySlug();
	if (!strlen($slug)) {
	foreach ($proj->getSlugs() as $slug_object) {
	$slug = $slug_object->getSlug();
	if (strlen($slug)) {
	break;
	}
	}
	}

	// If we're building results for the autocompleter and this project
	// doesn't have any usable slugs, don't return it as a result.
	if ($for_autocomplete && !strlen($slug)) {
	continue;
	}

	$closed = null;
	if ($proj->isArchived()) {
	$closed = pht('Archived');
	}

	$all_strings = array();
	$all_strings[] = $proj->getDisplayName();

	// Add an extra space after the name so that the original project
	// sorts ahead of milestones. This is kind of a hack but ehh?
	$all_strings[] = null;

	foreach ($proj->getSlugs() as $project_slug) {
	$all_strings[] = $project_slug->getSlug();
	}
	$all_strings = implode(' ', $all_strings);

	$proj_result = id(new PhabricatorTypeaheadResult())
	->setName($all_strings)
	->setDisplayName($proj->getDisplayName())
	->setDisplayType($proj->getDisplayIconName())
	->setURI($proj->getURI())
	->setPHID($phid)
	->setIcon($proj->getDisplayIconIcon())
	->setColor($proj->getColor())
	->setPriorityType('proj')
	->setClosed($closed);

	if (strlen($slug)) {
	$proj_result->setAutocomplete('#'.$slug);
	}

	$proj_result->setImageURI($proj->getProfileImageURI());

	if ($is_browse) {
	$proj_result->addAttribute($proj->getDisplayIconName());

	$description = idx($descriptions, $phid);
	if (strlen($description)) {
	$summary = PhabricatorMarkupEngine::summarize($description);
	$proj_result->addAttribute($summary);
	}
	}

	$results[] = $proj_result;
	}

	return $results;
	}

	}
	diff --git a/src/applications/typeahead/controller/PhabricatorTypeaheadModularDatasourceController.php b/src/applications/typeahead/controller/PhabricatorTypeaheadModularDatasourceController.php
	index a7c8381bfd..5c641b7c1f 100644
	--- a/src/applications/typeahead/controller/PhabricatorTypeaheadModularDatasourceController.php
	+++ b/src/applications/typeahead/controller/PhabricatorTypeaheadModularDatasourceController.php
	@@ -1,408 +1,413 @@
	<?php

	final class PhabricatorTypeaheadModularDatasourceController
	extends PhabricatorTypeaheadDatasourceController {

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$request = $this->getRequest();
	$viewer = $request->getUser();
	$query = $request->getStr('q');
	$offset = $request->getInt('offset');
	$select_phid = null;
	$is_browse = ($request->getURIData('action') == 'browse');

	$select = $request->getStr('select');
	if ($select) {
	$select = phutil_json_decode($select);
	$query = idx($select, 'q');
	$offset = idx($select, 'offset');
	$select_phid = idx($select, 'phid');
	}

	// Default this to the query string to make debugging a little bit easier.
	$raw_query = nonempty($request->getStr('raw'), $query);

	// This makes form submission easier in the debug view.
	$class = nonempty($request->getURIData('class'), $request->getStr('class'));

	$sources = id(new PhutilClassMapQuery())
	->setAncestorClass('PhabricatorTypeaheadDatasource')
	->execute();

	if (isset($sources[$class])) {
	$source = $sources[$class];
	$source->setParameters($request->getRequestData());
	$source->setViewer($viewer);

	// NOTE: Wrapping the source in a Composite datasource ensures we perform
	// application visibility checks for the viewer, so we do not need to do
	// those separately.
	$composite = new PhabricatorTypeaheadRuntimeCompositeDatasource();
	$composite->addDatasource($source);

	$hard_limit = 1000;
	$limit = 100;

	$composite
	->setViewer($viewer)
	->setQuery($query)
	->setRawQuery($raw_query)
	->setLimit($limit + 1);

	if ($is_browse) {
	if (!$composite->isBrowsable()) {
	return new Aphront404Response();
	}

	if (($offset + $limit) >= $hard_limit) {
	// Offset-based paging is intrinsically slow; hard-cap how far we're
	// willing to go with it.
	return new Aphront404Response();
	}

	$composite
	->setOffset($offset)
	->setIsBrowse(true);
	}

	$results = $composite->loadResults();

	if ($is_browse) {
	// If this is a request for a specific token after the user clicks
	// "Select", return the token in wire format so it can be added to
	// the tokenizer.
	if ($select_phid !== null) {
	$map = mpull($results, null, 'getPHID');
	$token = idx($map, $select_phid);
	if (!$token) {
	return new Aphront404Response();
	}

	$payload = array(
	'key' => $token->getPHID(),
	'token' => $token->getWireFormat(),
	);

	return id(new AphrontAjaxResponse())->setContent($payload);
	}

	$format = $request->getStr('format');
	switch ($format) {
	case 'html':
	case 'dialog':
	// These are the acceptable response formats.
	break;
	default:
	// Return a dialog if format information is missing or invalid.
	$format = 'dialog';
	break;
	}

	$next_link = null;
	if (count($results) > $limit) {
	$results = array_slice($results, 0, $limit, $preserve_keys = true);
	if (($offset + (2 * $limit)) < $hard_limit) {
	$next_uri = id(new PhutilURI($request->getRequestURI()))
	->setQueryParam('offset', $offset + $limit)
	->setQueryParam('q', $query)
	->setQueryParam('raw', $raw_query)
	->setQueryParam('format', 'html');

	$next_link = javelin_tag(
	'a',
	array(
	'href' => $next_uri,
	'class' => 'typeahead-browse-more',
	'sigil' => 'typeahead-browse-more',
	'mustcapture' => true,
	),
	pht('More Results'));
	} else {
	// If the user has paged through more than 1K results, don't
	// offer to page any further.
	$next_link = javelin_tag(
	'div',
	array(
	'class' => 'typeahead-browse-hard-limit',
	),
	pht('You reach the edge of the abyss.'));
	}
	}

	$exclude = $request->getStrList('exclude');
	$exclude = array_fuse($exclude);

	$select = array(
	'offset' => $offset,
	'q' => $query,
	);

	$items = array();
	foreach ($results as $result) {
	// Disable already-selected tokens.
	$disabled = isset($exclude[$result->getPHID()]);

	$value = $select + array('phid' => $result->getPHID());
	$value = json_encode($value);

	$button = phutil_tag(
	'button',
	array(
	'class' => 'small grey',
	'name' => 'select',
	'value' => $value,
	'disabled' => $disabled ? 'disabled' : null,
	),
	pht('Select'));

	$information = $this->renderBrowseResult($result, $button);

	$items[] = phutil_tag(
	'div',
	array(
	'class' => 'typeahead-browse-item grouped',
	),
	$information);
	}

	$markup = array(
	$items,
	$next_link,
	);

	if ($format == 'html') {
	$content = array(
	'markup' => hsprintf('%s', $markup),
	);
	return id(new AphrontAjaxResponse())->setContent($content);
	}

	$this->requireResource('typeahead-browse-css');
	$this->initBehavior('typeahead-browse');

	$input_id = celerity_generate_unique_node_id();
	$frame_id = celerity_generate_unique_node_id();

	$config = array(
	'inputID' => $input_id,
	'frameID' => $frame_id,
	'uri' => (string)$request->getRequestURI(),
	);
	$this->initBehavior('typeahead-search', $config);

	$search = javelin_tag(
	'input',
	array(
	'type' => 'text',
	'id' => $input_id,
	'class' => 'typeahead-browse-input',
	'autocomplete' => 'off',
	'placeholder' => $source->getPlaceholderText(),
	));

	$frame = phutil_tag(
	'div',
	array(
	'class' => 'typeahead-browse-frame',
	'id' => $frame_id,
	),
	$markup);

	$browser = array(
	phutil_tag(
	'div',
	array(
	'class' => 'typeahead-browse-header',
	),
	$search),
	$frame,
	);

	$function_help = null;
	if ($source->getAllDatasourceFunctions()) {
	$reference_uri = '/typeahead/help/'.get_class($source).'/';

	$reference_link = phutil_tag(
	'a',
	array(
	'href' => $reference_uri,
	'target' => '_blank',
	),
	pht('Reference: Advanced Functions'));

	$function_help = array(
	id(new PHUIIconView())
	->setIcon('fa-book'),
	' ',
	$reference_link,
	);
	}

	return $this->newDialog()
	->setWidth(AphrontDialogView::WIDTH_FORM)
	->setRenderDialogAsDiv(true)
	->setTitle($source->getBrowseTitle())
	->appendChild($browser)
	->setResizeX(true)
	->setResizeY($frame_id)
	->addFooter($function_help)
	->addCancelButton('/', pht('Close'));
	}

	} else if ($is_browse) {
	return new Aphront404Response();
	} else {
	$results = array();
	}

	$content = mpull($results, 'getWireFormat');
	$content = array_values($content);

	if ($request->isAjax()) {
	return id(new AphrontAjaxResponse())->setContent($content);
	}

	// If there's a non-Ajax request to this endpoint, show results in a tabular
	// format to make it easier to debug typeahead output.

	foreach ($sources as $key => $source) {
	// This can happen with composite or generic sources.
	if (!$source->getDatasourceApplicationClass()) {
	continue;
	}
	if (!PhabricatorApplication::isClassInstalledForViewer(
	$source->getDatasourceApplicationClass(),
	$viewer)) {
	unset($sources[$key]);
	}
	}
	$options = array_fuse(array_keys($sources));
	asort($options);

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->setAction('/typeahead/class/')
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Source Class'))
	->setName('class')
	->setValue($class)
	->setOptions($options))
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Query'))
	->setName('q')
	->setValue($request->getStr('q')))
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Raw Query'))
	->setName('raw')
	->setValue($request->getStr('raw')))
	->appendChild(
	id(new AphrontFormSubmitControl())
	->setValue(pht('Query')));

	$form_box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Token Query'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setForm($form);

	$table = new AphrontTableView($content);
	$table->setHeaders(
	array(
	pht('Name'),
	pht('URI'),
	pht('PHID'),
	pht('Priority'),
	pht('Display Name'),
	pht('Display Type'),
	pht('Image URI'),
	pht('Priority Type'),
	pht('Icon'),
	pht('Closed'),
	pht('Sprite'),
	+ pht('Color'),
	+ pht('Type'),
	+ pht('Unique'),
	+ pht('Auto'),
	+ pht('Phase'),
	));

	$result_box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Token Results (%s)', $class))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($table);

	$title = pht('Typeahead Results');

	$header = id(new PHUIHeaderView())
	->setHeader($title);

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setFooter(array(
	$form_box,
	$result_box,
	));

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

	private function renderBrowseResult(
	PhabricatorTypeaheadResult $result,
	$button) {

	$class = array();
	$style = array();
	$separator = " \xC2\xB7 ";

	$class[] = 'phabricator-main-search-typeahead-result';

	$name = phutil_tag(
	'div',
	array(
	'class' => 'result-name',
	),
	$result->getDisplayName());

	$icon = $result->getIcon();
	$icon = id(new PHUIIconView())->setIcon($icon);

	$attributes = $result->getAttributes();
	$attributes = phutil_implode_html($separator, $attributes);
	$attributes = array($icon, ' ', $attributes);

	$closed = $result->getClosed();
	if ($closed) {
	$class[] = 'result-closed';
	$attributes = array($closed, $separator, $attributes);
	}

	$attributes = phutil_tag(
	'div',
	array(
	'class' => 'result-type',
	),
	$attributes);

	$image = $result->getImageURI();
	if ($image) {
	$style[] = 'background-image: url('.$image.');';
	$class[] = 'has-image';
	}

	return phutil_tag(
	'div',
	array(
	'class' => implode(' ', $class),
	'style' => implode(' ', $style),
	),
	array(
	$button,
	$name,
	$attributes,
	));
	}

	}
	diff --git a/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php b/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php
	index 306b33b497..33f06e4ae5 100644
	--- a/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php
	+++ b/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php
	@@ -1,194 +1,320 @@
	<?php

	abstract class PhabricatorTypeaheadCompositeDatasource
	extends PhabricatorTypeaheadDatasource {

	private $usable;
	+ private $prefixString;
	+ private $prefixLength;

	abstract public function getComponentDatasources();

	public function isBrowsable() {
	foreach ($this->getUsableDatasources() as $datasource) {
	if (!$datasource->isBrowsable()) {
	return false;
	}
	}

	return parent::isBrowsable();
	}

	public function getDatasourceApplicationClass() {
	return null;
	}

	public function loadResults() {
	+ $phases = array();
	+
	+ // We only need to do a prefix phase query if there's an actual query
	+ // string. If the user didn't type anything, nothing can possibly match it.
	+ if (strlen($this->getRawQuery())) {
	+ $phases[] = self::PHASE_PREFIX;
	+ }
	+
	+ $phases[] = self::PHASE_CONTENT;
	+
	$offset = $this->getOffset();
	$limit = $this->getLimit();

	+ $results = array();
	+ foreach ($phases as $phase) {
	+ if ($limit) {
	+ $phase_limit = ($offset + $limit) - count($results);
	+ } else {
	+ $phase_limit = 0;
	+ }
	+
	+ $phase_results = $this->loadResultsForPhase(
	+ $phase,
	+ $phase_limit);
	+
	+ foreach ($phase_results as $result) {
	+ $results[] = $result;
	+ }
	+
	+ if ($limit) {
	+ if (count($results) >= $offset + $limit) {
	+ break;
	+ }
	+ }
	+ }
	+
	+ return $results;
	+ }
	+
	+ protected function loadResultsForPhase($phase, $limit) {
	+ if ($phase == self::PHASE_PREFIX) {
	+ $this->prefixString = $this->getPrefixQuery();
	+ $this->prefixLength = strlen($this->prefixString);
	+ }
	+
	// If the input query is a function like `members(platy`, and we can
	// parse the function, we strip the function off and hand the stripped
	// query to child sources. This makes it easier to implement function
	// sources in terms of real object sources.
	$raw_query = $this->getRawQuery();

	$is_function = false;
	if (self::isFunctionToken($raw_query)) {
	$is_function = true;
	}

	$stack = $this->getFunctionStack();
	$is_browse = $this->getIsBrowse();

	$results = array();
	foreach ($this->getUsableDatasources() as $source) {
	$source_stack = $stack;

	$source_query = $raw_query;
	if ($is_function) {
	// If this source can't handle the function, skip it.
	$function = $source->parseFunction($raw_query, $allow_partial = true);
	if (!$function) {
	continue;
	}

	// If this source handles the function directly, strip the function.
	// Otherwise, this is something like a composite source which has
	// some internal source which can evaluate the function, but will
	// perform stripping later.
	if ($source->shouldStripFunction($function['name'])) {
	$source_query = head($function['argv']);
	$source_stack[] = $function['name'];
	}
	}

	$source
	+ ->setPhase($phase)
	->setFunctionStack($source_stack)
	->setRawQuery($source_query)
	->setQuery($this->getQuery())
	->setViewer($this->getViewer());

	- if ($limit) {
	- $source->setLimit($offset + $limit);
	- }
	-
	if ($is_browse) {
	$source->setIsBrowse(true);
	}

	- $source_results = $source->loadResults();
	- $source_results = $source->didLoadResults($source_results);
	+ if ($limit) {
	+ // If we are loading results from a source with a limit, it may return
	+ // some results which belong to the wrong phase. We need an entire page
	+ // of valid results in the correct phase AFTER any results for the
	+ // wrong phase are filtered for pagination to work correctly.
	+
	+ // To make sure we can get there, we fetch more and more results until
	+ // enough of them survive filtering to generate a full page.
	+
	+ // We start by fetching 150% of the results than we think we need, and
	+ // double the amount we overfetch by each time.
	+ $factor = 1.5;
	+ while (true) {
	+ $query_source = clone $source;
	+ $total = (int)ceil($limit * $factor) + 1;
	+ $query_source->setLimit($total);
	+
	+ $source_results = $query_source->loadResultsForPhase(
	+ $phase,
	+ $limit);
	+
	+ // If there are fewer unfiltered results than we asked for, we know
	+ // this is the entire result set and we don't need to keep going.
	+ if (count($source_results) < $total) {
	+ $source_results = $query_source->didLoadResults($source_results);
	+ $source_results = $this->filterPhaseResults(
	+ $phase,
	+ $source_results);
	+ break;
	+ }
	+
	+ // Otherwise, this result set have everything we need, or may not.
	+ // Filter the results that are part of the wrong phase out first...
	+ $source_results = $query_source->didLoadResults($source_results);
	+ $source_results = $this->filterPhaseResults($phase, $source_results);
	+
	+ // Now check if we have enough results left. If we do, we're all set.
	+ if (count($source_results) >= $total) {
	+ break;
	+ }
	+
	+ // We filtered out too many results to have a full page left, so we
	+ // need to run the query again, asking for even more results. We'll
	+ // keep doing this until we get a full page or get all of the
	+ // results.
	+ $factor = $factor * 2;
	+ }
	+ } else {
	+ $source_results = $source->loadResults();
	+ $source_results = $source->didLoadResults($source_results);
	+ $source_results = $this->filterPhaseResults($phase, $source_results);
	+ }
	+
	$results[] = $source_results;
	}

	$results = array_mergev($results);
	$results = msort($results, 'getSortKey');

	- $count = count($results);
	+ $results = $this->sliceResults($results);
	+
	+ return $results;
	+ }
	+
	+ private function filterPhaseResults($phase, $source_results) {
	+ foreach ($source_results as $key => $source_result) {
	+ $result_phase = $this->getResultPhase($source_result);
	+
	+ if ($result_phase != $phase) {
	+ unset($source_results[$key]);
	+ continue;
	+ }
	+
	+ $source_result->setPhase($result_phase);
	+ }
	+
	+ return $source_results;
	+ }
	+
	+ private function getResultPhase(PhabricatorTypeaheadResult $result) {
	+ if ($this->prefixLength) {
	+ $result_name = phutil_utf8_strtolower($result->getName());
	+ if (!strncmp($result_name, $this->prefixString, $this->prefixLength)) {
	+ return self::PHASE_PREFIX;
	+ }
	+ }
	+
	+ return self::PHASE_CONTENT;
	+ }
	+
	+ protected function sliceResults(array $results) {
	+ $offset = $this->getOffset();
	+ $limit = $this->getLimit();
	+
	if ($offset \|\| $limit) {
	if (!$limit) {
	$limit = count($results);
	}

	$results = array_slice($results, $offset, $limit, $preserve_keys = true);
	}

	return $results;
	}

	private function getUsableDatasources() {
	if ($this->usable === null) {
	$sources = $this->getComponentDatasources();

	$usable = array();
	foreach ($sources as $source) {
	$application_class = $source->getDatasourceApplicationClass();

	if ($application_class) {
	$result = id(new PhabricatorApplicationQuery())
	->setViewer($this->getViewer())
	->withClasses(array($application_class))
	->execute();
	if (!$result) {
	continue;
	}
	}

	$source->setViewer($this->getViewer());
	$usable[] = $source;
	}
	$this->usable = $usable;
	}

	return $this->usable;
	}

	public function getAllDatasourceFunctions() {
	$results = parent::getAllDatasourceFunctions();
	foreach ($this->getUsableDatasources() as $source) {
	$results += $source->getAllDatasourceFunctions();
	}
	return $results;
	}

	protected function didEvaluateTokens(array $results) {
	foreach ($this->getUsableDatasources() as $source) {
	$results = $source->didEvaluateTokens($results);
	}
	return $results;
	}

	protected function canEvaluateFunction($function) {
	foreach ($this->getUsableDatasources() as $source) {
	if ($source->canEvaluateFunction($function)) {
	return true;
	}
	}

	return parent::canEvaluateFunction($function);
	}

	protected function evaluateValues(array $values) {
	foreach ($this->getUsableDatasources() as $source) {
	$values = $source->evaluateValues($values);
	}

	return parent::evaluateValues($values);
	}

	protected function evaluateFunction($function, array $argv) {
	foreach ($this->getUsableDatasources() as $source) {
	if ($source->canEvaluateFunction($function)) {
	return $source->evaluateFunction($function, $argv);
	}
	}

	return parent::evaluateFunction($function, $argv);
	}

	public function renderFunctionTokens($function, array $argv_list) {
	foreach ($this->getUsableDatasources() as $source) {
	if ($source->canEvaluateFunction($function)) {
	return $source->renderFunctionTokens($function, $argv_list);
	}
	}

	return parent::renderFunctionTokens($function, $argv_list);
	}

	protected function renderSpecialTokens(array $values) {
	$result = array();
	foreach ($this->getUsableDatasources() as $source) {
	$special = $source->renderSpecialTokens($values);
	foreach ($special as $key => $token) {
	$result[$key] = $token;
	unset($values[$key]);
	}
	if (!$values) {
	break;
	}
	}
	return $result;
	}


	}
	diff --git a/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php b/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
	index 9fee4b2434..163b6c40b3 100644
	--- a/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
	+++ b/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
	@@ -1,503 +1,527 @@
	<?php

	/**
	* @task functions Token Functions
	*/
	abstract class PhabricatorTypeaheadDatasource extends Phobject {

	private $viewer;
	private $query;
	private $rawQuery;
	private $offset;
	private $limit;
	private $parameters = array();
	private $functionStack = array();
	private $isBrowse;
	+ private $phase = self::PHASE_CONTENT;
	+
	+ const PHASE_PREFIX = 'prefix';
	+ const PHASE_CONTENT = 'content';

	public function setLimit($limit) {
	$this->limit = $limit;
	return $this;
	}

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

	public function setOffset($offset) {
	$this->offset = $offset;
	return $this;
	}

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

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

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

	public function setRawQuery($raw_query) {
	$this->rawQuery = $raw_query;
	return $this;
	}

	+ public function getPrefixQuery() {
	+ return phutil_utf8_strtolower($this->getRawQuery());
	+ }
	+
	public function getRawQuery() {
	return $this->rawQuery;
	}

	public function setQuery($query) {
	$this->query = $query;
	return $this;
	}

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

	public function setParameters(array $params) {
	$this->parameters = $params;
	return $this;
	}

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

	public function getParameter($name, $default = null) {
	return idx($this->parameters, $name, $default);
	}

	public function setIsBrowse($is_browse) {
	$this->isBrowse = $is_browse;
	return $this;
	}

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

	+ public function setPhase($phase) {
	+ $this->phase = $phase;
	+ return $this;
	+ }
	+
	+ public function getPhase() {
	+ return $this->phase;
	+ }
	+
	public function getDatasourceURI() {
	$uri = new PhutilURI('/typeahead/class/'.get_class($this).'/');
	$uri->setQueryParams($this->parameters);
	return (string)$uri;
	}

	public function getBrowseURI() {
	if (!$this->isBrowsable()) {
	return null;
	}

	$uri = new PhutilURI('/typeahead/browse/'.get_class($this).'/');
	$uri->setQueryParams($this->parameters);
	return (string)$uri;
	}

	abstract public function getPlaceholderText();

	public function getBrowseTitle() {
	return get_class($this);
	}

	abstract public function getDatasourceApplicationClass();
	abstract public function loadResults();

	+ protected function loadResultsForPhase($phase, $limit) {
	+ // By default, sources just load all of their results in every phase and
	+ // rely on filtering at a higher level to sequence phases correctly.
	+ $this->setLimit($limit);
	+ return $this->loadResults();
	+ }
	+
	protected function didLoadResults(array $results) {
	return $results;
	}

	public static function tokenizeString($string) {
	$string = phutil_utf8_strtolower($string);
	$string = trim($string);
	if (!strlen($string)) {
	return array();
	}

	$tokens = preg_split('/\s+\|[-\[\]]/u', $string);
	return array_unique($tokens);
	}

	public function getTokens() {
	return self::tokenizeString($this->getRawQuery());
	}

	protected function executeQuery(
	PhabricatorCursorPagedPolicyAwareQuery $query) {

	return $query
	->setViewer($this->getViewer())
	->setOffset($this->getOffset())
	->setLimit($this->getLimit())
	->execute();
	}


	/**
	* Can the user browse through results from this datasource?
	*
	* Browsable datasources allow the user to switch from typeahead mode to
	* a browse mode where they can scroll through all results.
	*
	* By default, datasources are browsable, but some datasources can not
	* generate a meaningful result set or can't filter results on the server.
	*
	* @return bool
	*/
	public function isBrowsable() {
	return true;
	}


	/**
	* Filter a list of results, removing items which don't match the query
	* tokens.
	*
	* This is useful for datasources which return a static list of hard-coded
	* or configured results and can't easily do query filtering in a real
	* query class. Instead, they can just build the entire result set and use
	* this method to filter it.
	*
	* For datasources backed by database objects, this is often much less
	* efficient than filtering at the query level.
	*
	* @param list<PhabricatorTypeaheadResult> List of typeahead results.
	* @return list<PhabricatorTypeaheadResult> Filtered results.
	*/
	protected function filterResultsAgainstTokens(array $results) {
	$tokens = $this->getTokens();
	if (!$tokens) {
	return $results;
	}

	$map = array();
	foreach ($tokens as $token) {
	$map[$token] = strlen($token);
	}

	foreach ($results as $key => $result) {
	$rtokens = self::tokenizeString($result->getName());

	// For each token in the query, we need to find a match somewhere
	// in the result name.
	foreach ($map as $token => $length) {
	// Look for a match.
	$match = false;
	foreach ($rtokens as $rtoken) {
	if (!strncmp($rtoken, $token, $length)) {
	// This part of the result name has the query token as a prefix.
	$match = true;
	break;
	}
	}

	if (!$match) {
	// We didn't find a match for this query token, so throw the result
	// away. Try with the next result.
	unset($results[$key]);
	break;
	}
	}
	}

	return $results;
	}

	protected function newFunctionResult() {
	return id(new PhabricatorTypeaheadResult())
	->setTokenType(PhabricatorTypeaheadTokenView::TYPE_FUNCTION)
	->setIcon('fa-asterisk')
	->addAttribute(pht('Function'));
	}

	public function newInvalidToken($name) {
	return id(new PhabricatorTypeaheadTokenView())
	->setValue($name)
	->setIcon('fa-exclamation-circle')
	->setTokenType(PhabricatorTypeaheadTokenView::TYPE_INVALID);
	}

	public function renderTokens(array $values) {
	$phids = array();
	$setup = array();
	$tokens = array();

	foreach ($values as $key => $value) {
	if (!self::isFunctionToken($value)) {
	$phids[$key] = $value;
	} else {
	$function = $this->parseFunction($value);
	if ($function) {
	$setup[$function['name']][$key] = $function;
	} else {
	$name = pht('Invalid Function: %s', $value);
	$tokens[$key] = $this->newInvalidToken($name)
	->setKey($value);
	}
	}
	}

	// Give special non-function tokens which are also not PHIDs (like statuses
	// and priorities) an opportunity to render.
	$type_unknown = PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN;
	$special = array();
	foreach ($values as $key => $value) {
	if (phid_get_type($value) == $type_unknown) {
	$special[$key] = $value;
	}
	}

	if ($special) {
	$special_tokens = $this->renderSpecialTokens($special);
	foreach ($special_tokens as $key => $token) {
	$tokens[$key] = $token;
	unset($phids[$key]);
	}
	}

	if ($phids) {
	$handles = $this->getViewer()->loadHandles($phids);
	foreach ($phids as $key => $phid) {
	$handle = $handles[$phid];
	$tokens[$key] = PhabricatorTypeaheadTokenView::newFromHandle($handle);
	}
	}

	if ($setup) {
	foreach ($setup as $function_name => $argv_list) {
	// Render the function tokens.
	$function_tokens = $this->renderFunctionTokens(
	$function_name,
	ipull($argv_list, 'argv'));

	// Rekey the function tokens using the original array keys.
	$function_tokens = array_combine(
	array_keys($argv_list),
	$function_tokens);

	// For any functions which were invalid, set their value to the
	// original input value before it was parsed.
	foreach ($function_tokens as $key => $token) {
	$type = $token->getTokenType();
	if ($type == PhabricatorTypeaheadTokenView::TYPE_INVALID) {
	$token->setKey($values[$key]);
	}
	}

	$tokens += $function_tokens;
	}
	}

	return array_select_keys($tokens, array_keys($values));
	}

	protected function renderSpecialTokens(array $values) {
	return array();
	}

	/* -( Token Functions )---------------------------------------------------- */


	/**
	* @task functions
	*/
	public function getDatasourceFunctions() {
	return array();
	}


	/**
	* @task functions
	*/
	public function getAllDatasourceFunctions() {
	return $this->getDatasourceFunctions();
	}


	/**
	* @task functions
	*/
	protected function canEvaluateFunction($function) {
	return $this->shouldStripFunction($function);
	}


	/**
	* @task functions
	*/
	protected function shouldStripFunction($function) {
	$functions = $this->getDatasourceFunctions();
	return isset($functions[$function]);
	}


	/**
	* @task functions
	*/
	protected function evaluateFunction($function, array $argv_list) {
	throw new PhutilMethodNotImplementedException();
	}


	/**
	* @task functions
	*/
	protected function evaluateValues(array $values) {
	return $values;
	}


	/**
	* @task functions
	*/
	public function evaluateTokens(array $tokens) {
	$results = array();
	$evaluate = array();
	foreach ($tokens as $token) {
	if (!self::isFunctionToken($token)) {
	$results[] = $token;
	} else {
	$evaluate[] = $token;
	}
	}

	$results = $this->evaluateValues($results);

	foreach ($evaluate as $function) {
	$function = self::parseFunction($function);
	if (!$function) {
	throw new PhabricatorTypeaheadInvalidTokenException();
	}

	$name = $function['name'];
	$argv = $function['argv'];

	foreach ($this->evaluateFunction($name, array($argv)) as $phid) {
	$results[] = $phid;
	}
	}

	$results = $this->didEvaluateTokens($results);

	return $results;
	}


	/**
	* @task functions
	*/
	protected function didEvaluateTokens(array $results) {
	return $results;
	}


	/**
	* @task functions
	*/
	public static function isFunctionToken($token) {
	// We're looking for a "(" so that a string like "members(q" is identified
	// and parsed as a function call. This allows us to start generating
	// results immeidately, before the user fully types out "members(quack)".
	return (strpos($token, '(') !== false);
	}


	/**
	* @task functions
	*/
	public function parseFunction($token, $allow_partial = false) {
	$matches = null;

	if ($allow_partial) {
	$ok = preg_match('/^([^(]+)$(.*?)$?$/', $token, $matches);
	} else {
	$ok = preg_match('/^([^(]+)$(.*)$$/', $token, $matches);
	}

	if (!$ok) {
	return null;
	}

	$function = trim($matches[1]);

	if (!$this->canEvaluateFunction($function)) {
	return null;
	}

	return array(
	'name' => $function,
	'argv' => array(trim($matches[2])),
	);
	}


	/**
	* @task functions
	*/
	public function renderFunctionTokens($function, array $argv_list) {
	throw new PhutilMethodNotImplementedException();
	}


	/**
	* @task functions
	*/
	public function setFunctionStack(array $function_stack) {
	$this->functionStack = $function_stack;
	return $this;
	}


	/**
	* @task functions
	*/
	public function getFunctionStack() {
	return $this->functionStack;
	}


	/**
	* @task functions
	*/
	protected function getCurrentFunction() {
	return nonempty(last($this->functionStack), null);
	}

	protected function renderTokensFromResults(array $results, array $values) {
	$tokens = array();
	foreach ($values as $key => $value) {
	if (empty($results[$value])) {
	continue;
	}
	$tokens[$key] = PhabricatorTypeaheadTokenView::newFromTypeaheadResult(
	$results[$value]);
	}

	return $tokens;
	}

	public function getWireTokens(array $values) {
	// TODO: This is a bit hacky for now: we're sort of generating wire
	// results, rendering them, then reverting them back to wire results. This
	// is pretty silly. It would probably be much cleaner to make
	// renderTokens() call this method instead, then render from the result
	// structure.
	$rendered = $this->renderTokens($values);

	$tokens = array();
	foreach ($rendered as $key => $render) {
	$tokens[$key] = id(new PhabricatorTypeaheadResult())
	->setPHID($render->getKey())
	->setIcon($render->getIcon())
	->setColor($render->getColor())
	->setDisplayName($render->getValue())
	->setTokenType($render->getTokenType());
	}

	return mpull($tokens, 'getWireFormat', 'getPHID');
	}

	}
	diff --git a/src/applications/typeahead/storage/PhabricatorTypeaheadResult.php b/src/applications/typeahead/storage/PhabricatorTypeaheadResult.php
	index 4c5c079734..14cbe726dc 100644
	--- a/src/applications/typeahead/storage/PhabricatorTypeaheadResult.php
	+++ b/src/applications/typeahead/storage/PhabricatorTypeaheadResult.php
	@@ -1,214 +1,225 @@
	<?php

	final class PhabricatorTypeaheadResult extends Phobject {

	private $name;
	private $uri;
	private $phid;
	private $priorityString;
	private $displayName;
	private $displayType;
	private $imageURI;
	private $priorityType;
	private $imageSprite;
	private $icon;
	private $color;
	private $closed;
	private $tokenType;
	private $unique;
	private $autocomplete;
	private $attributes = array();
	+ private $phase;

	public function setIcon($icon) {
	$this->icon = $icon;
	return $this;
	}

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

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

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

	public function setPriorityString($priority_string) {
	$this->priorityString = $priority_string;
	return $this;
	}

	public function setDisplayName($display_name) {
	$this->displayName = $display_name;
	return $this;
	}

	public function setDisplayType($display_type) {
	$this->displayType = $display_type;
	return $this;
	}

	public function setImageURI($image_uri) {
	$this->imageURI = $image_uri;
	return $this;
	}

	public function setPriorityType($priority_type) {
	$this->priorityType = $priority_type;
	return $this;
	}

	public function setImageSprite($image_sprite) {
	$this->imageSprite = $image_sprite;
	return $this;
	}

	public function setClosed($closed) {
	$this->closed = $closed;
	return $this;
	}

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

	public function getDisplayName() {
	return coalesce($this->displayName, $this->getName());
	}

	public function getIcon() {
	return nonempty($this->icon, $this->getDefaultIcon());
	}

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

	public function setUnique($unique) {
	$this->unique = $unique;
	return $this;
	}

	public function setTokenType($type) {
	$this->tokenType = $type;
	return $this;
	}

	public function getTokenType() {
	if ($this->closed && !$this->tokenType) {
	return PhabricatorTypeaheadTokenView::TYPE_DISABLED;
	}
	return $this->tokenType;
	}

	public function setColor($color) {
	$this->color = $color;
	return $this;
	}

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

	public function setAutocomplete($autocomplete) {
	$this->autocomplete = $autocomplete;
	return $this;
	}

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

	public function getSortKey() {
	// Put unique results (special parameter functions) ahead of other
	// results.
	if ($this->unique) {
	$prefix = 'A';
	} else {
	$prefix = 'B';
	}

	return $prefix.phutil_utf8_strtolower($this->getName());
	}

	public function getWireFormat() {
	$data = array(
	$this->name,
	$this->uri ? (string)$this->uri : null,
	$this->phid,
	$this->priorityString,
	$this->displayName,
	$this->displayType,
	$this->imageURI ? (string)$this->imageURI : null,
	$this->priorityType,
	$this->getIcon(),
	$this->closed,
	$this->imageSprite ? (string)$this->imageSprite : null,
	$this->color,
	$this->tokenType,
	$this->unique ? 1 : null,
	$this->autocomplete,
	+ $this->phase,
	);
	while (end($data) === null) {
	array_pop($data);
	}
	return $data;
	}

	/**
	* If the datasource did not specify an icon explicitly, try to select a
	* default based on PHID type.
	*/
	private function getDefaultIcon() {
	static $icon_map;
	if ($icon_map === null) {
	$types = PhabricatorPHIDType::getAllTypes();

	$map = array();
	foreach ($types as $type) {
	$icon = $type->getTypeIcon();
	if ($icon !== null) {
	$map[$type->getTypeConstant()] = $icon;
	}
	}

	$icon_map = $map;
	}

	$phid_type = phid_get_type($this->phid);
	if (isset($icon_map[$phid_type])) {
	return $icon_map[$phid_type];
	}

	return null;
	}

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

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

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

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

	public function addAttribute($attribute) {
	$this->attributes[] = $attribute;
	return $this;
	}

	+ public function setPhase($phase) {
	+ $this->phase = $phase;
	+ return $this;
	+ }
	+
	+ public function getPhase() {
	+ return $this->phase;
	+ }
	+
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Nov 6, 4:04 AM (20 h, 49 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 321442
Default Alt Text: (87 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions