No OneTemporary
Actions

Size

38 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/repository/phid/PhabricatorRepositoryRepositoryPHIDType.php b/src/applications/repository/phid/PhabricatorRepositoryRepositoryPHIDType.php
	index 5a3bca339d..c2cfed251d 100644
	--- a/src/applications/repository/phid/PhabricatorRepositoryRepositoryPHIDType.php
	+++ b/src/applications/repository/phid/PhabricatorRepositoryRepositoryPHIDType.php
	@@ -1,83 +1,84 @@
	<?php

	final class PhabricatorRepositoryRepositoryPHIDType
	extends PhabricatorPHIDType {

	const TYPECONST = 'REPO';

	public function getTypeName() {
	return pht('Repository');
	}

	public function getTypeIcon() {
	return 'fa-database';
	}

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

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

	protected function buildQueryForObjects(
	PhabricatorObjectQuery $query,
	array $phids) {

	return id(new PhabricatorRepositoryQuery())
	->withPHIDs($phids);
	}

	public function loadHandles(
	PhabricatorHandleQuery $query,
	array $handles,
	array $objects) {

	foreach ($handles as $phid => $handle) {
	$repository = $objects[$phid];

	$monogram = $repository->getMonogram();
	$callsign = $repository->getCallsign();
	$name = $repository->getName();
	+ $uri = $repository->getURI();

	$handle->setName($monogram);
	$handle->setFullName("{$monogram} {$name}");
	- $handle->setURI("/diffusion/{$callsign}/");
	+ $handle->setURI($uri);
	}
	}

	public function canLoadNamedObject($name) {
	return preg_match('/^r[A-Z]+\|R[0-9]+$/', $name);
	}

	public function loadNamedObjects(
	PhabricatorObjectQuery $query,
	array $names) {

	$results = array();
	$id_map = array();
	foreach ($names as $key => $name) {
	$id = substr($name, 1);
	$id_map[$id][] = $name;
	$names[$key] = substr($name, 1);
	}

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

	if ($query->execute()) {
	$objects = $query->getIdentifierMap();
	foreach ($objects as $key => $object) {
	foreach (idx($id_map, $key, array()) as $name) {
	$results[$name] = $object;
	}
	}
	return $results;
	} else {
	return array();
	}
	}

	}
	diff --git a/src/applications/repository/query/PhabricatorRepositorySearchEngine.php b/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
	index 04333384f9..1abc964f6c 100644
	--- a/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
	+++ b/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
	@@ -1,263 +1,263 @@
	<?php

	final class PhabricatorRepositorySearchEngine
	extends PhabricatorApplicationSearchEngine {

	public function getResultTypeDescription() {
	return pht('Repositories');
	}

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

	public function newQuery() {
	return id(new PhabricatorRepositoryQuery())
	->needProjectPHIDs(true)
	->needCommitCounts(true)
	->needMostRecentCommits(true);
	}

	protected function buildCustomSearchFields() {
	return array(
	id(new PhabricatorSearchStringListField())
	->setLabel(pht('Callsigns'))
	->setKey('callsigns'),
	id(new PhabricatorSearchTextField())
	->setLabel(pht('Name Contains'))
	->setKey('name'),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Status'))
	->setKey('status')
	->setOptions($this->getStatusOptions()),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Hosted'))
	->setKey('hosted')
	->setOptions($this->getHostedOptions()),
	id(new PhabricatorSearchCheckboxesField())
	->setLabel(pht('Types'))
	->setKey('types')
	->setOptions(PhabricatorRepositoryType::getAllRepositoryTypes()),
	);
	}

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

	if ($map['callsigns']) {
	$query->withCallsigns($map['callsigns']);
	}

	if ($map['status']) {
	$status = idx($this->getStatusValues(), $map['status']);
	if ($status) {
	$query->withStatus($status);
	}
	}

	if ($map['hosted']) {
	$hosted = idx($this->getHostedValues(), $map['hosted']);
	if ($hosted) {
	$query->withHosted($hosted);
	}
	}

	if ($map['types']) {
	$query->withTypes($map['types']);
	}

	if (strlen($map['name'])) {
	$query->withNameContains($map['name']);
	}

	return $query;
	}

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

	protected function getBuiltinQueryNames() {
	$names = array(
	'active' => pht('Active Repositories'),
	'all' => pht('All Repositories'),
	);

	return $names;
	}

	public function buildSavedQueryFromBuiltin($query_key) {

	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);

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

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	private function getStatusOptions() {
	return array(
	'' => pht('Active and Inactive Repositories'),
	'open' => pht('Active Repositories'),
	'closed' => pht('Inactive Repositories'),
	);
	}

	private function getStatusValues() {
	return array(
	'' => PhabricatorRepositoryQuery::STATUS_ALL,
	'open' => PhabricatorRepositoryQuery::STATUS_OPEN,
	'closed' => PhabricatorRepositoryQuery::STATUS_CLOSED,
	);
	}

	private function getHostedOptions() {
	return array(
	'' => pht('Hosted and Remote Repositories'),
	'phabricator' => pht('Hosted Repositories'),
	'remote' => pht('Remote Repositories'),
	);
	}

	private function getHostedValues() {
	return array(
	'' => PhabricatorRepositoryQuery::HOSTED_ALL,
	'phabricator' => PhabricatorRepositoryQuery::HOSTED_PHABRICATOR,
	'remote' => PhabricatorRepositoryQuery::HOSTED_REMOTE,
	);
	}

	protected function getRequiredHandlePHIDsForResultList(
	array $repositories,
	PhabricatorSavedQuery $query) {
	return array_mergev(mpull($repositories, 'getProjectPHIDs'));
	}

	protected function renderResultList(
	array $repositories,
	PhabricatorSavedQuery $query,
	array $handles) {
	assert_instances_of($repositories, 'PhabricatorRepository');

	$viewer = $this->requireViewer();

	$list = new PHUIObjectItemListView();
	foreach ($repositories as $repository) {
	$id = $repository->getID();

	$item = id(new PHUIObjectItemView())
	->setUser($viewer)
	->setObject($repository)
	->setHeader($repository->getName())
	- ->setObjectName('r'.$repository->getCallsign())
	- ->setHref($this->getApplicationURI($repository->getCallsign().'/'));
	+ ->setObjectName($repository->getMonogram())
	+ ->setHref($repository->getURI());

	$commit = $repository->getMostRecentCommit();
	if ($commit) {
	$commit_link = DiffusionView::linkCommit(
	- $repository,
	- $commit->getCommitIdentifier(),
	- $commit->getSummary());
	+ $repository,
	+ $commit->getCommitIdentifier(),
	+ $commit->getSummary());
	$item->setSubhead($commit_link);
	$item->setEpoch($commit->getEpoch());
	}

	$item->addIcon(
	'none',
	PhabricatorRepositoryType::getNameForRepositoryType(
	$repository->getVersionControlSystem()));

	$size = $repository->getCommitCount();
	if ($size) {
	$history_uri = DiffusionRequest::generateDiffusionURI(
	array(
	'callsign' => $repository->getCallsign(),
	'action' => 'history',
	));

	$item->addAttribute(
	phutil_tag(
	'a',
	array(
	'href' => $history_uri,
	),
	pht('%s Commit(s)', new PhutilNumber($size))));
	} else {
	$item->addAttribute(pht('No Commits'));
	}

	$project_handles = array_select_keys(
	$handles,
	$repository->getProjectPHIDs());
	if ($project_handles) {
	$item->addAttribute(
	id(new PHUIHandleTagListView())
	->setSlim(true)
	->setHandles($project_handles));
	}

	if (!$repository->isTracked()) {
	$item->setDisabled(true);
	$item->addIcon('disable-grey', pht('Inactive'));
	}

	$list->addItem($item);
	}

	$result = new PhabricatorApplicationSearchResultView();
	$result->setObjectList($list);
	$result->setNoDataString(pht('No repositories found for this query.'));

	return $result;
	}

	protected function willUseSavedQuery(PhabricatorSavedQuery $saved) {
	$project_phids = $saved->getParameter('projectPHIDs', array());

	$old = $saved->getParameter('projects', array());
	foreach ($old as $phid) {
	$project_phids[] = $phid;
	}

	$any = $saved->getParameter('anyProjectPHIDs', array());
	foreach ($any as $project) {
	$project_phids[] = 'any('.$project.')';
	}

	$saved->setParameter('projectPHIDs', $project_phids);
	}

	protected function getNewUserBody() {

	$import_button = id(new PHUIButtonView())
	->setTag('a')
	->setText(pht('Import Repository'))
	->setHref('/diffusion/import/')
	->setColor(PHUIButtonView::GREEN);

	$create_button = id(new PHUIButtonView())
	->setTag('a')
	->setText(pht('Create Repository'))
	->setHref('/diffusion/create/')
	->setColor(PHUIButtonView::GREEN);

	$icon = $this->getApplication()->getFontIcon();
	$app_name = $this->getApplication()->getName();
	$view = id(new PHUIBigInfoView())
	->setIcon($icon)
	->setTitle(pht('Welcome to %s', $app_name))
	->setDescription(
	pht('Import, create, or just browse repositories in Diffusion.'))
	->addAction($import_button)
	->addAction($create_button);

	return $view;
	}

	}
	diff --git a/src/applications/repository/search/DiffusionCommitFulltextEngine.php b/src/applications/repository/search/DiffusionCommitFulltextEngine.php
	index 51d2ead5fa..dd87a8bda5 100644
	--- a/src/applications/repository/search/DiffusionCommitFulltextEngine.php
	+++ b/src/applications/repository/search/DiffusionCommitFulltextEngine.php
	@@ -1,49 +1,51 @@
	<?php

	final class DiffusionCommitFulltextEngine
	extends PhabricatorFulltextEngine {

	protected function buildAbstractDocument(
	PhabricatorSearchAbstractDocument $document,
	$object) {

	$commit = id(new DiffusionCommitQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($object->getPHID()))
	->needCommitData(true)
	->executeOne();

	$repository = $commit->getRepository();
	$commit_data = $commit->getCommitData();

	$date_created = $commit->getEpoch();
	$commit_message = $commit_data->getCommitMessage();
	$author_phid = $commit_data->getCommitDetail('authorPHID');

	- $title = 'r'.$repository->getCallsign().$commit->getCommitIdentifier().
	- ' '.$commit_data->getSummary();
	+ $monogram = $commit->getMonogram();
	+ $summary = $commit_data->getSummary();
	+
	+ $title = "{$monogram} {$summary}";

	$document
	->setDocumentCreated($date_created)
	->setDocumentModified($date_created)
	->setDocumentTitle($title);

	$document->addField(
	PhabricatorSearchDocumentFieldType::FIELD_BODY,
	$commit_message);

	if ($author_phid) {
	$document->addRelationship(
	PhabricatorSearchRelationship::RELATIONSHIP_AUTHOR,
	$author_phid,
	PhabricatorPeopleUserPHIDType::TYPECONST,
	$date_created);
	}

	$document->addRelationship(
	PhabricatorSearchRelationship::RELATIONSHIP_REPOSITORY,
	$repository->getPHID(),
	PhabricatorRepositoryRepositoryPHIDType::TYPECONST,
	$date_created);
	}
	}
	diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	index da6d56b915..70478bb681 100644
	--- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	+++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	@@ -1,448 +1,453 @@
	<?php

	final class PhabricatorRepositoryCommit
	extends PhabricatorRepositoryDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorFlaggableInterface,
	PhabricatorProjectInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorSubscribableInterface,
	PhabricatorMentionableInterface,
	HarbormasterBuildableInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorFulltextInterface {

	protected $repositoryID;
	protected $phid;
	protected $commitIdentifier;
	protected $epoch;
	protected $mailKey;
	protected $authorPHID;
	protected $auditStatus = PhabricatorAuditCommitStatusConstants::NONE;
	protected $summary = '';
	protected $importStatus = 0;

	const IMPORTED_MESSAGE = 1;
	const IMPORTED_CHANGE = 2;
	const IMPORTED_OWNERS = 4;
	const IMPORTED_HERALD = 8;
	const IMPORTED_ALL = 15;

	const IMPORTED_CLOSEABLE = 1024;

	private $commitData = self::ATTACHABLE;
	private $audits = self::ATTACHABLE;
	private $repository = self::ATTACHABLE;
	private $customFields = self::ATTACHABLE;

	public function attachRepository(PhabricatorRepository $repository) {
	$this->repository = $repository;
	return $this;
	}

	public function getRepository($assert_attached = true) {
	if ($assert_attached) {
	return $this->assertAttached($this->repository);
	}
	return $this->repository;
	}

	public function isPartiallyImported($mask) {
	return (($mask & $this->getImportStatus()) == $mask);
	}

	public function isImported() {
	return $this->isPartiallyImported(self::IMPORTED_ALL);
	}

	public function writeImportStatusFlag($flag) {
	queryfx(
	$this->establishConnection('w'),
	'UPDATE %T SET importStatus = (importStatus \| %d) WHERE id = %d',
	$this->getTableName(),
	$flag,
	$this->getID());
	$this->setImportStatus($this->getImportStatus() \| $flag);
	return $this;
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_TIMESTAMPS => false,
	self::CONFIG_COLUMN_SCHEMA => array(
	'commitIdentifier' => 'text40',
	'mailKey' => 'bytes20',
	'authorPHID' => 'phid?',
	'auditStatus' => 'uint32',
	'summary' => 'text80',
	'importStatus' => 'uint32',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'repositoryID' => array(
	'columns' => array('repositoryID', 'importStatus'),
	),
	'authorPHID' => array(
	'columns' => array('authorPHID', 'auditStatus', 'epoch'),
	),
	'repositoryID_2' => array(
	'columns' => array('repositoryID', 'epoch'),
	),
	'key_commit_identity' => array(
	'columns' => array('commitIdentifier', 'repositoryID'),
	'unique' => true,
	),
	'key_epoch' => array(
	'columns' => array('epoch'),
	),
	'key_author' => array(
	'columns' => array('authorPHID', 'epoch'),
	),
	),
	self::CONFIG_NO_MUTATE => array(
	'importStatus',
	),
	) + parent::getConfiguration();
	}

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

	public function loadCommitData() {
	if (!$this->getID()) {
	return null;
	}
	return id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$this->getID());
	}

	public function attachCommitData(
	PhabricatorRepositoryCommitData $data = null) {
	$this->commitData = $data;
	return $this;
	}

	public function getCommitData() {
	return $this->assertAttached($this->commitData);
	}

	public function attachAudits(array $audits) {
	assert_instances_of($audits, 'PhabricatorRepositoryAuditRequest');
	$this->audits = $audits;
	return $this;
	}

	public function getAudits() {
	return $this->assertAttached($this->audits);
	}

	public function getAuthorityAudits(
	PhabricatorUser $user,
	array $authority_phids) {

	$authority = array_fill_keys($authority_phids, true);
	$audits = $this->getAudits();
	$authority_audits = array();
	foreach ($audits as $audit) {
	$has_authority = !empty($authority[$audit->getAuditorPHID()]);
	if ($has_authority) {
	$commit_author = $this->getAuthorPHID();

	// You don't have authority over package and project audits on your
	// own commits.

	$auditor_is_user = ($audit->getAuditorPHID() == $user->getPHID());
	$user_is_author = ($commit_author == $user->getPHID());

	if ($auditor_is_user \|\| !$user_is_author) {
	$authority_audits[$audit->getID()] = $audit;
	}
	}
	}
	return $authority_audits;
	}

	public function save() {
	if (!$this->mailKey) {
	$this->mailKey = Filesystem::readRandomCharacters(20);
	}
	return parent::save();
	}

	public function delete() {
	$data = $this->loadCommitData();
	$audits = id(new PhabricatorRepositoryAuditRequest())
	->loadAllWhere('commitPHID = %s', $this->getPHID());
	$this->openTransaction();

	if ($data) {
	$data->delete();
	}
	foreach ($audits as $audit) {
	$audit->delete();
	}
	$result = parent::delete();

	$this->saveTransaction();
	return $result;
	}

	public function getDateCreated() {
	// This is primarily to make analysis of commits with the Fact engine work.
	return $this->getEpoch();
	}

	public function getURI() {
	- $repository = $this->getRepository();
	- $callsign = $repository->getCallsign();
	- $commit_identifier = $this->getCommitIdentifier();
	- return '/r'.$callsign.$commit_identifier;
	+ return '/'.$this->getMonogram();
	}

	/**
	* Synchronize a commit's overall audit status with the individual audit
	* triggers.
	*/
	public function updateAuditStatus(array $requests) {
	assert_instances_of($requests, 'PhabricatorRepositoryAuditRequest');

	$any_concern = false;
	$any_accept = false;
	$any_need = false;

	foreach ($requests as $request) {
	switch ($request->getAuditStatus()) {
	case PhabricatorAuditStatusConstants::AUDIT_REQUIRED:
	$any_need = true;
	break;
	case PhabricatorAuditStatusConstants::ACCEPTED:
	$any_accept = true;
	break;
	case PhabricatorAuditStatusConstants::CONCERNED:
	$any_concern = true;
	break;
	}
	}

	if ($any_concern) {
	$status = PhabricatorAuditCommitStatusConstants::CONCERN_RAISED;
	} else if ($any_accept) {
	if ($any_need) {
	$status = PhabricatorAuditCommitStatusConstants::PARTIALLY_AUDITED;
	} else {
	$status = PhabricatorAuditCommitStatusConstants::FULLY_AUDITED;
	}
	} else if ($any_need) {
	$status = PhabricatorAuditCommitStatusConstants::NEEDS_AUDIT;
	} else {
	$status = PhabricatorAuditCommitStatusConstants::NONE;
	}

	return $this->setAuditStatus($status);
	}

	+ public function getMonogram() {
	+ $repository = $this->getRepository();
	+ $callsign = $repository->getCallsign();
	+ $identifier = $this->getCommitIdentifier();
	+
	+ return "r{$callsign}{$identifier}";
	+ }
	+

	/* -( PhabricatorPolicyInterface )----------------------------------------- */

	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getRepository()->getPolicy($capability);
	case PhabricatorPolicyCapability::CAN_EDIT:
	return PhabricatorPolicies::POLICY_USER;
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return $this->getRepository()->hasAutomaticCapability($capability, $viewer);
	}

	public function describeAutomaticCapability($capability) {
	return pht(
	'Commits inherit the policies of the repository they belong to.');
	}


	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */

	public function getUsersToNotifyOfTokenGiven() {
	return array(
	$this->getAuthorPHID(),
	);
	}

	/* -( Stuff for serialization )---------------------------------------------- */

	/**
	* NOTE: this is not a complete serialization; only the 'protected' fields are
	* involved. This is due to ease of (ab)using the Lisk abstraction to get this
	* done, as well as complexity of the other fields.
	*/
	public function toDictionary() {
	return array(
	'repositoryID' => $this->getRepositoryID(),
	'phid' => $this->getPHID(),
	'commitIdentifier' => $this->getCommitIdentifier(),
	'epoch' => $this->getEpoch(),
	'mailKey' => $this->getMailKey(),
	'authorPHID' => $this->getAuthorPHID(),
	'auditStatus' => $this->getAuditStatus(),
	'summary' => $this->getSummary(),
	'importStatus' => $this->getImportStatus(),
	);
	}

	public static function newFromDictionary(array $dict) {
	return id(new PhabricatorRepositoryCommit())
	->loadFromArray($dict);
	}


	/* -( HarbormasterBuildableInterface )------------------------------------- */


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

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

	public function getBuildVariables() {
	$results = array();

	$results['buildable.commit'] = $this->getCommitIdentifier();
	$repo = $this->getRepository();

	$results['repository.callsign'] = $repo->getCallsign();
	$results['repository.phid'] = $repo->getPHID();
	$results['repository.vcs'] = $repo->getVersionControlSystem();
	$results['repository.uri'] = $repo->getPublicCloneURI();

	return $results;
	}

	public function getAvailableBuildVariables() {
	return array(
	'buildable.commit' => pht('The commit identifier, if applicable.'),
	'repository.callsign' =>
	pht('The callsign of the repository in Phabricator.'),
	'repository.phid' =>
	pht('The PHID of the repository in Phabricator.'),
	'repository.vcs' =>
	pht('The version control system, either "svn", "hg" or "git".'),
	'repository.uri' =>
	pht('The URI to clone or checkout the repository from.'),
	);
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('diffusion.fields');
	}

	public function getCustomFieldBaseClass() {
	return 'PhabricatorCommitCustomField';
	}

	public function getCustomFields() {
	return $this->assertAttached($this->customFields);
	}

	public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
	$this->customFields = $fields;
	return $this;
	}


	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {

	// TODO: This should also list auditors, but handling that is a bit messy
	// right now because we are not guaranteed to have the data.

	return ($phid == $this->getAuthorPHID());
	}

	public function shouldShowSubscribersProperty() {
	return true;
	}

	public function shouldAllowSubscription($phid) {
	return true;
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PhabricatorAuditEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PhabricatorAuditTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	$xactions = $timeline->getTransactions();

	$path_ids = array();
	foreach ($xactions as $xaction) {
	if ($xaction->hasComment()) {
	$path_id = $xaction->getComment()->getPathID();
	if ($path_id) {
	$path_ids[] = $path_id;
	}
	}
	}

	$path_map = array();
	if ($path_ids) {
	$path_map = id(new DiffusionPathQuery())
	->withPathIDs($path_ids)
	->execute();
	$path_map = ipull($path_map, 'path', 'id');
	}

	return $timeline->setPathMap($path_map);
	}

	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new DiffusionCommitFulltextEngine();
	}

	}
	diff --git a/src/applications/repository/worker/PhabricatorRepositoryCommitParserWorker.php b/src/applications/repository/worker/PhabricatorRepositoryCommitParserWorker.php
	index cafb28d7f6..aa2aaa270b 100644
	--- a/src/applications/repository/worker/PhabricatorRepositoryCommitParserWorker.php
	+++ b/src/applications/repository/worker/PhabricatorRepositoryCommitParserWorker.php
	@@ -1,84 +1,80 @@
	<?php

	abstract class PhabricatorRepositoryCommitParserWorker
	extends PhabricatorWorker {

	protected $commit;
	protected $repository;

	private function loadCommit() {
	if ($this->commit) {
	return $this->commit;
	}

	$commit_id = idx($this->getTaskData(), 'commitID');
	if (!$commit_id) {
	throw new PhabricatorWorkerPermanentFailureException(
	pht('No "%s" in task data.', 'commitID'));
	}

	- $commit = id(new PhabricatorRepositoryCommit())->load($commit_id);
	-
	+ $commit = id(new DiffusionCommitQuery())
	+ ->setViewer(PhabricatorUser::getOmnipotentUser())
	+ ->withIDs(array($commit_id))
	+ ->executeOne();
	if (!$commit) {
	throw new PhabricatorWorkerPermanentFailureException(
	pht('Commit "%s" does not exist.', $commit_id));
	}

	- return $this->commit = $commit;
	+ $this->commit = $commit;
	+
	+ return $commit;
	}

	final protected function doWork() {
	- if (!$this->loadCommit()) {
	- return;
	- }
	-
	- $repository = id(new PhabricatorRepositoryQuery())
	- ->setViewer(PhabricatorUser::getOmnipotentUser())
	- ->withIDs(array($this->commit->getRepositoryID()))
	- ->executeOne();
	- if (!$repository) {
	- return;
	- }
	+ $commit = $this->loadCommit();
	+ $repository = $commit->getRepository();

	$this->repository = $repository;
	+
	$this->parseCommit($repository, $this->commit);
	}

	final protected function shouldQueueFollowupTasks() {
	return !idx($this->getTaskData(), 'only');
	}

	abstract protected function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit);

	- protected function isBadCommit($full_commit_name) {
	+ protected function isBadCommit(PhabricatorRepositoryCommit $commit) {
	$repository = new PhabricatorRepository();

	$bad_commit = queryfx_one(
	$repository->establishConnection('w'),
	'SELECT * FROM %T WHERE fullCommitName = %s',
	PhabricatorRepository::TABLE_BADCOMMIT,
	- $full_commit_name);
	+ $commit->getMonogram());

	return (bool)$bad_commit;
	}

	public function renderForDisplay(PhabricatorUser $viewer) {
	$suffix = parent::renderForDisplay($viewer);

	$commit = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIDs(array(idx($this->getTaskData(), 'commitID')))
	->executeOne();
	if (!$commit) {
	return $suffix;
	}

	$link = DiffusionView::linkCommit(
	$commit->getRepository(),
	$commit->getCommitIdentifier());

	return array($link, $suffix);
	}
	}
	diff --git a/src/applications/repository/worker/commitchangeparser/PhabricatorRepositoryCommitChangeParserWorker.php b/src/applications/repository/worker/commitchangeparser/PhabricatorRepositoryCommitChangeParserWorker.php
	index 6563c4442c..6a0161fd06 100644
	--- a/src/applications/repository/worker/commitchangeparser/PhabricatorRepositoryCommitChangeParserWorker.php
	+++ b/src/applications/repository/worker/commitchangeparser/PhabricatorRepositoryCommitChangeParserWorker.php
	@@ -1,155 +1,151 @@
	<?php

	abstract class PhabricatorRepositoryCommitChangeParserWorker
	extends PhabricatorRepositoryCommitParserWorker {

	public function getRequiredLeaseTime() {
	// It can take a very long time to parse commits; some commits in the
	// Facebook repository affect many millions of paths. Acquire 24h leases.
	return phutil_units('24 hours in seconds');
	}

	abstract protected function parseCommitChanges(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit);

	protected function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	- $identifier = $commit->getCommitIdentifier();
	- $callsign = $repository->getCallsign();
	- $full_name = 'r'.$callsign.$identifier;
	-
	- $this->log("%s\n", pht('Parsing %s...', $full_name));
	- if ($this->isBadCommit($full_name)) {
	+ $this->log("%s\n", pht('Parsing "%s"...', $commit->getMonogram()));
	+ if ($this->isBadCommit($commit)) {
	$this->log(pht('This commit is marked bad!'));
	return;
	}

	$results = $this->parseCommitChanges($repository, $commit);
	if ($results) {
	$this->writeCommitChanges($repository, $commit, $results);
	}

	$this->finishParse();
	}

	public function parseChangesForUnitTest(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {
	return $this->parseCommitChanges($repository, $commit);
	}

	public static function lookupOrCreatePaths(array $paths) {
	$repository = new PhabricatorRepository();
	$conn_w = $repository->establishConnection('w');

	$result_map = self::lookupPaths($paths);

	$missing_paths = array_fill_keys($paths, true);
	$missing_paths = array_diff_key($missing_paths, $result_map);
	$missing_paths = array_keys($missing_paths);

	if ($missing_paths) {
	foreach (array_chunk($missing_paths, 128) as $path_chunk) {
	$sql = array();
	foreach ($path_chunk as $path) {
	$sql[] = qsprintf($conn_w, '(%s, %s)', $path, md5($path));
	}
	queryfx(
	$conn_w,
	'INSERT IGNORE INTO %T (path, pathHash) VALUES %Q',
	PhabricatorRepository::TABLE_PATH,
	implode(', ', $sql));
	}
	$result_map += self::lookupPaths($missing_paths);
	}

	return $result_map;
	}

	private static function lookupPaths(array $paths) {
	$repository = new PhabricatorRepository();
	$conn_w = $repository->establishConnection('w');

	$result_map = array();
	foreach (array_chunk($paths, 128) as $path_chunk) {
	$chunk_map = queryfx_all(
	$conn_w,
	'SELECT path, id FROM %T WHERE pathHash IN (%Ls)',
	PhabricatorRepository::TABLE_PATH,
	array_map('md5', $path_chunk));
	foreach ($chunk_map as $row) {
	$result_map[$row['path']] = $row['id'];
	}
	}
	return $result_map;
	}

	protected function finishParse() {
	$commit = $this->commit;

	$commit->writeImportStatusFlag(
	PhabricatorRepositoryCommit::IMPORTED_CHANGE);

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

	if ($this->shouldQueueFollowupTasks()) {
	$this->queueTask(
	'PhabricatorRepositoryCommitOwnersWorker',
	array(
	'commitID' => $commit->getID(),
	));
	}
	}

	private function writeCommitChanges(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	array $changes) {

	$repository_id = (int)$repository->getID();
	$commit_id = (int)$commit->getID();

	// NOTE: This SQL is being built manually instead of with qsprintf()
	// because some SVN changes affect an enormous number of paths (millions)
	// and this showed up as significantly slow on a profile at some point.

	$changes_sql = array();
	foreach ($changes as $change) {
	$values = array(
	$repository_id,
	(int)$change->getPathID(),
	$commit_id,
	nonempty((int)$change->getTargetPathID(), 'null'),
	nonempty((int)$change->getTargetCommitID(), 'null'),
	(int)$change->getChangeType(),
	(int)$change->getFileType(),
	(int)$change->getIsDirect(),
	(int)$change->getCommitSequence(),
	);
	$changes_sql[] = '('.implode(', ', $values).')';
	}

	$conn_w = $repository->establishConnection('w');

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE commitID = %d',
	PhabricatorRepository::TABLE_PATHCHANGE,
	$commit_id);

	foreach (PhabricatorLiskDAO::chunkSQL($changes_sql) as $chunk) {
	queryfx(
	$conn_w,
	'INSERT INTO %T
	(repositoryID, pathID, commitID, targetPathID, targetCommitID,
	changeType, fileType, isDirect, commitSequence)
	VALUES %Q',
	PhabricatorRepository::TABLE_PATHCHANGE,
	$chunk);
	}
	}

	}
	diff --git a/src/applications/search/engine/PhabricatorJumpNavHandler.php b/src/applications/search/engine/PhabricatorJumpNavHandler.php
	index 9e810e3977..6c30af98dd 100644
	--- a/src/applications/search/engine/PhabricatorJumpNavHandler.php
	+++ b/src/applications/search/engine/PhabricatorJumpNavHandler.php
	@@ -1,117 +1,117 @@
	<?php

	final class PhabricatorJumpNavHandler extends Phobject {

	public static function getJumpResponse(PhabricatorUser $viewer, $jump) {
	$jump = trim($jump);

	$patterns = array(
	'/^a$/i' => 'uri:/audit/',
	'/^f$/i' => 'uri:/feed/',
	'/^d$/i' => 'uri:/differential/',
	'/^r$/i' => 'uri:/diffusion/',
	'/^t$/i' => 'uri:/maniphest/',
	'/^p$/i' => 'uri:/project/',
	'/^u$/i' => 'uri:/people/',
	'/^p\s+(.+)$/i' => 'project',
	'/^u\s+(\S+)$/i' => 'user',
	'/^(?:s)\s+(\S+)/i' => 'find-symbol',
	'/^r\s+(.+)$/i' => 'find-repository',
	);

	foreach ($patterns as $pattern => $effect) {
	$matches = null;
	if (preg_match($pattern, $jump, $matches)) {
	if (!strncmp($effect, 'uri:', 4)) {
	return id(new AphrontRedirectResponse())
	->setURI(substr($effect, 4));
	} else {
	switch ($effect) {
	case 'user':
	return id(new AphrontRedirectResponse())
	->setURI('/p/'.$matches[1].'/');
	case 'project':
	$project = self::findCloselyNamedProject($matches[1]);
	if ($project) {
	return id(new AphrontRedirectResponse())
	->setURI('/project/view/'.$project->getID().'/');
	} else {
	$jump = $matches[1];
	}
	break;
	case 'find-symbol':
	$context = '';
	$symbol = $matches[1];
	$parts = array();
	if (preg_match('/(.)(?:\\.\|::\|->)(.)/', $symbol, $parts)) {
	$context = '&context='.phutil_escape_uri($parts[1]);
	$symbol = $parts[2];
	}
	return id(new AphrontRedirectResponse())
	->setURI("/diffusion/symbol/$symbol/?jump=true$context");
	case 'find-repository':
	$name = $matches[1];
	$repositories = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->withNameContains($name)
	->execute();
	if (count($repositories) == 1) {
	// Just one match, jump to repository.
	- $uri = '/diffusion/'.head($repositories)->getCallsign().'/';
	+ $uri = head($repositories)->getURI();
	} else {
	// More than one match, jump to search.
	$uri = urisprintf('/diffusion/?order=name&name=%s', $name);
	}
	return id(new AphrontRedirectResponse())->setURI($uri);
	default:
	throw new Exception(pht("Unknown jump effect '%s'!", $effect));
	}
	}
	}
	}

	// If none of the patterns matched, look for an object by name.
	$objects = id(new PhabricatorObjectQuery())
	->setViewer($viewer)
	->withNames(array($jump))
	->execute();

	if (count($objects) == 1) {
	$handle = id(new PhabricatorHandleQuery())
	->setViewer($viewer)
	->withPHIDs(mpull($objects, 'getPHID'))
	->executeOne();

	return id(new AphrontRedirectResponse())->setURI($handle->getURI());
	}

	return null;
	}

	private static function findCloselyNamedProject($name) {
	$project = id(new PhabricatorProject())->loadOneWhere(
	'name = %s',
	$name);
	if ($project) {
	return $project;
	} else { // no exact match, try a fuzzy match
	$projects = id(new PhabricatorProject())->loadAllWhere(
	'name LIKE %~',
	$name);
	if ($projects) {
	$min_name_length = PHP_INT_MAX;
	$best_project = null;
	foreach ($projects as $project) {
	$name_length = strlen($project->getName());
	if ($name_length <= $min_name_length) {
	$min_name_length = $name_length;
	$best_project = $project;
	}
	}
	return $best_project;
	} else {
	return null;
	}
	}
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Aug 15, 10:16 AM (6 d, 11 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 195782
Default Alt Text: (38 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions