No OneTemporary
Actions

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/diffusion/controller/DiffusionRepositoryController.php b/src/applications/diffusion/controller/DiffusionRepositoryController.php
	index 6183c88136..c3d27ac196 100644
	--- a/src/applications/diffusion/controller/DiffusionRepositoryController.php
	+++ b/src/applications/diffusion/controller/DiffusionRepositoryController.php
	@@ -1,456 +1,457 @@
	<?php

	final class DiffusionRepositoryController extends DiffusionController {

	public function shouldAllowPublic() {
	return true;
	}

	public function processRequest() {
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$content = array();

	$crumbs = $this->buildCrumbs();
	$content[] = $crumbs;

	$content[] = $this->buildPropertiesTable($drequest->getRepository());
	$phids = array();

	try {
	$history_results = $this->callConduitWithDiffusionRequest(
	'diffusion.historyquery',
	array(
	'commit' => $drequest->getCommit(),
	'path' => $drequest->getPath(),
	'offset' => 0,
	'limit' => 15));
	$history = DiffusionPathChange::newFromConduit(
	$history_results['pathChanges']);

	foreach ($history as $item) {
	$data = $item->getCommitData();
	if ($data) {
	if ($data->getCommitDetail('authorPHID')) {
	$phids[$data->getCommitDetail('authorPHID')] = true;
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[$data->getCommitDetail('committerPHID')] = true;
	}
	}
	}
	$history_exception = null;
	} catch (Exception $ex) {
	$history_results = null;
	$history = null;
	$history_exception = $ex;
	}

	try {
	$browse_results = DiffusionBrowseResultSet::newFromConduit(
	$this->callConduitWithDiffusionRequest(
	'diffusion.browsequery',
	array(
	'path' => $drequest->getPath(),
	'commit' => $drequest->getCommit(),
	)));
	$browse_paths = $browse_results->getPaths();

	foreach ($browse_paths as $item) {
	$data = $item->getLastCommitData();
	if ($data) {
	if ($data->getCommitDetail('authorPHID')) {
	$phids[$data->getCommitDetail('authorPHID')] = true;
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[$data->getCommitDetail('committerPHID')] = true;
	}
	}
	}

	$browse_exception = null;
	} catch (Exception $ex) {
	$browse_results = null;
	$browse_paths = null;
	$browse_exception = $ex;
	}

	$phids = array_keys($phids);
	$handles = $this->loadViewerHandles($phids);

	if ($browse_results) {
	$readme = $this->callConduitWithDiffusionRequest(
	'diffusion.readmequery',
	array(
	'paths' => $browse_results->getPathDicts()
	));
	} else {
	$readme = null;
	}

	$content[] = $this->buildHistoryTable(
	$history_results,
	$history,
	$history_exception,
	$handles);

	$content[] = $this->buildBrowseTable(
	$browse_results,
	$browse_paths,
	$browse_exception,
	$handles);

	try {
	$content[] = $this->buildTagListTable($drequest);
	} catch (Exception $ex) {
	if (!$repository->isImporting()) {
	$content[] = $this->renderStatusMessage(
	pht('Unable to Load Tags'),
	$ex->getMessage());
	}
	}

	try {
	$content[] = $this->buildBranchListTable($drequest);
	} catch (Exception $ex) {
	if (!$repository->isImporting()) {
	$content[] = $this->renderStatusMessage(
	pht('Unable to Load Branches'),
	$ex->getMessage());
	}
	}

	if ($readme) {
	$box = new PHUIBoxView();
	$box->setShadow(true);
	$box->appendChild($readme);
	$box->addPadding(PHUI::PADDING_LARGE);

	$panel = new AphrontPanelView();
	$panel->setHeader(pht('README'));
	$panel->setNoBackground();
	$panel->appendChild($box);
	$content[] = $panel;
	}

	return $this->buildApplicationPage(
	$content,
	array(
	'title' => $drequest->getRepository()->getName(),
	'device' => true,
	));
	}

	private function buildPropertiesTable(PhabricatorRepository $repository) {
	$user = $this->getRequest()->getUser();

	$header = id(new PHUIHeaderView())
	->setHeader($repository->getName())
	->setUser($user)
	->setPolicyObject($repository);

	if (!$repository->isTracked()) {
	$header->setStatus('policy-noone', '', pht('Inactive'));
	} else if ($repository->isImporting()) {
	$header->setStatus('time', 'red', pht('Importing...'));
	} else {
	$header->setStatus('oh-ok', '', pht('Active'));
	}


	$actions = $this->buildActionList($repository);

	$view = id(new PHUIPropertyListView())
	->setUser($user);
	$view->addProperty(pht('Callsign'), $repository->getCallsign());

	switch ($repository->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$view->addProperty(
	pht('Clone URI'),
	$repository->getPublicRemoteURI());
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$view->addProperty(
	pht('Repository Root'),
	$repository->getPublicRemoteURI());
	break;
	}

	$description = $repository->getDetail('description');
	if (strlen($description)) {
	$description = PhabricatorMarkupEngine::renderOneObject(
	$repository,
	'description',
	$user);
	$view->addSectionHeader(pht('Description'));
	$view->addTextContent($description);
	}

	$view->setActionList($actions);

	return id(new PHUIObjectBoxView())
	->setHeader($header)
	->addPropertyList($view);

	}

	private function buildBranchListTable(DiffusionRequest $drequest) {
	- if ($drequest->getBranch() !== null) {
	- $limit = 15;
	+ $viewer = $this->getRequest()->getUser();

	- $branches = DiffusionBranchInformation::newFromConduit(
	- $this->callConduitWithDiffusionRequest(
	- 'diffusion.branchquery',
	- array(
	- 'limit' => $limit
	- )));
	- if (!$branches) {
	- return null;
	- }
	+ if ($drequest->getBranch() === null) {
	+ return null;
	+ }

	- $more_branches = (count($branches) > $limit);
	- $branches = array_slice($branches, 0, $limit);
	+ $limit = 15;

	- $commits = id(new PhabricatorAuditCommitQuery())
	- ->withIdentifiers(
	- $drequest->getRepository()->getID(),
	- mpull($branches, 'getHeadCommitIdentifier'))
	- ->needCommitData(true)
	- ->execute();
	+ $branches = DiffusionBranchInformation::newFromConduit(
	+ $this->callConduitWithDiffusionRequest(
	+ 'diffusion.branchquery',
	+ array(
	+ 'limit' => $limit + 1,
	+ )));
	+ if (!$branches) {
	+ return null;
	+ }

	- $table = new DiffusionBranchTableView();
	- $table->setDiffusionRequest($drequest);
	- $table->setBranches($branches);
	- $table->setCommits($commits);
	- $table->setUser($this->getRequest()->getUser());
	+ $more_branches = (count($branches) > $limit);
	+ $branches = array_slice($branches, 0, $limit);

	- $panel = new AphrontPanelView();
	- $panel->setHeader(pht('Branches'));
	- $panel->setNoBackground();
	+ $commits = id(new DiffusionCommitQuery())
	+ ->setViewer($viewer)
	+ ->withIdentifiers(mpull($branches, 'getHeadCommitIdentifier'))
	+ ->withRepositoryIDs(array($drequest->getRepository()->getID()))
	+ ->execute();

	- if ($more_branches) {
	- $panel->setCaption(pht('Showing %d branches.', $limit));
	- }
	+ $table = new DiffusionBranchTableView();
	+ $table->setDiffusionRequest($drequest);
	+ $table->setBranches($branches);
	+ $table->setCommits($commits);
	+ $table->setUser($this->getRequest()->getUser());

	- $panel->addButton(
	- phutil_tag(
	- 'a',
	- array(
	- 'href' => $drequest->generateURI(
	- array(
	- 'action' => 'branches',
	- )),
	- 'class' => 'grey button',
	- ),
	- pht("Show All Branches \xC2\xBB")));
	-
	- $panel->appendChild($table);
	+ $panel = new AphrontPanelView();
	+ $panel->setHeader(pht('Branches'));
	+ $panel->setNoBackground();

	- return $panel;
	+ if ($more_branches) {
	+ $panel->setCaption(pht('Showing %d branches.', $limit));
	}

	- return null;
	+ $panel->addButton(
	+ phutil_tag(
	+ 'a',
	+ array(
	+ 'href' => $drequest->generateURI(
	+ array(
	+ 'action' => 'branches',
	+ )),
	+ 'class' => 'grey button',
	+ ),
	+ pht("Show All Branches \xC2\xBB")));
	+
	+ $panel->appendChild($table);
	+
	+ return $panel;
	}

	private function buildTagListTable(DiffusionRequest $drequest) {
	$tag_limit = 15;
	$tags = array();
	try {
	$tags = DiffusionRepositoryTag::newFromConduit(
	$this->callConduitWithDiffusionRequest(
	'diffusion.tagsquery',
	array(
	// On the home page, we want to find tags on any branch.
	'commit' => null,
	'limit' => $tag_limit + 1,
	)));
	} catch (ConduitException $e) {
	if ($e->getMessage() != 'ERR-UNSUPPORTED-VCS') {
	throw $e;
	}
	}

	if (!$tags) {
	return null;
	}

	$more_tags = (count($tags) > $tag_limit);
	$tags = array_slice($tags, 0, $tag_limit);

	$commits = id(new PhabricatorAuditCommitQuery())
	->withIdentifiers(
	$drequest->getRepository()->getID(),
	mpull($tags, 'getCommitIdentifier'))
	->needCommitData(true)
	->execute();

	$view = new DiffusionTagListView();
	$view->setDiffusionRequest($drequest);
	$view->setTags($tags);
	$view->setUser($this->getRequest()->getUser());
	$view->setCommits($commits);

	$phids = $view->getRequiredHandlePHIDs();
	$handles = $this->loadViewerHandles($phids);
	$view->setHandles($handles);

	$panel = new AphrontPanelView();
	$panel->setHeader(pht('Tags'));
	$panel->setNoBackground(true);

	if ($more_tags) {
	$panel->setCaption(pht('Showing the %d most recent tags.', $tag_limit));
	}

	$panel->addButton(
	phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'tags',
	)),
	'class' => 'grey button',
	),
	pht("Show All Tags \xC2\xBB")));
	$panel->appendChild($view);

	return $panel;
	}

	private function buildActionList(PhabricatorRepository $repository) {
	$viewer = $this->getRequest()->getUser();

	$view_uri = $this->getApplicationURI($repository->getCallsign().'/');
	$edit_uri = $this->getApplicationURI($repository->getCallsign().'/edit/');

	$view = id(new PhabricatorActionListView())
	->setUser($viewer)
	->setObject($repository)
	->setObjectURI($view_uri);

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$repository,
	PhabricatorPolicyCapability::CAN_EDIT);

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit Repository'))
	->setIcon('edit')
	->setHref($edit_uri)
	->setWorkflow(!$can_edit)
	->setDisabled(!$can_edit));

	return $view;
	}

	private function buildHistoryTable(
	$history_results,
	$history,
	$history_exception,
	array $handles) {

	$request = $this->getRequest();
	$viewer = $request->getUser();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	if ($history_exception) {
	if ($repository->isImporting()) {
	return $this->renderStatusMessage(
	pht('Still Importing...'),
	pht(
	'This repository is still importing. History is not yet '.
	'available.'));
	} else {
	return $this->renderStatusMessage(
	pht('Unable to Retrieve History'),
	$history_exception->getMessage());
	}
	}

	$history_table = id(new DiffusionHistoryTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setHandles($handles)
	->setHistory($history);

	// TODO: Super sketchy.
	$history_table->loadRevisions();

	if ($history_results) {
	$history_table->setParents($history_results['parents']);
	}

	$history_table->setIsHead(true);

	$callsign = $drequest->getRepository()->getCallsign();
	$all = phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'history',
	)),
	),
	pht('View Full Commit History'));

	$panel = new AphrontPanelView();
	$panel->setHeader(pht("Recent Commits · %s", $all));
	$panel->appendChild($history_table);
	$panel->setNoBackground();

	return $panel;
	}

	private function buildBrowseTable(
	$browse_results,
	$browse_paths,
	$browse_exception,
	array $handles) {

	$request = $this->getRequest();
	$viewer = $request->getUser();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	if ($browse_exception) {
	if ($repository->isImporting()) {
	// The history table renders a useful message.
	return null;
	} else {
	return $this->renderStatusMessage(
	pht('Unable to Retrieve Paths'),
	$browse_exception->getMessage());
	}
	}

	$browse_table = id(new DiffusionBrowseTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setHandles($handles);
	if ($browse_paths) {
	$browse_table->setPaths($browse_paths);
	} else {
	$browse_table->setPaths(array());
	}

	$browse_uri = $drequest->generateURI(array('action' => 'browse'));

	$browse_panel = new AphrontPanelView();
	$browse_panel->setHeader(
	phutil_tag(
	'a',
	array('href' => $browse_uri),
	pht('Browse Repository')));
	$browse_panel->appendChild($browse_table);
	$browse_panel->setNoBackground();

	return $browse_panel;
	}

	}
	diff --git a/src/applications/diffusion/query/DiffusionCommitQuery.php b/src/applications/diffusion/query/DiffusionCommitQuery.php
	index 3522b6e7fa..ba981ae9a7 100644
	--- a/src/applications/diffusion/query/DiffusionCommitQuery.php
	+++ b/src/applications/diffusion/query/DiffusionCommitQuery.php
	@@ -1,257 +1,293 @@
	<?php

	final class DiffusionCommitQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $identifiers;
	private $phids;
	private $defaultRepository;
	private $identifierMap;
	+ private $repositoryIDs;
	+
	+ private $needCommitData;

	/**
	* Load commits by partial or full identifiers, e.g. "rXab82393", "rX1234",
	* or "a9caf12". When an identifier matches multiple commits, they will all
	* be returned; callers should be prepared to deal with more results than
	* they queried for.
	*/
	public function withIdentifiers(array $identifiers) {
	$this->identifiers = $identifiers;
	return $this;
	}

	/**
	* If a default repository is provided, ambiguous commit identifiers will
	* be assumed to belong to the default repository.
	*
	* For example, "r123" appearing in a commit message in repository X is
	* likely to be unambiguously "rX123". Normally the reference would be
	* considered ambiguous, but if you provide a default repository it will
	* be correctly resolved.
	*/
	public function withDefaultRepository(PhabricatorRepository $repository) {
	$this->defaultRepository = $repository;
	return $this;
	}

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

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

	+ public function needCommitData($need) {
	+ $this->needCommitData = $need;
	+ return $this;
	+ }
	+
	public function getIdentifierMap() {
	if ($this->identifierMap === null) {
	throw new Exception(
	"You must execute() the query before accessing the identifier map.");
	}
	return $this->identifierMap;
	}

	protected function loadPage() {
	if ($this->identifierMap === null) {
	$this->identifierMap = array();
	}

	$table = new PhabricatorRepositoryCommit();
	$conn_r = $table->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T %Q %Q %Q',
	$table->getTableName(),
	$this->buildWhereClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

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

	- public function willFilterPage(array $commits) {
	+ protected function willFilterPage(array $commits) {
	$repository_ids = mpull($commits, 'getRepositoryID', 'getRepositoryID');
	$repos = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withIDs($repository_ids)
	->execute();

	foreach ($commits as $key => $commit) {
	$repo = idx($repos, $commit->getRepositoryID());
	if ($repo) {
	$commit->attachRepository($repo);
	} else {
	unset($commits[$key]);
	}
	}

	if ($this->identifiers !== null) {
	$ids = array_fuse($this->identifiers);
	$min_qualified = PhabricatorRepository::MINIMUM_QUALIFIED_HASH;

	$result = array();
	foreach ($commits as $commit) {
	$prefix = 'r'.$commit->getRepository()->getCallsign();
	$suffix = $commit->getCommitIdentifier();

	if ($commit->getRepository()->isSVN()) {
	if (isset($ids[$prefix.$suffix])) {
	$result[$prefix.$suffix][] = $commit;
	}
	} else {
	// This awkward contruction is so we can link the commits up in O(N)
	// time instead of O(N^2).
	for ($ii = $min_qualified; $ii <= strlen($suffix); $ii++) {
	$part = substr($suffix, 0, $ii);
	if (isset($ids[$prefix.$part])) {
	$result[$prefix.$part][] = $commit;
	}
	if (isset($ids[$part])) {
	$result[$part][] = $commit;
	}
	}
	}
	}

	foreach ($result as $identifier => $matching_commits) {
	if (count($matching_commits) == 1) {
	$result[$identifier] = head($matching_commits);
	} else {
	// This reference is ambiguous (it matches more than one commit) so
	// don't link it
	unset($result[$identifier]);
	}
	}

	$this->identifierMap += $result;
	}

	return $commits;
	}

	+ protected function didFilterPage(array $commits) {
	+
	+ if ($this->needCommitData) {
	+ $data = id(new PhabricatorRepositoryCommitData())->loadAllWhere(
	+ 'commitID in (%Ld)',
	+ mpull($commits, 'getID'));
	+ $data = mpull($data, null, 'getCommitID');
	+ foreach ($commits as $commit) {
	+ $commit_data = idx($data, $commit->getID());
	+ $commit->attachCommitData($commit_data);
	+ }
	+ }
	+
	+ return $commits;
	+ }
	+
	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if ($this->identifiers) {
	$min_unqualified = PhabricatorRepository::MINIMUM_UNQUALIFIED_HASH;
	$min_qualified = PhabricatorRepository::MINIMUM_QUALIFIED_HASH;

	$refs = array();
	$bare = array();
	foreach ($this->identifiers as $identifier) {
	$matches = null;
	preg_match('/^(?:r([A-Z]+))?(.*)$/', $identifier, $matches);
	$repo = nonempty($matches[1], null);
	$identifier = nonempty($matches[2], null);

	if ($repo === null) {
	if ($this->defaultRepository) {
	$repo = $this->defaultRepository->getCallsign();
	}
	}

	if ($repo === null) {
	if (strlen($identifier) < $min_unqualified) {
	continue;
	}
	$bare[] = $identifier;
	} else {
	$refs[] = array(
	'callsign' => $repo,
	'identifier' => $identifier,
	);
	}
	}

	$sql = array();

	foreach ($bare as $identifier) {
	$sql[] = qsprintf(
	$conn_r,
	'(commitIdentifier LIKE %> AND LENGTH(commitIdentifier) = 40)',
	$identifier);
	}

	if ($refs) {
	$callsigns = ipull($refs, 'callsign');
	$repos = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withCallsigns($callsigns)
	->execute();
	$repos = mpull($repos, null, 'getCallsign');

	foreach ($refs as $key => $ref) {
	$repo = idx($repos, $ref['callsign']);
	if (!$repo) {
	continue;
	}

	if ($repo->isSVN()) {
	if (!ctype_digit($ref['identifier'])) {
	continue;
	}
	$sql[] = qsprintf(
	$conn_r,
	'(repositoryID = %d AND commitIdentifier = %s)',
	$repo->getID(),
	// NOTE: Because the 'commitIdentifier' column is a string, MySQL
	// ignores the index if we hand it an integer. Hand it a string.
	// See T3377.
	(int)$ref['identifier']);
	} else {
	if (strlen($ref['identifier']) < $min_qualified) {
	continue;
	}
	$sql[] = qsprintf(
	$conn_r,
	'(repositoryID = %d AND commitIdentifier LIKE %>)',
	$repo->getID(),
	$ref['identifier']);
	}
	}
	}

	if (!$sql) {
	// If we discarded all possible identifiers (e.g., they all referenced
	// bogus repositories or were all too short), make sure the query finds
	// nothing.
	throw new PhabricatorEmptyQueryException('No commit identifiers.');
	}

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

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

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

	+ if ($this->repositoryIDs) {
	+ $where[] = qsprintf(
	+ $conn_r,
	+ 'repositoryID IN (%Ld)',
	+ $this->repositoryIDs);
	+ }
	+
	return $this->formatWhereClause($where);
	}

	public function didFilterResults(array $filtered) {
	if ($this->identifierMap) {
	foreach ($this->identifierMap as $name => $commit) {
	if (isset($filtered[$commit->getPHID()])) {
	unset($this->identifierMap[$name]);
	}
	}
	}
	}

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

	}
	diff --git a/src/applications/diffusion/view/DiffusionBranchTableView.php b/src/applications/diffusion/view/DiffusionBranchTableView.php
	index 3da9c8c1f2..001af93685 100644
	--- a/src/applications/diffusion/view/DiffusionBranchTableView.php
	+++ b/src/applications/diffusion/view/DiffusionBranchTableView.php
	@@ -1,94 +1,90 @@
	<?php

	final class DiffusionBranchTableView extends DiffusionView {

	private $branches;
	private $commits = array();

	public function setBranches(array $branches) {
	assert_instances_of($branches, 'DiffusionBranchInformation');
	$this->branches = $branches;
	return $this;
	}

	public function setCommits(array $commits) {
	$this->commits = mpull($commits, null, 'getCommitIdentifier');
	return $this;
	}

	public function render() {
	$drequest = $this->getDiffusionRequest();
	$current_branch = $drequest->getBranch();

	$rows = array();
	$rowc = array();
	foreach ($this->branches as $branch) {
	$commit = idx($this->commits, $branch->getHeadCommitIdentifier());
	if ($commit) {
	- $details = $commit->getCommitData()->getCommitMessage();
	- $details = idx(explode("\n", $details), 0);
	- $details = substr($details, 0, 80);
	-
	+ $details = $commit->getSummary();
	$datetime = phabricator_datetime($commit->getEpoch(), $this->user);
	} else {
	$datetime = null;
	$details = null;
	}

	$rows[] = array(
	phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'history',
	'branch' => $branch->getName(),
	))
	),
	pht('History')),
	phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'browse',
	'branch' => $branch->getName(),
	)),
	),
	$branch->getName()),
	self::linkCommit(
	$drequest->getRepository(),
	$branch->getHeadCommitIdentifier()),
	$datetime,
	AphrontTableView::renderSingleDisplayLine($details),
	- // TODO: etc etc
	);
	if ($branch->getName() == $current_branch) {
	$rowc[] = 'highlighted';
	} else {
	$rowc[] = null;
	}
	}

	$view = new AphrontTableView($rows);
	$view->setHeaders(
	array(
	pht('History'),
	pht('Branch'),
	pht('Head'),
	pht('Modified'),
	pht('Details'),
	));
	$view->setColumnClasses(
	array(
	'',
	'pri',
	'',
	'',
	'wide',
	));
	$view->setRowClasses($rowc);
	return $view->render();
	}

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	index a999726162..55ee28dac4 100644
	--- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	+++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	@@ -1,237 +1,238 @@
	<?php

	final class PhabricatorRepositoryCommit
	extends PhabricatorRepositoryDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorFlaggableInterface,
	PhabricatorTokenReceiverInterface {

	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;

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

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

	public function getRepository() {
	return $this->assertAttached($this->repository);
	}

	public function setIsUnparsed($is_unparsed) {
	$this->isUnparsed = $is_unparsed;
	return $this;
	}

	public function getIsUnparsed() {
	return $this->isUnparsed;
	}

	public function isImported() {
	return ($this->getImportStatus() == 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());
	return $this;
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_TIMESTAMPS => false,
	) + parent::getConfiguration();
	}

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

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

	- public function attachCommitData(PhabricatorRepositoryCommitData $data) {
	+ 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, 'PhabricatorAuditComment');
	$this->audits = $audits;
	return $this;
	}

	public function getAudits() {
	return $this->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();
	}

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


	/* -( 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:
	// TODO: (T603) Who should be able to edit a commit? For now, retain
	// the existing policy.
	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());
	}

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

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 20:16 (1 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1128371
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions