No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/daemon/controller/PhabricatorDaemonLogViewController.php b/src/applications/daemon/controller/PhabricatorDaemonLogViewController.php
	index f4c7ba60c9..253a3d5190 100644
	--- a/src/applications/daemon/controller/PhabricatorDaemonLogViewController.php
	+++ b/src/applications/daemon/controller/PhabricatorDaemonLogViewController.php
	@@ -1,180 +1,181 @@
	<?php

	final class PhabricatorDaemonLogViewController
	extends PhabricatorDaemonController {

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

	$log = id(new PhabricatorDaemonLogQuery())
	->setViewer($viewer)
	->withIDs(array($id))
	->setAllowStatusWrites(true)
	->executeOne();
	if (!$log) {
	return new Aphront404Response();
	}

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(pht('Daemon %s', $log->getID()));
	$crumbs->setBorder(true);

	$header = id(new PHUIHeaderView())
	->setHeader($log->getDaemon())
	->setHeaderIcon('fa-pied-piper-alt');

	$tag = id(new PHUITagView())
	->setType(PHUITagView::TYPE_STATE);

	$status = $log->getStatus();
	switch ($status) {
	case PhabricatorDaemonLog::STATUS_UNKNOWN:
	$color = 'orange';
	$name = pht('Unknown');
	$icon = 'fa-warning';
	break;
	case PhabricatorDaemonLog::STATUS_RUNNING:
	$color = 'green';
	$name = pht('Running');
	$icon = 'fa-rocket';
	break;
	case PhabricatorDaemonLog::STATUS_DEAD:
	$color = 'red';
	$name = pht('Dead');
	$icon = 'fa-times';
	break;
	case PhabricatorDaemonLog::STATUS_WAIT:
	$color = 'blue';
	$name = pht('Waiting');
	$icon = 'fa-clock-o';
	break;
	case PhabricatorDaemonLog::STATUS_EXITING:
	$color = 'yellow';
	$name = pht('Exiting');
	$icon = 'fa-check';
	break;
	case PhabricatorDaemonLog::STATUS_EXITED:
	$color = 'bluegrey';
	$name = pht('Exited');
	$icon = 'fa-check';
	break;
	}

	$header->setStatus($icon, $color, $name);

	$properties = $this->buildPropertyListView($log);

	$object_box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Daemon Details'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->addPropertyList($properties);

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

	return $this->newPage()
	->setTitle(pht('Daemon Log'))
	->setCrumbs($crumbs)
	->appendChild($view);

	}

	private function buildPropertyListView(PhabricatorDaemonLog $daemon) {
	$request = $this->getRequest();
	$viewer = $request->getUser();

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

	$id = $daemon->getID();
	$c_epoch = $daemon->getDateCreated();
	$u_epoch = $daemon->getDateModified();

	$unknown_time = PhabricatorDaemonLogQuery::getTimeUntilUnknown();
	$dead_time = PhabricatorDaemonLogQuery::getTimeUntilDead();
	$wait_time = PhutilDaemonHandle::getWaitBeforeRestart();

	$details = null;
	$status = $daemon->getStatus();
	switch ($status) {
	case PhabricatorDaemonLog::STATUS_RUNNING:
	$details = pht(
	'This daemon is running normally and reported a status update '.
	'recently (within %s).',
	phutil_format_relative_time($unknown_time));
	break;
	case PhabricatorDaemonLog::STATUS_UNKNOWN:
	$details = pht(
	'This daemon has not reported a status update recently (within %s). '.
	'It may have exited abruptly. After %s, it will be presumed dead.',
	phutil_format_relative_time($unknown_time),
	phutil_format_relative_time($dead_time));
	break;
	case PhabricatorDaemonLog::STATUS_DEAD:
	$details = pht(
	'This daemon did not report a status update for %s. It is '.
	'presumed dead. Usually, this indicates that the daemon was '.
	'killed or otherwise exited abruptly with an error. You may '.
	'need to restart it.',
	phutil_format_relative_time($dead_time));
	break;
	case PhabricatorDaemonLog::STATUS_WAIT:
	$details = pht(
	'This daemon is running normally and reported a status update '.
	'recently (within %s). The process is currently waiting to '.
	'restart, either because it is hibernating or because it '.
	'encountered an error.',
	phutil_format_relative_time($unknown_time));
	break;
	case PhabricatorDaemonLog::STATUS_EXITING:
	$details = pht('This daemon is shutting down gracefully.');
	break;
	case PhabricatorDaemonLog::STATUS_EXITED:
	$details = pht('This daemon exited normally and is no longer running.');
	break;
	}

	$view->addProperty(pht('Status Details'), $details);

	$view->addProperty(pht('Daemon Class'), $daemon->getDaemon());
	$view->addProperty(pht('Host'), $daemon->getHost());
	$view->addProperty(pht('PID'), $daemon->getPID());
	$view->addProperty(pht('Running as'), $daemon->getRunningAsUser());
	$view->addProperty(pht('Started'), phabricator_datetime($c_epoch, $viewer));
	$view->addProperty(
	pht('Seen'),
	pht(
	'%s ago (%s)',
	phutil_format_relative_time(time() - $u_epoch),
	phabricator_datetime($u_epoch, $viewer)));

	$argv = $daemon->getArgv();
	if (is_array($argv)) {
	$argv = implode("\n", $argv);
	}

	$view->addProperty(
	pht('Argv'),
	phutil_tag(
	'textarea',
	array(
	'style' => 'width: 100%; height: 12em;',
	),
	$argv));

	$view->addProperty(
	pht('View Full Logs'),
	phutil_tag(
	'tt',
	array(),
	- "phabricator/ $ ./bin/phd log --id {$id}"));
	+ PlatformSymbols::getPlatformServerPath().
	+ " $ ./bin/phd log --id {$id}"));


	return $view;
	}

	}
	diff --git a/src/applications/diffusion/controller/DiffusionRepositoryEditDeleteController.php b/src/applications/diffusion/controller/DiffusionRepositoryEditDeleteController.php
	index 93fe70c0fe..72e18d17e8 100644
	--- a/src/applications/diffusion/controller/DiffusionRepositoryEditDeleteController.php
	+++ b/src/applications/diffusion/controller/DiffusionRepositoryEditDeleteController.php
	@@ -1,47 +1,48 @@
	<?php

	final class DiffusionRepositoryEditDeleteController
	extends DiffusionRepositoryManageController {

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

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

	$panel_uri = id(new DiffusionRepositoryBasicsManagementPanel())
	->setRepository($repository)
	->getPanelURI();

	$doc_uri = PhabricatorEnv::getDoclink(
	'Permanently Destroying Data');

	return $this->newDialog()
	->setTitle(pht('Delete Repository'))
	->appendParagraph(
	pht(
	'To permanently destroy this repository, run this command from '.
	'the command line:'))
	->appendCommand(
	csprintf(
	- 'phabricator/ $ ./bin/remove destroy %R',
	+ '%s $ ./bin/remove destroy %R',
	+ PlatformSymbols::getPlatformServerPath(),
	$repository->getMonogram()))
	->appendParagraph(
	pht(
	'Repositories can not be permanently destroyed from the web '.
	'interface. See %s in the documentation for more information.',
	phutil_tag(
	'a',
	array(
	'href' => $doc_uri,
	'target' => '_blank',
	),
	pht('Permanently Destroying Data'))))
	->addCancelButton($panel_uri, pht('Close'));
	}

	}
	diff --git a/src/applications/metamta/PhabricatorMetaMTAWorker.php b/src/applications/metamta/PhabricatorMetaMTAWorker.php
	index dcc6a8dc5e..7d7c51f8b2 100644
	--- a/src/applications/metamta/PhabricatorMetaMTAWorker.php
	+++ b/src/applications/metamta/PhabricatorMetaMTAWorker.php
	@@ -1,53 +1,54 @@
	<?php

	final class PhabricatorMetaMTAWorker
	extends PhabricatorWorker {

	public function getMaximumRetryCount() {
	return 250;
	}

	public function getWaitBeforeRetry(PhabricatorWorkerTask $task) {
	return ($task->getFailureCount() * 15);
	}

	protected function doWork() {
	$message = $this->loadMessage();

	if ($message->getStatus() != PhabricatorMailOutboundStatus::STATUS_QUEUE) {
	return;
	}

	try {
	$message->sendNow();
	} catch (PhabricatorMetaMTAPermanentFailureException $ex) {
	// If the mailer fails permanently, fail this task permanently.
	throw new PhabricatorWorkerPermanentFailureException($ex->getMessage());
	}
	}

	private function loadMessage() {
	$message_id = $this->getTaskData();
	$message = id(new PhabricatorMetaMTAMail())
	->load($message_id);

	if (!$message) {
	throw new PhabricatorWorkerPermanentFailureException(
	pht(
	'Unable to load mail message (with ID "%s") while preparing to '.
	'deliver it.',
	$message_id));
	}

	return $message;
	}

	public function renderForDisplay(PhabricatorUser $viewer) {
	return phutil_tag(
	'pre',
	- array(
	- ),
	- 'phabricator/ $ ./bin/mail show-outbound --id '.$this->getTaskData());
	+ array(),
	+ PlatformSymbols::getPlatformServerPath().
	+ ' $ ./bin/mail show-outbound --id '.
	+ $this->getTaskData());
	}

	}
	diff --git a/src/applications/repository/query/PhabricatorRepositoryQuery.php b/src/applications/repository/query/PhabricatorRepositoryQuery.php
	index 05b011e85a..17a46f7b62 100644
	--- a/src/applications/repository/query/PhabricatorRepositoryQuery.php
	+++ b/src/applications/repository/query/PhabricatorRepositoryQuery.php
	@@ -1,706 +1,710 @@
	<?php

	final class PhabricatorRepositoryQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $callsigns;
	private $types;
	private $uuids;
	private $uris;
	private $datasourceQuery;
	private $slugs;
	private $almanacServicePHIDs;

	private $numericIdentifiers;
	private $callsignIdentifiers;
	private $phidIdentifiers;
	private $monogramIdentifiers;
	private $slugIdentifiers;

	private $identifierMap;

	const STATUS_OPEN = 'status-open';
	const STATUS_CLOSED = 'status-closed';
	const STATUS_ALL = 'status-all';
	private $status = self::STATUS_ALL;

	const HOSTED_PHABRICATOR = 'hosted-phab';
	const HOSTED_REMOTE = 'hosted-remote';
	const HOSTED_ALL = 'hosted-all';
	private $hosted = self::HOSTED_ALL;

	private $needMostRecentCommits;
	private $needCommitCounts;
	private $needProjectPHIDs;
	private $needURIs;
	private $needProfileImage;

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

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

	public function withCallsigns(array $callsigns) {
	$this->callsigns = $callsigns;
	return $this;
	}

	public function withIdentifiers(array $identifiers) {
	$identifiers = array_fuse($identifiers);

	$ids = array();
	$callsigns = array();
	$phids = array();
	$monograms = array();
	$slugs = array();

	foreach ($identifiers as $identifier) {
	+ if ($identifier === null) {
	+ continue;
	+ }
	+
	if (ctype_digit((string)$identifier)) {
	$ids[$identifier] = $identifier;
	continue;
	}

	if (preg_match('/^(r[A-Z]+\|R[1-9]\d*)\z/', $identifier)) {
	$monograms[$identifier] = $identifier;
	continue;
	}

	$repository_type = PhabricatorRepositoryRepositoryPHIDType::TYPECONST;
	if (phid_get_type($identifier) === $repository_type) {
	$phids[$identifier] = $identifier;
	continue;
	}

	if (preg_match('/^[A-Z]+\z/', $identifier)) {
	$callsigns[$identifier] = $identifier;
	continue;
	}

	$slugs[$identifier] = $identifier;
	}

	$this->numericIdentifiers = $ids;
	$this->callsignIdentifiers = $callsigns;
	$this->phidIdentifiers = $phids;
	$this->monogramIdentifiers = $monograms;
	$this->slugIdentifiers = $slugs;

	return $this;
	}

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

	public function withHosted($hosted) {
	$this->hosted = $hosted;
	return $this;
	}

	public function withTypes(array $types) {
	$this->types = $types;
	return $this;
	}

	public function withUUIDs(array $uuids) {
	$this->uuids = $uuids;
	return $this;
	}

	public function withURIs(array $uris) {
	$this->uris = $uris;
	return $this;
	}

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

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

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

	public function needCommitCounts($need_counts) {
	$this->needCommitCounts = $need_counts;
	return $this;
	}

	public function needMostRecentCommits($need_commits) {
	$this->needMostRecentCommits = $need_commits;
	return $this;
	}

	public function needProjectPHIDs($need_phids) {
	$this->needProjectPHIDs = $need_phids;
	return $this;
	}

	public function needURIs($need_uris) {
	$this->needURIs = $need_uris;
	return $this;
	}

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

	public function getBuiltinOrders() {
	return array(
	'committed' => array(
	'vector' => array('committed', 'id'),
	'name' => pht('Most Recent Commit'),
	),
	'name' => array(
	'vector' => array('name', 'id'),
	'name' => pht('Name'),
	),
	'callsign' => array(
	'vector' => array('callsign'),
	'name' => pht('Callsign'),
	),
	'size' => array(
	'vector' => array('size', 'id'),
	'name' => pht('Size'),
	),
	) + parent::getBuiltinOrders();
	}

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

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

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

	protected function loadPage() {
	$table = $this->newResultObject();
	$data = $this->loadStandardPageRows($table);
	$repositories = $table->loadAllFromArray($data);

	if ($this->needCommitCounts) {
	$sizes = ipull($data, 'size', 'id');
	foreach ($repositories as $id => $repository) {
	$repository->attachCommitCount(nonempty($sizes[$id], 0));
	}
	}

	if ($this->needMostRecentCommits) {
	$commit_ids = ipull($data, 'lastCommitID', 'id');
	$commit_ids = array_filter($commit_ids);
	if ($commit_ids) {
	$commits = id(new DiffusionCommitQuery())
	->setViewer($this->getViewer())
	->withIDs($commit_ids)
	->needCommitData(true)
	->needIdentities(true)
	->execute();
	} else {
	$commits = array();
	}
	foreach ($repositories as $id => $repository) {
	$commit = null;
	if (idx($commit_ids, $id)) {
	$commit = idx($commits, $commit_ids[$id]);
	}
	$repository->attachMostRecentCommit($commit);
	}
	}

	return $repositories;
	}

	protected function willFilterPage(array $repositories) {
	assert_instances_of($repositories, 'PhabricatorRepository');

	// TODO: Denormalize repository status into the PhabricatorRepository
	// table so we can do this filtering in the database.
	foreach ($repositories as $key => $repo) {
	$status = $this->status;
	switch ($status) {
	case self::STATUS_OPEN:
	if (!$repo->isTracked()) {
	unset($repositories[$key]);
	}
	break;
	case self::STATUS_CLOSED:
	if ($repo->isTracked()) {
	unset($repositories[$key]);
	}
	break;
	case self::STATUS_ALL:
	break;
	default:
	throw new Exception("Unknown status '{$status}'!");
	}

	// TODO: This should also be denormalized.
	$hosted = $this->hosted;
	switch ($hosted) {
	case self::HOSTED_PHABRICATOR:
	if (!$repo->isHosted()) {
	unset($repositories[$key]);
	}
	break;
	case self::HOSTED_REMOTE:
	if ($repo->isHosted()) {
	unset($repositories[$key]);
	}
	break;
	case self::HOSTED_ALL:
	break;
	default:
	throw new Exception(pht("Unknown hosted failed '%s'!", $hosted));
	}
	}

	// Build the identifierMap
	if ($this->numericIdentifiers) {
	foreach ($this->numericIdentifiers as $id) {
	if (isset($repositories[$id])) {
	$this->identifierMap[$id] = $repositories[$id];
	}
	}
	}

	if ($this->callsignIdentifiers) {
	$repository_callsigns = mpull($repositories, null, 'getCallsign');

	foreach ($this->callsignIdentifiers as $callsign) {
	if (isset($repository_callsigns[$callsign])) {
	$this->identifierMap[$callsign] = $repository_callsigns[$callsign];
	}
	}
	}

	if ($this->phidIdentifiers) {
	$repository_phids = mpull($repositories, null, 'getPHID');

	foreach ($this->phidIdentifiers as $phid) {
	if (isset($repository_phids[$phid])) {
	$this->identifierMap[$phid] = $repository_phids[$phid];
	}
	}
	}

	if ($this->monogramIdentifiers) {
	$monogram_map = array();
	foreach ($repositories as $repository) {
	foreach ($repository->getAllMonograms() as $monogram) {
	$monogram_map[$monogram] = $repository;
	}
	}

	foreach ($this->monogramIdentifiers as $monogram) {
	if (isset($monogram_map[$monogram])) {
	$this->identifierMap[$monogram] = $monogram_map[$monogram];
	}
	}
	}

	if ($this->slugIdentifiers) {
	$slug_map = array();
	foreach ($repositories as $repository) {
	$slug = $repository->getRepositorySlug();
	if ($slug === null) {
	continue;
	}

	$normal = phutil_utf8_strtolower($slug);
	$slug_map[$normal] = $repository;
	}

	foreach ($this->slugIdentifiers as $slug) {
	$normal = phutil_utf8_strtolower($slug);
	if (isset($slug_map[$normal])) {
	$this->identifierMap[$slug] = $slug_map[$normal];
	}
	}
	}

	return $repositories;
	}

	protected function didFilterPage(array $repositories) {
	if ($this->needProjectPHIDs) {
	$type_project = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;

	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(mpull($repositories, 'getPHID'))
	->withEdgeTypes(array($type_project));
	$edge_query->execute();

	foreach ($repositories as $repository) {
	$project_phids = $edge_query->getDestinationPHIDs(
	array(
	$repository->getPHID(),
	));
	$repository->attachProjectPHIDs($project_phids);
	}
	}

	$viewer = $this->getViewer();

	if ($this->needURIs) {
	$uris = id(new PhabricatorRepositoryURIQuery())
	->setViewer($viewer)
	->withRepositories($repositories)
	->execute();
	$uri_groups = mgroup($uris, 'getRepositoryPHID');
	foreach ($repositories as $repository) {
	$repository_uris = idx($uri_groups, $repository->getPHID(), array());
	$repository->attachURIs($repository_uris);
	}
	}

	if ($this->needProfileImage) {
	$default = null;

	$file_phids = mpull($repositories, '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 ($repositories as $repository) {
	$file = idx($files, $repository->getProfileImagePHID());
	if (!$file) {
	if (!$default) {
	$default = PhabricatorFile::loadBuiltin(
	$this->getViewer(),
	'repo/code.png');
	}
	$file = $default;
	}
	$repository->attachProfileImageFile($file);
	}
	}

	return $repositories;
	}

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

	public function getOrderableColumns() {
	return parent::getOrderableColumns() + array(
	'committed' => array(
	'table' => 's',
	'column' => 'epoch',
	'type' => 'int',
	'null' => 'tail',
	),
	'callsign' => array(
	'table' => 'r',
	'column' => 'callsign',
	'type' => 'string',
	'unique' => true,
	'reverse' => true,
	'null' => 'tail',
	),
	'name' => array(
	'table' => 'r',
	'column' => 'name',
	'type' => 'string',
	'reverse' => true,
	),
	'size' => array(
	'table' => 's',
	'column' => 'size',
	'type' => 'int',
	'null' => 'tail',
	),
	);
	}

	protected function newPagingMapFromCursorObject(
	PhabricatorQueryCursor $cursor,
	array $keys) {

	$repository = $cursor->getObject();

	$map = array(
	'id' => (int)$repository->getID(),
	'callsign' => $repository->getCallsign(),
	'name' => $repository->getName(),
	);

	if (isset($keys['committed'])) {
	$map['committed'] = $cursor->getRawRowProperty('epoch');
	}

	if (isset($keys['size'])) {
	$map['size'] = $cursor->getRawRowProperty('size');
	}

	return $map;
	}

	protected function buildSelectClauseParts(AphrontDatabaseConnection $conn) {
	$parts = parent::buildSelectClauseParts($conn);

	if ($this->shouldJoinSummaryTable()) {
	$parts[] = qsprintf($conn, 's.*');
	}

	return $parts;
	}

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

	if ($this->shouldJoinSummaryTable()) {
	$joins[] = qsprintf(
	$conn,
	'LEFT JOIN %T s ON r.id = s.repositoryID',
	PhabricatorRepository::TABLE_SUMMARY);
	}

	if ($this->shouldJoinURITable()) {
	$joins[] = qsprintf(
	$conn,
	'LEFT JOIN %R uri ON r.phid = uri.repositoryPHID',
	new PhabricatorRepositoryURIIndex());
	}

	return $joins;
	}

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

	return parent::shouldGroupQueryResultRows();
	}

	private function shouldJoinURITable() {
	return ($this->uris !== null);
	}

	private function shouldJoinSummaryTable() {
	if ($this->needCommitCounts) {
	return true;
	}

	if ($this->needMostRecentCommits) {
	return true;
	}

	$vector = $this->getOrderVector();
	if ($vector->containsKey('committed')) {
	return true;
	}

	if ($vector->containsKey('size')) {
	return true;
	}

	return false;
	}

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

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

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

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

	if ($this->numericIdentifiers \|\|
	$this->callsignIdentifiers \|\|
	$this->phidIdentifiers \|\|
	$this->monogramIdentifiers \|\|
	$this->slugIdentifiers) {
	$identifier_clause = array();

	if ($this->numericIdentifiers) {
	$identifier_clause[] = qsprintf(
	$conn,
	'r.id IN (%Ld)',
	$this->numericIdentifiers);
	}

	if ($this->callsignIdentifiers) {
	$identifier_clause[] = qsprintf(
	$conn,
	'r.callsign IN (%Ls)',
	$this->callsignIdentifiers);
	}

	if ($this->phidIdentifiers) {
	$identifier_clause[] = qsprintf(
	$conn,
	'r.phid IN (%Ls)',
	$this->phidIdentifiers);
	}

	if ($this->monogramIdentifiers) {
	$monogram_callsigns = array();
	$monogram_ids = array();

	foreach ($this->monogramIdentifiers as $identifier) {
	if ($identifier[0] == 'r') {
	$monogram_callsigns[] = substr($identifier, 1);
	} else {
	$monogram_ids[] = substr($identifier, 1);
	}
	}

	if ($monogram_ids) {
	$identifier_clause[] = qsprintf(
	$conn,
	'r.id IN (%Ld)',
	$monogram_ids);
	}

	if ($monogram_callsigns) {
	$identifier_clause[] = qsprintf(
	$conn,
	'r.callsign IN (%Ls)',
	$monogram_callsigns);
	}
	}

	if ($this->slugIdentifiers) {
	$identifier_clause[] = qsprintf(
	$conn,
	'r.repositorySlug IN (%Ls)',
	$this->slugIdentifiers);
	}

	$where[] = qsprintf($conn, '%LO', $identifier_clause);
	}

	if ($this->types) {
	$where[] = qsprintf(
	$conn,
	'r.versionControlSystem IN (%Ls)',
	$this->types);
	}

	if ($this->uuids) {
	$where[] = qsprintf(
	$conn,
	'r.uuid IN (%Ls)',
	$this->uuids);
	}

	if (phutil_nonempty_string($this->datasourceQuery)) {
	// This handles having "rP" match callsigns starting with "P...".
	$query = trim($this->datasourceQuery);
	if (preg_match('/^r/', $query)) {
	$callsign = substr($query, 1);
	} else {
	$callsign = $query;
	}
	$where[] = qsprintf(
	$conn,
	'r.name LIKE %> OR r.callsign LIKE %> OR r.repositorySlug LIKE %>',
	$query,
	$callsign,
	$query);
	}

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

	if ($this->uris !== null) {
	$try_uris = $this->getNormalizedURIs();
	$try_uris = array_fuse($try_uris);

	$where[] = qsprintf(
	$conn,
	'uri.repositoryURI IN (%Ls)',
	$try_uris);
	}

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

	return $where;
	}

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

	private function getNormalizedURIs() {
	$normalized_uris = array();

	// Since we don't know which type of repository this URI is in the general
	// case, just generate all the normalizations. We could refine this in some
	// cases: if the query specifies VCS types, or the URI is a git-style URI
	// or an `svn+ssh` URI, we could deduce how to normalize it. However, this
	// would be more complicated and it's not clear if it matters in practice.

	$domain_map = PhabricatorRepositoryURI::getURINormalizerDomainMap();

	$types = ArcanistRepositoryURINormalizer::getAllURITypes();
	foreach ($this->uris as $uri) {
	foreach ($types as $type) {
	$normalized_uri = new ArcanistRepositoryURINormalizer($type, $uri);
	$normalized_uri->setDomainMap($domain_map);
	$normalized_uris[] = $normalized_uri->getNormalizedURI();
	}
	}

	return array_unique($normalized_uris);
	}

	}
	diff --git a/src/infrastructure/markup/markuprule/PhutilRemarkupEvalRule.php b/src/infrastructure/markup/markuprule/PhutilRemarkupEvalRule.php
	index cb67041c62..a525924fff 100644
	--- a/src/infrastructure/markup/markuprule/PhutilRemarkupEvalRule.php
	+++ b/src/infrastructure/markup/markuprule/PhutilRemarkupEvalRule.php
	@@ -1,100 +1,100 @@
	<?php

	final class PhutilRemarkupEvalRule extends PhutilRemarkupRule {

	const KEY_EVAL = 'eval';

	public function getPriority() {
	return 50;
	}

	public function apply($text) {
	return preg_replace_callback(
	'/\${{{(.+?)}}}/',
	array($this, 'newExpressionToken'),
	$text);
	}

	public function newExpressionToken(array $matches) {
	$expression = $matches[1];

	if (!$this->isFlatText($expression)) {
	return $matches[0];
	}

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

	$list_key = self::KEY_EVAL;
	$expression_list = $engine->getTextMetadata($list_key, array());

	$expression_list[] = array(
	'token' => $token,
	'expression' => $expression,
	'original' => $matches[0],
	);

	$engine->setTextMetadata($list_key, $expression_list);

	return $token;
	}

	public function didMarkupText() {
	$engine = $this->getEngine();

	$list_key = self::KEY_EVAL;
	$expression_list = $engine->getTextMetadata($list_key, array());

	foreach ($expression_list as $expression_item) {
	$token = $expression_item['token'];
	$expression = $expression_item['expression'];

	$result = $this->evaluateExpression($expression);

	if ($result === null) {
	$result = $expression_item['original'];
	}

	$engine->overwriteStoredText($token, $result);
	}
	}

	private function evaluateExpression($expression) {
	static $string_map;

	if ($string_map === null) {
	$string_map = array(
	'strings' => array(
	'platform' => array(
	'server' => array(
	'name' => PlatformSymbols::getPlatformServerName(),
	- 'path' => pht('phabricator/'),
	+ 'path' => PlatformSymbols::getPlatformServerPath(),
	),
	'client' => array(
	'name' => PlatformSymbols::getPlatformClientName(),
	- 'path' => pht('arcanist/'),
	+ 'path' => PlatformSymbols::getPlatformClientPath(),
	),
	),
	),
	);
	}

	$parts = explode('.', $expression);

	$cursor = $string_map;
	foreach ($parts as $part) {
	if (isset($cursor[$part])) {
	$cursor = $cursor[$part];
	} else {
	break;
	}
	}

	if (is_string($cursor)) {
	return $cursor;
	}

	return null;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Apr 29, 10:56 AM (1 d, 2 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 108310
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions