No OneTemporary
Actions

Size

52 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/audit/editor/PhabricatorAuditCommentEditor.php b/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	index 03476f70a7..8a17999ee0 100644
	--- a/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	+++ b/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	@@ -1,53 +1,53 @@
	<?php

	final class PhabricatorAuditCommentEditor extends PhabricatorEditor {

	/**
	* Load the PHIDs for all objects the user has the authority to act as an
	* audit for. This includes themselves, and any packages they are an owner
	* of.
	*/
	public static function loadAuditPHIDsForUser(PhabricatorUser $user) {
	$phids = array();

	// TODO: This method doesn't really use the right viewer, but in practice we
	// never issue this query of this type on behalf of another user and are
	// unlikely to do so in the future. This entire method should be refactored
	// into a Query class, however, and then we should use a proper viewer.

	// The user can audit on their own behalf.
	$phids[$user->getPHID()] = true;

	$owned_packages = id(new PhabricatorOwnersPackageQuery())
	->setViewer($user)
	->withAuthorityPHIDs(array($user->getPHID()))
	->execute();
	foreach ($owned_packages as $package) {
	$phids[$package->getPHID()] = true;
	}

	// The user can audit on behalf of all projects they are a member of.
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withMemberPHIDs(array($user->getPHID()))
	->execute();
	foreach ($projects as $project) {
	$phids[$project->getPHID()] = true;
	}

	return array_keys($phids);
	}

	public static function getMailThreading(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	return array(
	'diffusion-audit-'.$commit->getPHID(),
	pht(
	'Commit %s',
	- 'r'.$repository->getCallsign().$commit->getCommitIdentifier()),
	+ $commit->getMonogram()),
	);
	}

	}
	diff --git a/src/applications/audit/management/PhabricatorAuditManagementDeleteWorkflow.php b/src/applications/audit/management/PhabricatorAuditManagementDeleteWorkflow.php
	index fa9dbff635..95fbdb430f 100644
	--- a/src/applications/audit/management/PhabricatorAuditManagementDeleteWorkflow.php
	+++ b/src/applications/audit/management/PhabricatorAuditManagementDeleteWorkflow.php
	@@ -1,287 +1,288 @@
	<?php

	final class PhabricatorAuditManagementDeleteWorkflow
	extends PhabricatorAuditManagementWorkflow {

	protected function didConstruct() {
	$this
	->setName('delete')
	->setExamples('delete [--dry-run] ...')
	->setSynopsis(pht('Delete audit requests matching parameters.'))
	->setArguments(
	array(
	array(
	'name' => 'dry-run',
	'help' => pht(
	'Show what would be deleted, but do not actually delete '.
	'anything.'),
	),
	array(
	'name' => 'users',
	'param' => 'names',
	'help' => pht('Select only audits by a given list of users.'),
	),
	array(
	'name' => 'repositories',
	'param' => 'repos',
	'help' => pht(
	'Select only audits in a given list of repositories.'),
	),
	array(
	'name' => 'commits',
	'param' => 'commits',
	'help' => pht('Select only audits for the given commits.'),
	),
	array(
	'name' => 'min-commit-date',
	'param' => 'date',
	'help' => pht(
	'Select only audits for commits on or after the given date.'),
	),
	array(
	'name' => 'max-commit-date',
	'param' => 'date',
	'help' => pht(
	'Select only audits for commits on or before the given date.'),
	),
	array(
	'name' => 'status',
	'param' => 'status',
	'help' => pht(
	'Select only audits in the given status. By default, '.
	'only open audits are selected.'),
	),
	array(
	'name' => 'ids',
	'param' => 'ids',
	'help' => pht('Select only audits with the given IDs.'),
	),
	));
	}

	public function execute(PhutilArgumentParser $args) {
	$viewer = $this->getViewer();
	$users = $this->loadUsers($args->getArg('users'));
	$repos = $this->loadRepos($args->getArg('repositories'));
	$commits = $this->loadCommits($args->getArg('commits'));
	$ids = $this->parseList($args->getArg('ids'));

	$status = $args->getArg('status');
	if (!$status) {
	$status = DiffusionCommitQuery::AUDIT_STATUS_OPEN;
	}

	$min_date = $this->loadDate($args->getArg('min-commit-date'));
	$max_date = $this->loadDate($args->getArg('max-commit-date'));
	if ($min_date && $max_date && ($min_date > $max_date)) {
	throw new PhutilArgumentUsageException(
	pht('Specified maximum date must come after specified minimum date.'));
	}

	$is_dry_run = $args->getArg('dry-run');

	$query = id(new DiffusionCommitQuery())
	->setViewer($this->getViewer())
	->needAuditRequests(true);

	if ($status) {
	$query->withAuditStatus($status);
	}

	$id_map = array();
	if ($ids) {
	$id_map = array_fuse($ids);
	$query->withAuditIDs($ids);
	}

	if ($repos) {
	$query->withRepositoryIDs(mpull($repos, 'getID'));
	}

	$auditor_map = array();
	if ($users) {
	$auditor_map = array_fuse(mpull($users, 'getPHID'));
	$query->withAuditorPHIDs($auditor_map);
	}

	if ($commits) {
	$query->withPHIDs(mpull($commits, 'getPHID'));
	}

	$commits = $query->execute();
	$commits = mpull($commits, null, 'getPHID');
	$audits = array();
	foreach ($commits as $commit) {
	$commit_audits = $commit->getAudits();
	foreach ($commit_audits as $key => $audit) {
	if ($id_map && empty($id_map[$audit->getID()])) {
	unset($commit_audits[$key]);
	continue;
	}

	if ($auditor_map && empty($auditor_map[$audit->getAuditorPHID()])) {
	unset($commit_audits[$key]);
	continue;
	}

	if ($min_date && $commit->getEpoch() < $min_date) {
	unset($commit_audits[$key]);
	continue;
	}

	if ($max_date && $commit->getEpoch() > $max_date) {
	unset($commit_audits[$key]);
	continue;
	}
	}
	$audits[] = $commit_audits;
	}
	$audits = array_mergev($audits);

	$console = PhutilConsole::getConsole();

	if (!$audits) {
	$console->writeErr("%s\n", pht('No audits match the query.'));
	return 0;
	}

	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->getViewer())
	->withPHIDs(mpull($audits, 'getAuditorPHID'))
	->execute();


	foreach ($audits as $audit) {
	$commit = $commits[$audit->getCommitPHID()];

	$console->writeOut(
	"%s\n",
	sprintf(
	'%10d %-16s %-16s %s: %s',
	$audit->getID(),
	$handles[$audit->getAuditorPHID()]->getName(),
	PhabricatorAuditStatusConstants::getStatusName(
	$audit->getAuditStatus()),
	$commit->getRepository()->formatCommitName(
	$commit->getCommitIdentifier()),
	trim($commit->getSummary())));
	}

	if (!$is_dry_run) {
	$message = pht(
	'Really delete these %d audit(s)? They will be permanently deleted '.
	'and can not be recovered.',
	count($audits));
	if ($console->confirm($message)) {
	foreach ($audits as $audit) {
	$id = $audit->getID();
	$console->writeOut("%s\n", pht('Deleting audit %d...', $id));
	$audit->delete();
	}
	}
	}

	return 0;
	}

	private function loadUsers($users) {
	$users = $this->parseList($users);
	if (!$users) {
	return null;
	}

	$objects = id(new PhabricatorPeopleQuery())
	->setViewer($this->getViewer())
	->withUsernames($users)
	->execute();
	$objects = mpull($objects, null, 'getUsername');

	foreach ($users as $name) {
	if (empty($objects[$name])) {
	throw new PhutilArgumentUsageException(
	pht('No such user with username "%s"!', $name));
	}
	}

	return $objects;
	}

	private function parseList($list) {
	$list = preg_split('/\s,\s/', $list);

	foreach ($list as $key => $item) {
	$list[$key] = trim($item);
	}

	foreach ($list as $key => $item) {
	if (!strlen($item)) {
	unset($list[$key]);
	}
	}

	return $list;
	}

	- private function loadRepos($callsigns) {
	- $callsigns = $this->parseList($callsigns);
	- if (!$callsigns) {
	+ private function loadRepos($identifiers) {
	+ $identifiers = $this->parseList($identifiers);
	+ if (!$identifiers) {
	return null;
	}

	- $repos = id(new PhabricatorRepositoryQuery())
	+ $query = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	- ->withCallsigns($callsigns)
	- ->execute();
	- $repos = mpull($repos, null, 'getCallsign');
	+ ->withIdentifiers($identifiers);
	+
	+ $repos = $query->execute();

	- foreach ($callsigns as $sign) {
	- if (empty($repos[$sign])) {
	+ $map = $query->getIdentifierMap();
	+ foreach ($identifiers as $identifier) {
	+ if (empty($map[$identifier])) {
	throw new PhutilArgumentUsageException(
	- pht('No such repository with callsign "%s"!', $sign));
	+ pht('No repository "%s" exists!', $identifier));
	}
	}

	return $repos;
	}

	private function loadDate($date) {
	if (!$date) {
	return null;
	}

	$epoch = strtotime($date);
	if (!$epoch \|\| $epoch < 1) {
	throw new PhutilArgumentUsageException(
	pht(
	'Unable to parse date "%s". Use a format like "%s".',
	$date,
	'2000-01-01'));
	}

	return $epoch;
	}

	private function loadCommits($commits) {
	$names = $this->parseList($commits);
	if (!$names) {
	return null;
	}

	$query = id(new DiffusionCommitQuery())
	->setViewer($this->getViewer())
	->withIdentifiers($names);

	$commits = $query->execute();

	$map = $query->getIdentifierMap();
	foreach ($names as $name) {
	if (empty($map[$name])) {
	throw new PhutilArgumentUsageException(
	pht('No such commit "%s"!', $name));
	}
	}

	return $commits;
	}

	}
	diff --git a/src/applications/diffusion/herald/HeraldCommitAdapter.php b/src/applications/diffusion/herald/HeraldCommitAdapter.php
	index 9baac6f2ad..67234edeab 100644
	--- a/src/applications/diffusion/herald/HeraldCommitAdapter.php
	+++ b/src/applications/diffusion/herald/HeraldCommitAdapter.php
	@@ -1,337 +1,334 @@
	<?php

	final class HeraldCommitAdapter
	extends HeraldAdapter
	implements HarbormasterBuildableAdapterInterface {

	protected $diff;
	protected $revision;

	protected $repository;
	protected $commit;
	protected $commitData;
	private $commitDiff;

	protected $affectedPaths;
	protected $affectedRevision;
	protected $affectedPackages;
	protected $auditNeededPackages;

	private $buildRequests = array();

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

	protected function newObject() {
	return new PhabricatorRepositoryCommit();
	}

	protected function initializeNewAdapter() {
	$this->commit = $this->newObject();
	}

	public function getObject() {
	return $this->commit;
	}

	public function getAdapterContentType() {
	return 'commit';
	}

	public function getAdapterContentName() {
	return pht('Commits');
	}

	public function getAdapterContentDescription() {
	return pht(
	"React to new commits appearing in tracked repositories.\n".
	"Commit rules can send email, flag commits, trigger audits, ".
	"and run build plans.");
	}

	public function supportsRuleType($rule_type) {
	switch ($rule_type) {
	case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
	case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
	case HeraldRuleTypeConfig::RULE_TYPE_OBJECT:
	return true;
	default:
	return false;
	}
	}

	public function canTriggerOnObject($object) {
	if ($object instanceof PhabricatorRepository) {
	return true;
	}
	if ($object instanceof PhabricatorProject) {
	return true;
	}
	return false;
	}

	public function getTriggerObjectPHIDs() {
	return array_merge(
	array(
	$this->repository->getPHID(),
	$this->getPHID(),
	),
	$this->repository->getProjectPHIDs());
	}

	public function explainValidTriggerObjects() {
	return pht('This rule can trigger for repositories and projects.');
	}

	public static function newLegacyAdapter(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $commit_data) {

	$object = new HeraldCommitAdapter();

	$commit->attachRepository($repository);

	$object->repository = $repository;
	$object->commit = $commit;
	$object->commitData = $commit_data;

	return $object;
	}

	public function setCommit(PhabricatorRepositoryCommit $commit) {
	$viewer = PhabricatorUser::getOmnipotentUser();

	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->withIDs(array($commit->getRepositoryID()))
	->needProjectPHIDs(true)
	->executeOne();
	if (!$repository) {
	throw new Exception(pht('Unable to load repository!'));
	}

	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());
	if (!$data) {
	throw new Exception(pht('Unable to load commit data!'));
	}

	$this->commit = clone $commit;
	$this->commit->attachRepository($repository);
	$this->commit->attachCommitData($data);

	$this->repository = $repository;
	$this->commitData = $data;

	return $this;
	}

	public function getHeraldName() {
	- return
	- 'r'.
	- $this->repository->getCallsign().
	- $this->commit->getCommitIdentifier();
	+ return $this->commit->getMonogram();
	}

	public function loadAffectedPaths() {
	if ($this->affectedPaths === null) {
	$result = PhabricatorOwnerPathQuery::loadAffectedPaths(
	$this->repository,
	$this->commit,
	PhabricatorUser::getOmnipotentUser());
	$this->affectedPaths = $result;
	}
	return $this->affectedPaths;
	}

	public function loadAffectedPackages() {
	if ($this->affectedPackages === null) {
	$packages = PhabricatorOwnersPackage::loadAffectedPackages(
	$this->repository,
	$this->loadAffectedPaths());
	$this->affectedPackages = $packages;
	}
	return $this->affectedPackages;
	}

	public function loadAuditNeededPackages() {
	if ($this->auditNeededPackages === null) {
	$status_arr = array(
	PhabricatorAuditStatusConstants::AUDIT_REQUIRED,
	PhabricatorAuditStatusConstants::CONCERNED,
	);
	$requests = id(new PhabricatorRepositoryAuditRequest())
	->loadAllWhere(
	'commitPHID = %s AND auditStatus IN (%Ls)',
	$this->commit->getPHID(),
	$status_arr);
	$this->auditNeededPackages = $requests;
	}
	return $this->auditNeededPackages;
	}

	public function loadDifferentialRevision() {
	if ($this->affectedRevision === null) {
	$this->affectedRevision = false;
	$data = $this->commitData;
	$revision_id = $data->getCommitDetail('differential.revisionID');
	if ($revision_id) {
	// NOTE: The Herald rule owner might not actually have access to
	// the revision, and can control which revision a commit is
	// associated with by putting text in the commit message. However,
	// the rules they can write against revisions don't actually expose
	// anything interesting, so it seems reasonable to load unconditionally
	// here.

	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->needRelationships(true)
	->needReviewerStatus(true)
	->executeOne();
	if ($revision) {
	$this->affectedRevision = $revision;
	}
	}
	}
	return $this->affectedRevision;
	}

	public static function getEnormousByteLimit() {
	return 1024 * 1024 * 1024; // 1GB
	}

	public static function getEnormousTimeLimit() {
	return 60 * 15; // 15 Minutes
	}

	private function loadCommitDiff() {
	$byte_limit = self::getEnormousByteLimit();

	$raw = $this->callConduit(
	'diffusion.rawdiffquery',
	array(
	'commit' => $this->commit->getCommitIdentifier(),
	'timeout' => self::getEnormousTimeLimit(),
	'byteLimit' => $byte_limit,
	'linesOfContext' => 0,
	));

	if (strlen($raw) >= $byte_limit) {
	throw new Exception(
	pht(
	'The raw text of this change is enormous (larger than %d bytes). '.
	'Herald can not process it.',
	$byte_limit));
	}

	$parser = new ArcanistDiffParser();
	$changes = $parser->parseDiff($raw);

	$diff = DifferentialDiff::newEphemeralFromRawChanges(
	$changes);
	return $diff;
	}

	public function isDiffEnormous() {
	$this->loadDiffContent('*');
	return ($this->commitDiff instanceof Exception);
	}

	public function loadDiffContent($type) {
	if ($this->commitDiff === null) {
	try {
	$this->commitDiff = $this->loadCommitDiff();
	} catch (Exception $ex) {
	$this->commitDiff = $ex;
	phlog($ex);
	}
	}

	if ($this->commitDiff instanceof Exception) {
	$ex = $this->commitDiff;
	$ex_class = get_class($ex);
	$ex_message = pht('Failed to load changes: %s', $ex->getMessage());

	return array(
	'<'.$ex_class.'>' => $ex_message,
	);
	}

	$changes = $this->commitDiff->getChangesets();

	$result = array();
	foreach ($changes as $change) {
	$lines = array();
	foreach ($change->getHunks() as $hunk) {
	switch ($type) {
	case '-':
	$lines[] = $hunk->makeOldFile();
	break;
	case '+':
	$lines[] = $hunk->makeNewFile();
	break;
	case '*':
	$lines[] = $hunk->makeChanges();
	break;
	default:
	throw new Exception(pht("Unknown content selection '%s'!", $type));
	}
	}
	$result[$change->getFilename()] = implode("\n", $lines);
	}

	return $result;
	}

	public function loadIsMergeCommit() {
	$parents = $this->callConduit(
	'diffusion.commitparentsquery',
	array(
	'commit' => $this->getObject()->getCommitIdentifier(),
	));

	return (count($parents) > 1);
	}

	private function callConduit($method, array $params) {
	$viewer = PhabricatorUser::getOmnipotentUser();

	$drequest = DiffusionRequest::newFromDictionary(
	array(
	'user' => $viewer,
	'repository' => $this->repository,
	'commit' => $this->commit->getCommitIdentifier(),
	));

	return DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	$drequest,
	$method,
	$params);
	}

	/* -( HarbormasterBuildableAdapterInterface )------------------------------ */


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

	public function getHarbormasterContainerPHID() {
	return $this->getObject()->getRepository()->getPHID();
	}

	public function getQueuedHarbormasterBuildRequests() {
	return $this->buildRequests;
	}

	public function queueHarbormasterBuildRequest(
	HarbormasterBuildRequest $request) {
	$this->buildRequests[] = $request;
	}

	}
	diff --git a/src/applications/harbormaster/query/HarbormasterBuildableSearchEngine.php b/src/applications/harbormaster/query/HarbormasterBuildableSearchEngine.php
	index 094968437b..195a68a695 100644
	--- a/src/applications/harbormaster/query/HarbormasterBuildableSearchEngine.php
	+++ b/src/applications/harbormaster/query/HarbormasterBuildableSearchEngine.php
	@@ -1,226 +1,226 @@
	<?php

	final class HarbormasterBuildableSearchEngine
	extends PhabricatorApplicationSearchEngine {

	public function getResultTypeDescription() {
	return pht('Harbormaster Buildables');
	}

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

	public function buildSavedQueryFromRequest(AphrontRequest $request) {
	$saved = new PhabricatorSavedQuery();

	$revisions = $this->readPHIDsFromRequest(
	$request,
	'revisions',
	array(
	DifferentialRevisionPHIDType::TYPECONST,
	));

	$repositories = $this->readPHIDsFromRequest(
	$request,
	'repositories',
	array(
	PhabricatorRepositoryRepositoryPHIDType::TYPECONST,
	));

	$container_phids = array_merge($revisions, $repositories);
	$saved->setParameter('containerPHIDs', $container_phids);

	$commits = $this->readPHIDsFromRequest(
	$request,
	'commits',
	array(
	PhabricatorRepositoryCommitPHIDType::TYPECONST,
	));

	$diffs = $this->readListFromRequest($request, 'diffs');
	if ($diffs) {
	$diffs = id(new DifferentialDiffQuery())
	->setViewer($this->requireViewer())
	->withIDs($diffs)
	->execute();
	$diffs = mpull($diffs, 'getPHID', 'getPHID');
	}

	$buildable_phids = array_merge($commits, $diffs);
	$saved->setParameter('buildablePHIDs', $buildable_phids);

	$saved->setParameter(
	'manual',
	$this->readBoolFromRequest($request, 'manual'));

	return $saved;
	}

	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
	$query = id(new HarbormasterBuildableQuery())
	->needContainerHandles(true)
	->needBuildableHandles(true);

	$container_phids = $saved->getParameter('containerPHIDs', array());
	if ($container_phids) {
	$query->withContainerPHIDs($container_phids);
	}

	$buildable_phids = $saved->getParameter('buildablePHIDs', array());

	if ($buildable_phids) {
	$query->withBuildablePHIDs($buildable_phids);
	}

	$manual = $saved->getParameter('manual');
	if ($manual !== null) {
	$query->withManualBuildables($manual);
	}

	return $query;
	}

	public function buildSearchForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved_query) {

	$container_phids = $saved_query->getParameter('containerPHIDs', array());
	$buildable_phids = $saved_query->getParameter('buildablePHIDs', array());

	$all_phids = array_merge($container_phids, $buildable_phids);

	$revision_names = array();
	$diff_names = array();
	$repository_names = array();
	$commit_names = array();

	if ($all_phids) {
	$objects = id(new PhabricatorObjectQuery())
	->setViewer($this->requireViewer())
	->withPHIDs($all_phids)
	->execute();

	foreach ($all_phids as $phid) {
	$object = idx($objects, $phid);
	if (!$object) {
	continue;
	}

	if ($object instanceof DifferentialRevision) {
	$revision_names[] = 'D'.$object->getID();
	} else if ($object instanceof DifferentialDiff) {
	$diff_names[] = $object->getID();
	} else if ($object instanceof PhabricatorRepository) {
	- $repository_names[] = 'r'.$object->getCallsign();
	+ $repository_names[] = $object->getMonogram();
	} else if ($object instanceof PhabricatorRepositoryCommit) {
	$repository = $object->getRepository();
	$commit_names[] = $repository->formatCommitName(
	$object->getCommitIdentifier());
	}
	}
	}

	$form
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Differential Revisions'))
	->setName('revisions')
	->setValue(implode(', ', $revision_names)))
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Differential Diffs'))
	->setName('diffs')
	->setValue(implode(', ', $diff_names)))
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Repositories'))
	->setName('repositories')
	->setValue(implode(', ', $repository_names)))
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Commits'))
	->setName('commits')
	->setValue(implode(', ', $commit_names)))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Origin'))
	->setName('manual')
	->setValue($this->getBoolFromQuery($saved_query, 'manual'))
	->setOptions(
	array(
	'' => pht('(All Origins)'),
	'true' => pht('Manual Buildables'),
	'false' => pht('Automatic Buildables'),
	)));
	}

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

	protected function getBuiltinQueryNames() {
	return array(
	'all' => pht('All Buildables'),
	);
	}

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

	switch ($query_key) {
	case 'all':
	return $query;
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	protected function renderResultList(
	array $buildables,
	PhabricatorSavedQuery $query,
	array $handles) {
	assert_instances_of($buildables, 'HarbormasterBuildable');

	$viewer = $this->requireViewer();

	$list = new PHUIObjectItemListView();
	foreach ($buildables as $buildable) {
	$id = $buildable->getID();

	$item = id(new PHUIObjectItemView())
	->setHeader(pht('Buildable %d', $buildable->getID()));
	if ($buildable->getContainerHandle() !== null) {
	$item->addAttribute($buildable->getContainerHandle()->getName());
	}
	if ($buildable->getBuildableHandle() !== null) {
	$item->addAttribute($buildable->getBuildableHandle()->getFullName());
	}

	if ($id) {
	$item->setHref("/B{$id}");
	}

	if ($buildable->getIsManualBuildable()) {
	$item->addIcon('fa-wrench grey', pht('Manual'));
	}

	$item->setStatusIcon('fa-wrench '.
	HarbormasterBuildable::getBuildableStatusColor(
	$buildable->getBuildableStatus()));
	$item->addByline(HarbormasterBuildable::getBuildableStatusName(
	$buildable->getBuildableStatus()));

	$list->addItem($item);

	}

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

	return $result;
	}

	}
	diff --git a/src/applications/owners/controller/PhabricatorOwnersPathsController.php b/src/applications/owners/controller/PhabricatorOwnersPathsController.php
	index ad278d5296..b02f5437be 100644
	--- a/src/applications/owners/controller/PhabricatorOwnersPathsController.php
	+++ b/src/applications/owners/controller/PhabricatorOwnersPathsController.php
	@@ -1,166 +1,166 @@
	<?php

	final class PhabricatorOwnersPathsController
	extends PhabricatorOwnersController {

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

	$package = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withIDs(array($request->getURIData('id')))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	// TODO: Support this capability.
	// PhabricatorPolicyCapability::CAN_EDIT,
	))
	->needPaths(true)
	->executeOne();
	if (!$package) {
	return new Aphront404Response();
	}

	if ($request->isFormPost()) {
	$paths = $request->getArr('path');
	$repos = $request->getArr('repo');
	$excludes = $request->getArr('exclude');

	$path_refs = array();
	foreach ($paths as $key => $path) {
	if (!isset($repos[$key])) {
	throw new Exception(
	pht(
	'No repository PHID for path "%s"!',
	$key));
	}

	if (!isset($excludes[$key])) {
	throw new Exception(
	pht(
	'No exclusion value for path "%s"!',
	$key));
	}

	$path_refs[] = array(
	'repositoryPHID' => $repos[$key],
	'path' => $path,
	'excluded' => (int)$excludes[$key],
	);
	}

	$type_paths = PhabricatorOwnersPackageTransaction::TYPE_PATHS;

	$xactions = array();
	$xactions[] = id(new PhabricatorOwnersPackageTransaction())
	->setTransactionType($type_paths)
	->setNewValue($path_refs);

	$editor = id(new PhabricatorOwnersPackageTransactionEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true);

	$editor->applyTransactions($package, $xactions);

	return id(new AphrontRedirectResponse())
	->setURI('/owners/package/'.$package->getID().'/');
	} else {
	$paths = $package->getPaths();
	$path_refs = mpull($paths, 'getRef');
	}

	$repos = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->execute();

	$default_paths = array();
	foreach ($repos as $repo) {
	$default_path = $repo->getDetail('default-owners-path');
	if ($default_path) {
	$default_paths[$repo->getPHID()] = $default_path;
	}
	}

	- $repos = mpull($repos, 'getCallsign', 'getPHID');
	+ $repos = mpull($repos, 'getMonogram', 'getPHID');
	asort($repos);

	$template = new AphrontTypeaheadTemplateView();
	$template = $template->render();

	Javelin::initBehavior(
	'owners-path-editor',
	array(
	'root' => 'path-editor',
	'table' => 'paths',
	'add_button' => 'addpath',
	'repositories' => $repos,
	'input_template' => $template,
	'pathRefs' => $path_refs,

	'completeURI' => '/diffusion/services/path/complete/',
	'validateURI' => '/diffusion/services/path/validate/',

	'repositoryDefaultPaths' => $default_paths,
	));

	require_celerity_resource('owners-path-editor-css');

	$cancel_uri = '/owners/package/'.$package->getID().'/';

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->appendChild(
	id(new PHUIFormInsetView())
	->setTitle(pht('Paths'))
	->addDivAttributes(array('id' => 'path-editor'))
	->setRightButton(javelin_tag(
	'a',
	array(
	'href' => '#',
	'class' => 'button green',
	'sigil' => 'addpath',
	'mustcapture' => true,
	),
	pht('Add New Path')))
	->setDescription(
	pht(
	'Specify the files and directories which comprise '.
	'this package.'))
	->setContent(javelin_tag(
	'table',
	array(
	'class' => 'owners-path-editor-table',
	'sigil' => 'paths',
	),
	'')))
	->appendChild(
	id(new AphrontFormSubmitControl())
	->addCancelButton($cancel_uri)
	->setValue(pht('Save Paths')));

	$form_box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Edit Paths'))
	->setForm($form);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(
	$package->getName(),
	$this->getApplicationURI('package/'.$package->getID().'/'));
	$crumbs->addTextCrumb(pht('Edit Paths'));

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$form_box,
	),
	array(
	'title' => array(
	$package->getName(),
	pht('Edit Paths'),
	),
	));
	}

	}
	diff --git a/src/applications/releeph/controller/product/ReleephProductCreateController.php b/src/applications/releeph/controller/product/ReleephProductCreateController.php
	index 9772b293fe..2aedf8cdf1 100644
	--- a/src/applications/releeph/controller/product/ReleephProductCreateController.php
	+++ b/src/applications/releeph/controller/product/ReleephProductCreateController.php
	@@ -1,132 +1,132 @@
	<?php

	final class ReleephProductCreateController extends ReleephProductController {

	public function handleRequest(AphrontRequest $request) {
	$name = trim($request->getStr('name'));
	$trunk_branch = trim($request->getStr('trunkBranch'));
	$repository_phid = $request->getStr('repositoryPHID');

	$e_name = true;
	$e_trunk_branch = true;
	$errors = array();

	if ($request->isFormPost()) {
	if (!$name) {
	$e_name = pht('Required');
	$errors[] = pht(
	'Your product should have a simple, descriptive name.');
	}

	if (!$trunk_branch) {
	$e_trunk_branch = pht('Required');
	$errors[] = pht(
	'You must specify which branch you will be picking from.');
	}

	$pr_repository = id(new PhabricatorRepositoryQuery())
	->setViewer($request->getUser())
	->withPHIDs(array($repository_phid))
	->executeOne();


	if (!$errors) {
	$releeph_product = id(new ReleephProject())
	->setName($name)
	->setTrunkBranch($trunk_branch)
	->setRepositoryPHID($pr_repository->getPHID())
	->setCreatedByUserPHID($request->getUser()->getPHID())
	->setIsActive(1);

	try {
	$releeph_product->save();

	return id(new AphrontRedirectResponse())
	->setURI($releeph_product->getURI());
	} catch (AphrontDuplicateKeyQueryException $ex) {
	$e_name = pht('Not Unique');
	$errors[] = pht('Another product already uses this name.');
	}
	}
	}

	$repo_options = $this->getRepositorySelectOptions();

	$product_name_input = id(new AphrontFormTextControl())
	->setLabel(pht('Name'))
	->setDisableAutocomplete(true)
	->setName('name')
	->setValue($name)
	->setError($e_name)
	->setCaption(pht('A name like "Thrift" but not "Thrift releases".'));

	$repository_input = id(new AphrontFormSelectControl())
	->setLabel(pht('Repository'))
	->setName('repositoryPHID')
	->setValue($repository_phid)
	->setOptions($repo_options);

	$branch_name_preview = id(new ReleephBranchPreviewView())
	->setLabel(pht('Example Branch'))
	->addControl('projectName', $product_name_input)
	->addControl('repositoryPHID', $repository_input)
	->addStatic('template', '')
	->addStatic('isSymbolic', false);

	$form = id(new AphrontFormView())
	->setUser($request->getUser())
	->appendChild($product_name_input)
	->appendChild($repository_input)
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Trunk'))
	->setName('trunkBranch')
	->setValue($trunk_branch)
	->setError($e_trunk_branch)
	->setCaption(pht(
	'The development branch, from which requests will be picked.')))
	->appendChild($branch_name_preview)
	->appendChild(
	id(new AphrontFormSubmitControl())
	->addCancelButton('/releeph/project/')
	->setValue(pht('Create Release Product')));

	$form_box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Create New Product'))
	->setFormErrors($errors)
	->setForm($form);

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

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$form_box,
	),
	array(
	'title' => pht('Create New Product'),
	));
	}

	private function getRepositorySelectOptions() {
	$repos = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getRequest()->getUser())
	->execute();

	$repos = msort($repos, 'getName');
	$repos = mpull($repos, null, 'getID');

	$choices = array();

	foreach ($repos as $repo_id => $repo) {
	$repo_name = $repo->getName();
	- $callsign = $repo->getCallsign();
	- $choices[$repo->getPHID()] = "r{$callsign} ({$repo_name})";
	+ $display = $repo->getDisplayName();
	+ $choices[$repo->getPHID()] = "{$display} ({$repo_name})";
	}

	- ksort($choices);
	+ asort($choices);
	return $choices;
	}

	}
	diff --git a/src/applications/releeph/differential/DifferentialReleephRequestFieldSpecification.php b/src/applications/releeph/differential/DifferentialReleephRequestFieldSpecification.php
	index 2f06f50f13..26e708a00c 100644
	--- a/src/applications/releeph/differential/DifferentialReleephRequestFieldSpecification.php
	+++ b/src/applications/releeph/differential/DifferentialReleephRequestFieldSpecification.php
	@@ -1,386 +1,386 @@
	<?php

	/**
	* This DifferentialFieldSpecification exists for two reason:
	*
	* 1: To parse "Releeph: picks RQ<nn>" headers in commits created by
	* arc-releeph so that RQs committed by arc-releeph have real
	* PhabricatorRepositoryCommits associated with them (instaed of just the SHA
	* of the commit, as seen by the pusher).
	*
	* 2: If requestors want to commit directly to their release branch, they can
	* use this header to (i) indicate on a differential revision that this
	* differential revision is for the release branch, and (ii) when they land
	* their diff on to the release branch manually, the ReleephRequest is
	* automatically updated (instead of having to use the "Mark Manually Picked"
	* button.)
	*
	*/
	final class DifferentialReleephRequestFieldSpecification extends Phobject {

	// TODO: This class is essentially dead right now, see T2222.

	const ACTION_PICKS = 'picks';
	const ACTION_REVERTS = 'reverts';

	private $releephAction;
	private $releephPHIDs = array();

	public function getStorageKey() {
	return 'releeph:actions';
	}

	public function getValueForStorage() {
	return json_encode(array(
	'releephAction' => $this->releephAction,
	'releephPHIDs' => $this->releephPHIDs,
	));
	}

	public function setValueFromStorage($json) {
	if ($json) {
	$dict = phutil_json_decode($json);
	$this->releephAction = idx($dict, 'releephAction');
	$this->releephPHIDs = idx($dict, 'releephPHIDs');
	}
	return $this;
	}

	public function shouldAppearOnRevisionView() {
	return true;
	}

	public function renderLabelForRevisionView() {
	return pht('Releeph');
	}

	public function getRequiredHandlePHIDs() {
	return mpull($this->loadReleephRequests(), 'getPHID');
	}

	public function renderValueForRevisionView() {
	static $tense;

	if ($tense === null) {
	$tense = array(
	self::ACTION_PICKS => array(
	'future' => pht('Will pick'),
	'past' => pht('Picked'),
	),
	self::ACTION_REVERTS => array(
	'future' => pht('Will revert'),
	'past' => pht('Reverted'),
	),
	);
	}

	$releeph_requests = $this->loadReleephRequests();
	if (!$releeph_requests) {
	return null;
	}

	$status = $this->getRevision()->getStatus();
	if ($status == ArcanistDifferentialRevisionStatus::CLOSED) {
	$verb = $tense[$this->releephAction]['past'];
	} else {
	$verb = $tense[$this->releephAction]['future'];
	}

	$parts = hsprintf('%s...', $verb);
	foreach ($releeph_requests as $releeph_request) {
	$parts->appendHTML(phutil_tag('br'));
	$parts->appendHTML(
	$this->getHandle($releeph_request->getPHID())->renderLink());
	}

	return $parts;
	}

	public function shouldAppearOnCommitMessage() {
	return true;
	}

	public function getCommitMessageKey() {
	return 'releephActions';
	}

	public function setValueFromParsedCommitMessage($dict) {
	$this->releephAction = $dict['releephAction'];
	$this->releephPHIDs = $dict['releephPHIDs'];
	return $this;
	}

	public function renderValueForCommitMessage($is_edit) {
	$releeph_requests = $this->loadReleephRequests();
	if (!$releeph_requests) {
	return null;
	}

	$parts = array($this->releephAction);
	foreach ($releeph_requests as $releeph_request) {
	$parts[] = 'RQ'.$releeph_request->getID();
	}

	return implode(' ', $parts);
	}

	/**
	* Releeph fields should look like:
	*
	* Releeph: picks RQ1 RQ2, RQ3
	* Releeph: reverts RQ1
	*/
	public function parseValueFromCommitMessage($value) {
	/**
	* Releeph commit messages look like this (but with more blank lines,
	* omitted here):
	*
	* Make CaptainHaddock more reasonable
	* Releeph: picks RQ1
	* Requested By: edward
	* Approved By: edward (requestor)
	* Request Reason: x
	* Summary: Make the Haddock implementation more reasonable.
	* Test Plan: none
	* Reviewers: user1
	*
	* Some of these fields are recognized by Differential (e.g. "Requested
	* By"). They are folded up into the "Releeph" field, parsed by this
	* class. As such $value includes more than just the first-line:
	*
	* "picks RQ1\n\nRequested By: edward\n\nApproved By: edward (requestor)"
	*
	* To hack around this, just consider the first line of $value when
	* determining what Releeph actions the parsed commit is performing.
	*/
	$first_line = head(array_filter(explode("\n", $value)));

	$tokens = preg_split('/\s*,?\s+/', $first_line);
	$raw_action = array_shift($tokens);
	$action = strtolower($raw_action);

	if (!$action) {
	return null;
	}

	switch ($action) {
	case self::ACTION_REVERTS:
	case self::ACTION_PICKS:
	break;

	default:
	throw new DifferentialFieldParseException(
	pht(
	"Commit message contains unknown Releeph action '%s'!",
	$raw_action));
	break;
	}

	$releeph_requests = array();
	foreach ($tokens as $token) {
	$match = array();
	if (!preg_match('/^(?:RQ)?(\d+)$/i', $token, $match)) {
	$label = $this->renderLabelForCommitMessage();
	throw new DifferentialFieldParseException(
	pht(
	"Commit message contains unparseable ".
	"Releeph request token '%s'!",
	$token));
	}

	$id = (int)$match[1];
	$releeph_request = id(new ReleephRequest())->load($id);

	if (!$releeph_request) {
	throw new DifferentialFieldParseException(
	pht(
	'Commit message references non existent Releeph request: %s!',
	$value));
	}

	$releeph_requests[] = $releeph_request;
	}

	if (count($releeph_requests) > 1) {
	$rqs_seen = array();
	$groups = array();
	foreach ($releeph_requests as $releeph_request) {
	$releeph_branch = $releeph_request->getBranch();
	$branch_name = $releeph_branch->getName();
	$rq_id = 'RQ'.$releeph_request->getID();

	if (idx($rqs_seen, $rq_id)) {
	throw new DifferentialFieldParseException(
	pht(
	'Commit message refers to %s multiple times!',
	$rq_id));
	}
	$rqs_seen[$rq_id] = true;

	if (!isset($groups[$branch_name])) {
	$groups[$branch_name] = array();
	}
	$groups[$branch_name][] = $rq_id;
	}

	if (count($groups) > 1) {
	$lists = array();
	foreach ($groups as $branch_name => $rq_ids) {
	$lists[] = implode(', ', $rq_ids).' in '.$branch_name;
	}
	throw new DifferentialFieldParseException(
	pht(
	'Commit message references multiple Releeph requests, '.
	'but the requests are in different branches: %s',
	implode('; ', $lists)));
	}
	}

	$phids = mpull($releeph_requests, 'getPHID');

	$data = array(
	'releephAction' => $action,
	'releephPHIDs' => $phids,
	);
	return $data;
	}

	public function renderLabelForCommitMessage() {
	return pht('Releeph');
	}

	public function shouldAppearOnCommitMessageTemplate() {
	return false;
	}

	public function didParseCommit(
	PhabricatorRepository $repo,
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data) {

	// NOTE: This is currently dead code. See T2222.

	$releeph_requests = $this->loadReleephRequests();

	if (!$releeph_requests) {
	return;
	}

	$releeph_branch = head($releeph_requests)->getBranch();
	if (!$this->isCommitOnBranch($repo, $commit, $releeph_branch)) {
	return;
	}

	foreach ($releeph_requests as $releeph_request) {
	if ($this->releephAction === self::ACTION_PICKS) {
	$action = 'pick';
	} else {
	$action = 'revert';
	}

	$actor_phid = coalesce(
	$data->getCommitDetail('committerPHID'),
	$data->getCommitDetail('authorPHID'));

	$actor = id(new PhabricatorUser())
	->loadOneWhere('phid = %s', $actor_phid);

	$xactions = array();

	$xactions[] = id(new ReleephRequestTransaction())
	->setTransactionType(ReleephRequestTransaction::TYPE_DISCOVERY)
	->setMetadataValue('action', $action)
	->setMetadataValue('authorPHID',
	$data->getCommitDetail('authorPHID'))
	->setMetadataValue('committerPHID',
	$data->getCommitDetail('committerPHID'))
	->setNewValue($commit->getPHID());

	$editor = id(new ReleephRequestTransactionalEditor())
	->setActor($actor)
	->setContinueOnNoEffect(true)
	->setContentSource(
	PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_UNKNOWN,
	array()));

	$editor->applyTransactions($releeph_request, $xactions);
	}
	}

	private function loadReleephRequests() {
	if (!$this->releephPHIDs) {
	return array();
	}

	return id(new ReleephRequestQuery())
	->setViewer($this->getViewer())
	->withPHIDs($this->releephPHIDs)
	->execute();
	}

	private function isCommitOnBranch(
	PhabricatorRepository $repo,
	PhabricatorRepositoryCommit $commit,
	ReleephBranch $releeph_branch) {

	switch ($repo->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	list($output) = $repo->execxLocalCommand(
	'branch --all --no-color --contains %s',
	$commit->getCommitIdentifier());

	$remote_prefix = 'remotes/origin/';
	$branches = array();
	foreach (array_filter(explode("\n", $output)) as $line) {
	$tokens = explode(' ', $line);
	$ref = last($tokens);
	if (strncmp($ref, $remote_prefix, strlen($remote_prefix)) === 0) {
	$branch = substr($ref, strlen($remote_prefix));
	$branches[$branch] = $branch;
	}
	}

	return idx($branches, $releeph_branch->getName());
	break;

	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$change_query = DiffusionPathChangeQuery::newFromDiffusionRequest(
	DiffusionRequest::newFromDictionary(array(
	'user' => $this->getUser(),
	'repository' => $repo,
	'commit' => $commit->getCommitIdentifier(),
	)));
	$path_changes = $change_query->loadChanges();
	$commit_paths = mpull($path_changes, 'getPath');

	$branch_path = $releeph_branch->getName();

	$in_branch = array();
	$ex_branch = array();
	foreach ($commit_paths as $path) {
	if (strncmp($path, $branch_path, strlen($branch_path)) === 0) {
	$in_branch[] = $path;
	} else {
	$ex_branch[] = $path;
	}
	}

	if ($in_branch && $ex_branch) {
	$error = pht(
	'CONFUSION: commit %s in %s contains %d path change(s) that were '.
	'part of a Releeph branch, but also has %d path change(s) not '.
	'part of a Releeph branch!',
	$commit->getCommitIdentifier(),
	- $repo->getCallsign(),
	+ $repo->getDisplayName(),
	count($in_branch),
	count($ex_branch));
	phlog($error);
	}

	return !empty($in_branch);
	break;
	}
	}

	}
	diff --git a/src/applications/releeph/query/ReleephProductSearchEngine.php b/src/applications/releeph/query/ReleephProductSearchEngine.php
	index ca92068b6f..f56125a687 100644
	--- a/src/applications/releeph/query/ReleephProductSearchEngine.php
	+++ b/src/applications/releeph/query/ReleephProductSearchEngine.php
	@@ -1,130 +1,130 @@
	<?php

	final class ReleephProductSearchEngine
	extends PhabricatorApplicationSearchEngine {

	public function getResultTypeDescription() {
	return pht('Releeph Products');
	}

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

	public function buildSavedQueryFromRequest(AphrontRequest $request) {
	$saved = new PhabricatorSavedQuery();

	$saved->setParameter('active', $request->getStr('active'));

	return $saved;
	}

	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
	$query = id(new ReleephProductQuery())
	->setOrder(ReleephProductQuery::ORDER_NAME);

	$active = $saved->getParameter('active');
	$value = idx($this->getActiveValues(), $active);
	if ($value !== null) {
	$query->withActive($value);
	}

	return $query;
	}

	public function buildSearchForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved_query) {

	$form->appendChild(
	id(new AphrontFormSelectControl())
	->setName('active')
	->setLabel(pht('Show Products'))
	->setValue($saved_query->getParameter('active'))
	->setOptions($this->getActiveOptions()));
	}

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

	protected function getBuiltinQueryNames() {
	return array(
	'active' => pht('Active'),
	'all' => pht('All'),
	);
	}

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

	switch ($query_key) {
	case 'active':
	return $query
	->setParameter('active', 'active');
	case 'all':
	return $query;
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	private function getActiveOptions() {
	return array(
	'all' => pht('Active and Inactive Products'),
	'active' => pht('Active Products'),
	'inactive' => pht('Inactive Products'),
	);
	}

	private function getActiveValues() {
	return array(
	'all' => null,
	'active' => 1,
	'inactive' => 0,
	);
	}

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

	assert_instances_of($products, 'ReleephProject');
	$viewer = $this->requireViewer();

	$list = id(new PHUIObjectItemListView())
	->setUser($viewer);

	foreach ($products as $product) {
	$id = $product->getID();

	$item = id(new PHUIObjectItemView())
	->setHeader($product->getName())
	->setHref($this->getApplicationURI("product/{$id}/"));

	if (!$product->getIsActive()) {
	$item->setDisabled(true);
	$item->addIcon('none', pht('Inactive'));
	}

	$repo = $product->getRepository();
	$item->addAttribute(
	phutil_tag(
	'a',
	array(
	- 'href' => '/diffusion/'.$repo->getCallsign().'/',
	+ 'href' => $repo->getURI(),
	),
	- 'r'.$repo->getCallsign()));
	+ $repo->getMonogram()));

	$list->addItem($item);
	}

	$result = new PhabricatorApplicationSearchResultView();
	$result->setObjectList($list);

	return $result;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Apr 29, 2:02 AM (22 h, 16 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 108153
Default Alt Text: (52 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions