No OneTemporary
Actions

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/project/typeahead/PhabricatorProjectDatasource.php b/src/applications/project/typeahead/PhabricatorProjectDatasource.php
	index 5953f688d2..86478a5e1e 100644
	--- a/src/applications/project/typeahead/PhabricatorProjectDatasource.php
	+++ b/src/applications/project/typeahead/PhabricatorProjectDatasource.php
	@@ -1,157 +1,159 @@
	<?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, '#');
	+ if ($raw_query !== null) {
	+ $raw_query = ltrim($raw_query, '#');
	+ }
	$tokens = self::tokenizeString($raw_query);

	$query = id(new PhabricatorProjectQuery())
	->needImages(true)
	->needSlugs(true)
	->setOrderVector(array('-status', 'id'));

	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))
	->withIsProxyColumn(false)
	->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 (!phutil_nonempty_string($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();

	// NOTE: We list the project's name first because results will be
	// sorted into prefix vs content phases incorrectly if we don't: it
	// will look like "Parent (Milestone)" matched "Parent" as a prefix,
	// but it did not.
	$all_strings[] = $proj->getName();

	if ($proj->isMilestone()) {
	$all_strings[] = $proj->getParentProject()->getName();
	}

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

	$all_strings = implode("\n", $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 (phutil_nonempty_string($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)) {
	+ if (phutil_nonempty_string($description)) {
	$summary = PhabricatorMarkupEngine::summarizeSentence($description);
	$proj_result->addAttribute($summary);
	}
	}

	$results[] = $proj_result;
	}

	return $results;
	}

	}
	diff --git a/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php b/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php
	index d344425d30..8a396c1ed3 100644
	--- a/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php
	+++ b/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php
	@@ -1,333 +1,333 @@
	<?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())) {
	+ if (phutil_nonempty_string($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 ($is_browse) {
	$source->setIsBrowse(true);
	}

	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');

	$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) {
	if ($this->getOffset()) {
	$offset = $this->getOffset();
	} else {
	$offset = 0;
	}
	$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) {
	$viewer = $this->getViewer();

	$sources = $this->getComponentDatasources();

	$extension_sources = id(new PhabricatorDatasourceEngine())
	->setViewer($viewer)
	->newDatasourcesForCompositeDatasource($this);
	foreach ($extension_sources as $extension_source) {
	$sources[] = $extension_source;
	}

	$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($viewer);
	$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 29a8d4b7ba..a35a8e8f0f 100644
	--- a/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
	+++ b/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
	@@ -1,641 +1,645 @@
	<?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() {
	$params = $this->newURIParameters();
	$uri = new PhutilURI('/typeahead/class/'.get_class($this).'/', $params);
	return phutil_string_cast($uri);
	}

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

	$params = $this->newURIParameters();
	$uri = new PhutilURI('/typeahead/browse/'.get_class($this).'/', $params);
	return phutil_string_cast($uri);
	}

	private function newURIParameters() {
	if (!$this->parameters) {
	return array();
	}

	$map = array(
	'parameters' => phutil_json_encode($this->parameters),
	);

	return $map;
	}

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

	// NOTE: Splitting on "(" and ")" is important for milestones.

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

	// Make sure we don't return the empty token, as this will boil down to a
	// JOIN against every token.
	foreach ($tokens as $key => $value) {
	if (!strlen($value)) {
	unset($tokens[$key]);
	}
	}

	return array_values($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 {
	// Put a placeholder in the result list so that we retain token order
	// when possible. We'll overwrite this below.
	$results[] = null;
	$evaluate[last_key($results)] = $token;
	}
	}

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

	foreach ($evaluate as $result_key => $function) {
	$function = $this->parseFunction($function);
	if (!$function) {
	throw new PhabricatorTypeaheadInvalidTokenException();
	}

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

	$evaluated_tokens = $this->evaluateFunction($name, array($argv));
	if (!$evaluated_tokens) {
	unset($results[$result_key]);
	} else {
	$is_first = true;
	foreach ($evaluated_tokens as $phid) {
	if ($is_first) {
	$results[$result_key] = $phid;
	$is_first = false;
	} else {
	$results[] = $phid;
	}
	}
	}
	}

	$results = array_values($results);
	$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 immediately, before the user fully types out "members(quack)".
	- return (strpos($token, '(') !== false);
	+ if ($token) {
	+ return (strpos($token, '(') !== false);
	+ } else {
	+ return false;
	+ }
	}


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

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

	if (!$ok) {
	if (!$allow_partial) {
	throw new PhabricatorTypeaheadInvalidTokenException(
	pht(
	'Unable to parse function and arguments for token "%s".',
	$token));
	}
	return null;
	}

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

	if (!$this->canEvaluateFunction($function)) {
	if (!$allow_partial) {
	throw new PhabricatorTypeaheadInvalidTokenException(
	pht(
	'This datasource ("%s") can not evaluate the function "%s(...)".',
	get_class($this),
	$function));
	}

	return null;
	}

	// TODO: There is currently no way to quote characters in arguments, so
	// some characters can't be argument characters. Replace this with a real
	// parser once we get use cases.

	$argv = $matches[2];
	$argv = trim($argv);
	if (!strlen($argv)) {
	$argv = array();
	} else {
	$argv = preg_split('/,/', $matches[2]);
	foreach ($argv as $key => $arg) {
	$argv[$key] = trim($arg);
	}
	}

	foreach ($argv as $key => $arg) {
	if (self::isFunctionToken($arg)) {
	$subfunction = $this->parseFunction($arg);

	$results = $this->evaluateFunction(
	$subfunction['name'],
	array($subfunction['argv']));

	$argv[$key] = head($results);
	}
	}

	return array(
	'name' => $function,
	'argv' => $argv,
	);
	}


	/**
	* @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');
	}

	final protected function applyFerretConstraints(
	PhabricatorCursorPagedPolicyAwareQuery $query,
	PhabricatorFerretEngine $engine,
	$ferret_function,
	$raw_query) {

	$compiler = id(new PhutilSearchQueryCompiler())
	->setEnableFunctions(true);

	$raw_tokens = $compiler->newTokens($raw_query);

	$fulltext_tokens = array();
	foreach ($raw_tokens as $raw_token) {
	// This is a little hacky and could maybe be cleaner. We're treating
	// every search term as though the user had entered "title:dog" instead
	// of "dog".

	$alternate_token = PhutilSearchQueryToken::newFromDictionary(
	array(
	'quoted' => $raw_token->isQuoted(),
	'value' => $raw_token->getValue(),
	'operator' => PhutilSearchQueryCompiler::OPERATOR_SUBSTRING,
	'function' => $ferret_function,
	));

	$fulltext_token = id(new PhabricatorFulltextToken())
	->setToken($alternate_token);
	$fulltext_tokens[] = $fulltext_token;
	}

	$query->withFerretConstraint($engine, $fulltext_tokens);
	}


	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, May 1, 5:28 PM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 109054
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions