No OneTemporary
Actions

Size

46 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/audit/constants/PhabricatorAuditCommitStatusConstants.php b/src/applications/audit/constants/PhabricatorAuditCommitStatusConstants.php
	index 877fd0b4ba..e559862c83 100644
	--- a/src/applications/audit/constants/PhabricatorAuditCommitStatusConstants.php
	+++ b/src/applications/audit/constants/PhabricatorAuditCommitStatusConstants.php
	@@ -1,96 +1,140 @@
	<?php

	final class PhabricatorAuditCommitStatusConstants extends Phobject {

	+ private $key;
	+ private $spec = array();
	+
	const NONE = 0;
	const NEEDS_AUDIT = 1;
	const CONCERN_RAISED = 2;
	const PARTIALLY_AUDITED = 3;
	const FULLY_AUDITED = 4;
	const NEEDS_VERIFICATION = 5;

	const MODERN_NONE = 'none';
	const MODERN_NEEDS_AUDIT = 'needs-audit';
	const MODERN_CONCERN_RAISED = 'concern-raised';
	const MODERN_PARTIALLY_AUDITED = 'partially-audited';
	const MODERN_AUDITED = 'audited';
	const MODERN_NEEDS_VERIFICATION = 'needs-verification';

	+ public static function newForLegacyStatus($status) {
	+ $map = self::getMap();
	+
	+ foreach ($map as $key => $spec) {
	+ if (idx($spec, 'legacy') == $status) {
	+ return self::newForStatus($key);
	+ }
	+ }
	+
	+ return self::newForStatus($status);
	+ }
	+
	+ public static function newForStatus($status) {
	+ $result = new self();
	+
	+ $result->key = $status;
	+
	+ $map = self::getMap();
	+ if (isset($map[$status])) {
	+ $result->spec = $map[$status];
	+ }
	+
	+ return $result;
	+ }
	+
	+ public function getKey() {
	+ return $this->key;
	+ }
	+
	+ public function getIcon() {
	+ return idx($this->spec, 'icon');
	+ }
	+
	+ public function getColor() {
	+ return idx($this->spec, 'color');
	+ }
	+
	+ public function getName() {
	+ return idx($this->spec, 'name', pht('Unknown ("%s")', $this->key));
	+ }
	+
	public static function getStatusNameMap() {
	$map = self::getMap();
	return ipull($map, 'name', 'legacy');
	}

	public static function getStatusName($code) {
	return idx(self::getStatusNameMap(), $code, pht('Unknown'));
	}

	public static function getOpenStatusConstants() {
	$constants = array();
	foreach (self::getMap() as $map) {
	if (!$map['closed']) {
	$constants[] = $map['legacy'];
	}
	}
	return $constants;
	}

	public static function getStatusColor($code) {
	$map = self::getMap();
	$map = ipull($map, 'color', 'legacy');
	return idx($map, $code);
	}

	public static function getStatusIcon($code) {
	$map = self::getMap();
	$map = ipull($map, 'icon', 'legacy');
	return idx($map, $code);
	}

	private static function getMap() {
	return array(
	self::MODERN_NONE => array(
	'name' => pht('No Audits'),
	'legacy' => self::NONE,
	'icon' => 'fa-check',
	'color' => 'bluegrey',
	'closed' => true,
	),
	self::MODERN_NEEDS_AUDIT => array(
	'name' => pht('Audit Required'),
	'legacy' => self::NEEDS_AUDIT,
	'icon' => 'fa-exclamation-circle',
	'color' => 'orange',
	'closed' => false,
	),
	self::MODERN_CONCERN_RAISED => array(
	'name' => pht('Concern Raised'),
	'legacy' => self::CONCERN_RAISED,
	'icon' => 'fa-times-circle',
	'color' => 'red',
	'closed' => false,
	),
	self::MODERN_PARTIALLY_AUDITED => array(
	'name' => pht('Partially Audited'),
	'legacy' => self::PARTIALLY_AUDITED,
	'icon' => 'fa-check-circle-o',
	'color' => 'yellow',
	'closed' => false,
	),
	self::MODERN_AUDITED => array(
	'name' => pht('Audited'),
	'legacy' => self::FULLY_AUDITED,
	'icon' => 'fa-check-circle',
	'color' => 'green',
	'closed' => true,
	),
	self::MODERN_NEEDS_VERIFICATION => array(
	'name' => pht('Needs Verification'),
	'legacy' => self::NEEDS_VERIFICATION,
	'icon' => 'fa-refresh',
	'color' => 'indigo',
	'closed' => false,
	),
	);
	}
	}
	diff --git a/src/applications/audit/management/PhabricatorAuditSynchronizeManagementWorkflow.php b/src/applications/audit/management/PhabricatorAuditSynchronizeManagementWorkflow.php
	index db6ce096c4..96d06e65c2 100644
	--- a/src/applications/audit/management/PhabricatorAuditSynchronizeManagementWorkflow.php
	+++ b/src/applications/audit/management/PhabricatorAuditSynchronizeManagementWorkflow.php
	@@ -1,60 +1,58 @@
	<?php

	final class PhabricatorAuditSynchronizeManagementWorkflow
	extends PhabricatorAuditManagementWorkflow {

	protected function didConstruct() {
	$this
	->setName('synchronize')
	->setExamples('synchronize ...')
	->setSynopsis(pht('Update audit status for commits.'))
	->setArguments(
	array_merge(
	$this->getCommitConstraintArguments(),
	array()));
	}

	public function execute(PhutilArgumentParser $args) {
	$viewer = $this->getViewer();
	$objects = $this->loadCommitsWithConstraints($args);

	foreach ($objects as $object) {
	$commits = $this->loadCommitsForConstraintObject($object);
	foreach ($commits as $commit) {
	$commit = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withPHIDs(array($commit->getPHID()))
	->needAuditRequests(true)
	->executeOne();
	if (!$commit) {
	continue;
	}

	- $old_status = $commit->getAuditStatus();
	+ $old_status = $commit->getAuditStatusObject();
	$commit->updateAuditStatus($commit->getAudits());
	- $new_status = $commit->getAuditStatus();
	+ $new_status = $commit->getAuditStatusObject();

	- if ($old_status == $new_status) {
	+ if ($old_status->getKey() == $new_status->getKey()) {
	echo tsprintf(
	"%s\n",
	pht(
	'No changes for "%s".',
	$commit->getDisplayName()));
	} else {
	echo tsprintf(
	"%s\n",
	pht(
	'Updating "%s": "%s" -> "%s".',
	$commit->getDisplayName(),
	- PhabricatorAuditCommitStatusConstants::getStatusName(
	- $old_status),
	- PhabricatorAuditCommitStatusConstants::getStatusName(
	- $new_status)));
	+ $old_status->getName(),
	+ $new_status->getName()));

	$commit->save();
	}
	}
	}
	}

	}
	diff --git a/src/applications/audit/view/PhabricatorAuditListView.php b/src/applications/audit/view/PhabricatorAuditListView.php
	index cb9fecac3a..fb56e7cd55 100644
	--- a/src/applications/audit/view/PhabricatorAuditListView.php
	+++ b/src/applications/audit/view/PhabricatorAuditListView.php
	@@ -1,182 +1,179 @@
	<?php

	final class PhabricatorAuditListView extends AphrontView {

	private $commits = array();
	private $header;
	private $showDrafts;
	private $noDataString;
	private $highlightedAudits;

	public function setNoDataString($no_data_string) {
	$this->noDataString = $no_data_string;
	return $this;
	}

	public function getNoDataString() {
	return $this->noDataString;
	}

	public function setHeader($header) {
	$this->header = $header;
	return $this;
	}

	public function getHeader() {
	return $this->header;
	}

	public function setShowDrafts($show_drafts) {
	$this->showDrafts = $show_drafts;
	return $this;
	}

	public function getShowDrafts() {
	return $this->showDrafts;
	}

	/**
	* These commits should have both commit data and audit requests attached.
	*/
	public function setCommits(array $commits) {
	assert_instances_of($commits, 'PhabricatorRepositoryCommit');
	$this->commits = mpull($commits, null, 'getPHID');
	return $this;
	}

	public function getCommits() {
	return $this->commits;
	}

	private function getCommitDescription($phid) {
	if ($this->commits === null) {
	return pht('(Unknown Commit)');
	}

	$commit = idx($this->commits, $phid);
	if (!$commit) {
	return pht('(Unknown Commit)');
	}

	$summary = $commit->getCommitData()->getSummary();
	if (strlen($summary)) {
	return $summary;
	}

	// No summary, so either this is still importing or just has an empty
	// commit message.

	if (!$commit->isImported()) {
	return pht('(Importing Commit...)');
	} else {
	return pht('(Untitled Commit)');
	}
	}

	public function render() {
	$list = $this->buildList();
	$list->setFlush(true);
	return $list->render();
	}

	public function buildList() {
	$viewer = $this->getViewer();
	$rowc = array();

	$phids = array();
	foreach ($this->getCommits() as $commit) {
	$phids[] = $commit->getPHID();

	foreach ($commit->getAudits() as $audit) {
	$phids[] = $audit->getAuditorPHID();
	}

	$author_phid = $commit->getAuthorPHID();
	if ($author_phid) {
	$phids[] = $author_phid;
	}
	}

	$handles = $viewer->loadHandles($phids);

	$show_drafts = $this->getShowDrafts();

	$draft_icon = id(new PHUIIconView())
	->setIcon('fa-comment yellow')
	->addSigil('has-tooltip')
	->setMetadata(
	array(
	'tip' => pht('Unsubmitted Comments'),
	));

	$list = new PHUIObjectItemListView();
	foreach ($this->commits as $commit) {
	$commit_phid = $commit->getPHID();
	$commit_handle = $handles[$commit_phid];
	$committed = null;

	$commit_name = $commit_handle->getName();
	$commit_link = $commit_handle->getURI();
	$commit_desc = $this->getCommitDescription($commit_phid);
	$committed = phabricator_datetime($commit->getEpoch(), $viewer);

	- $status = $commit->getAuditStatus();
	-
	- $status_text =
	- PhabricatorAuditCommitStatusConstants::getStatusName($status);
	- $status_color =
	- PhabricatorAuditCommitStatusConstants::getStatusColor($status);
	- $status_icon =
	- PhabricatorAuditCommitStatusConstants::getStatusIcon($status);
	+ $status = $commit->getAuditStatusObject();
	+
	+ $status_text = $status->getName();
	+ $status_color = $status->getColor();
	+ $status_icon = $status->getIcon();

	$author_phid = $commit->getAuthorPHID();
	if ($author_phid) {
	$author_name = $handles[$author_phid]->renderLink();
	} else {
	$author_name = $commit->getCommitData()->getAuthorName();
	}

	$item = id(new PHUIObjectItemView())
	->setObjectName($commit_name)
	->setHeader($commit_desc)
	->setHref($commit_link)
	->setDisabled($commit->isUnreachable())
	->addByline(pht('Author: %s', $author_name))
	->addIcon('none', $committed);

	if ($show_drafts) {
	if ($commit->getHasDraft($viewer)) {
	$item->addAttribute($draft_icon);
	}
	}

	$audits = $commit->getAudits();
	$auditor_phids = mpull($audits, 'getAuditorPHID');
	if ($auditor_phids) {
	$auditor_list = $handles->newSublist($auditor_phids)
	->renderList()
	->setAsInline(true);
	} else {
	$auditor_list = phutil_tag('em', array(), pht('None'));
	}
	$item->addAttribute(pht('Auditors: %s', $auditor_list));

	if ($status_color) {
	$item->setStatusIcon($status_icon.' '.$status_color, $status_text);
	}

	$list->addItem($item);
	}

	if ($this->noDataString) {
	$list->setNoDataString($this->noDataString);
	}

	if ($this->header) {
	$list->setHeader($this->header);
	}

	return $list;
	}

	}
	diff --git a/src/applications/diffusion/view/DiffusionHistoryTableView.php b/src/applications/diffusion/view/DiffusionHistoryTableView.php
	index 3885bbf47c..cfd7019679 100644
	--- a/src/applications/diffusion/view/DiffusionHistoryTableView.php
	+++ b/src/applications/diffusion/view/DiffusionHistoryTableView.php
	@@ -1,196 +1,196 @@
	<?php

	final class DiffusionHistoryTableView extends DiffusionHistoryView {

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

	$viewer = $this->getUser();

	$buildables = $this->loadBuildables(
	mpull($this->getHistory(), 'getCommit'));
	$has_any_build = false;

	$show_revisions = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorDifferentialApplication',
	$viewer);

	$handles = $viewer->loadHandles($this->getRequiredHandlePHIDs());

	$graph = null;
	if ($this->getParents()) {
	$parents = $this->getParents();

	// If we're filtering parents, remove relationships which point to
	// commits that are not part of the visible graph. Otherwise, we get
	// a big tree of nonsense when viewing release branches like "stable"
	// versus "master".
	if ($this->getFilterParents()) {
	foreach ($parents as $key => $nodes) {
	foreach ($nodes as $nkey => $node) {
	if (empty($parents[$node])) {
	unset($parents[$key][$nkey]);
	}
	}
	}
	}

	$graph = id(new PHUIDiffGraphView())
	->setIsHead($this->getIsHead())
	->setIsTail($this->getIsTail())
	->renderGraph($parents);
	}

	$show_builds = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorHarbormasterApplication',
	$this->getUser());

	$rows = array();
	$ii = 0;
	foreach ($this->getHistory() as $history) {
	$epoch = $history->getEpoch();

	if ($epoch) {
	$committed = $viewer->formatShortDateTime($epoch);
	} else {
	$committed = null;
	}

	$data = $history->getCommitData();
	$author_phid = $committer = $committer_phid = null;
	if ($data) {
	$author_phid = $data->getCommitDetail('authorPHID');
	$committer_phid = $data->getCommitDetail('committerPHID');
	$committer = $data->getCommitDetail('committer');
	}

	if ($author_phid && isset($handles[$author_phid])) {
	$author = $handles[$author_phid]->renderLink();
	} else {
	$author = self::renderName($history->getAuthorName());
	}

	$different_committer = false;
	if ($committer_phid) {
	$different_committer = ($committer_phid != $author_phid);
	} else if ($committer != '') {
	$different_committer = ($committer != $history->getAuthorName());
	}
	if ($different_committer) {
	if ($committer_phid && isset($handles[$committer_phid])) {
	$committer = $handles[$committer_phid]->renderLink();
	} else {
	$committer = self::renderName($committer);
	}
	$author = hsprintf('%s/%s', $author, $committer);
	}

	// We can show details once the message and change have been imported.
	$partial_import = PhabricatorRepositoryCommit::IMPORTED_MESSAGE \|
	PhabricatorRepositoryCommit::IMPORTED_CHANGE;

	$commit = $history->getCommit();
	if ($commit && $commit->isPartiallyImported($partial_import) && $data) {
	$summary = AphrontTableView::renderSingleDisplayLine(
	$history->getSummary());
	} else {
	$summary = phutil_tag('em', array(), pht("Importing\xE2\x80\xA6"));
	}

	$build = null;
	if ($show_builds) {
	$buildable = idx($buildables, $commit->getPHID());
	if ($buildable !== null) {
	$build = $this->renderBuildable($buildable);
	$has_any_build = true;
	}
	}

	$browse = $this->linkBrowse(
	$history->getPath(),
	array(
	'commit' => $history->getCommitIdentifier(),
	'branch' => $drequest->getBranch(),
	'type' => $history->getFileType(),
	));

	- $status = $commit->getAuditStatus();
	- $icon = PhabricatorAuditCommitStatusConstants::getStatusIcon($status);
	- $color = PhabricatorAuditCommitStatusConstants::getStatusColor($status);
	- $name = PhabricatorAuditCommitStatusConstants::getStatusName($status);
	+ $status = $commit->getAuditStatusObject();
	+ $icon = $status->getIcon();
	+ $color = $status->getColor();
	+ $name = $status->getName();

	$audit_view = id(new PHUIIconView())
	->setIcon($icon, $color)
	->addSigil('has-tooltip')
	->setMetadata(
	array(
	'tip' => $name,
	));

	$rows[] = array(
	$graph ? $graph[$ii++] : null,
	$browse,
	self::linkCommit(
	$drequest->getRepository(),
	$history->getCommitIdentifier()),
	$build,
	$audit_view,
	($commit ?
	self::linkRevision(idx($this->getRevisions(), $commit->getPHID())) :
	null),
	$author,
	$summary,
	$committed,
	);
	}

	$view = new AphrontTableView($rows);
	$view->setHeaders(
	array(
	null,
	null,
	pht('Commit'),
	null,
	null,
	null,
	pht('Author'),
	pht('Details'),
	pht('Committed'),
	));
	$view->setColumnClasses(
	array(
	'threads',
	'nudgeright',
	'',
	'icon',
	'icon',
	'',
	'',
	'wide',
	'right',
	));
	$view->setColumnVisibility(
	array(
	$graph ? true : false,
	true,
	true,
	$has_any_build,
	true,
	$show_revisions,
	));
	$view->setDeviceVisibility(
	array(
	$graph ? true : false,
	true,
	true,
	true,
	true,
	true,
	false,
	true,
	false,
	));
	return $view->render();
	}

	}
	diff --git a/src/applications/repository/phid/PhabricatorRepositoryCommitPHIDType.php b/src/applications/repository/phid/PhabricatorRepositoryCommitPHIDType.php
	index b5abd40032..c37bdc04f9 100644
	--- a/src/applications/repository/phid/PhabricatorRepositoryCommitPHIDType.php
	+++ b/src/applications/repository/phid/PhabricatorRepositoryCommitPHIDType.php
	@@ -1,127 +1,127 @@
	<?php

	final class PhabricatorRepositoryCommitPHIDType extends PhabricatorPHIDType {

	const TYPECONST = 'CMIT';

	public function getTypeName() {
	return pht('Diffusion Commit');
	}

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

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

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

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

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

	$unreachable = array();
	foreach ($handles as $phid => $handle) {
	$commit = $objects[$phid];
	if ($commit->isUnreachable()) {
	$unreachable[$phid] = $commit;
	}
	}

	if ($unreachable) {
	$query = id(new DiffusionCommitHintQuery())
	->setViewer($query->getViewer())
	->withCommits($unreachable);

	$query->execute();

	$hints = $query->getCommitMap();
	} else {
	$hints = array();
	}

	foreach ($handles as $phid => $handle) {
	$commit = $objects[$phid];
	$repository = $commit->getRepository();
	$commit_identifier = $commit->getCommitIdentifier();

	$name = $repository->formatCommitName($commit_identifier);

	if ($commit->isUnreachable()) {
	$handle->setStatus(PhabricatorObjectHandle::STATUS_CLOSED);

	// If we have a hint about this commit being rewritten, add the
	// rewrite target to the handle name. This reduces the chance users
	// will be caught offguard by the rewrite.
	$hint = idx($hints, $phid);
	if ($hint && $hint->isRewritten()) {
	$new_name = $hint->getNewCommitIdentifier();
	$new_name = $repository->formatCommitName($new_name);
	$name = pht("%s \xE2\x99\xBB %s", $name, $new_name);
	}
	}

	$summary = $commit->getSummary();
	if (strlen($summary)) {
	$full_name = $name.': '.$summary;
	} else {
	$full_name = $name;
	}

	$handle->setName($name);
	$handle->setFullName($full_name);
	$handle->setURI($commit->getURI());
	$handle->setTimestamp($commit->getEpoch());

	- $status = $commit->getAuditStatus();
	- $icon = PhabricatorAuditCommitStatusConstants::getStatusIcon($status);
	- $color = PhabricatorAuditCommitStatusConstants::getStatusColor($status);
	- $name = PhabricatorAuditCommitStatusConstants::getStatusName($status);
	+ $status = $commit->getAuditStatusObject();
	+ $icon = $status->getIcon();
	+ $color = $status->getColor();
	+ $name = $status->getName();

	$handle
	->setStateIcon($icon)
	->setStateColor($color)
	->setStateName($name);
	}
	}

	public static function getCommitObjectNamePattern() {
	$min_unqualified = PhabricatorRepository::MINIMUM_UNQUALIFIED_HASH;
	$min_qualified = PhabricatorRepository::MINIMUM_QUALIFIED_HASH;

	return
	'(?:r[A-Z]+:?\|R[0-9]+:)[1-9]\d*'.
	'\|'.
	'(?:r[A-Z]+:?\|R[0-9]+:)[a-f0-9]{'.$min_qualified.',40}'.
	'\|'.
	'[a-f0-9]{'.$min_unqualified.',40}';
	}

	public function canLoadNamedObject($name) {
	$pattern = self::getCommitObjectNamePattern();
	return preg_match('(^'.$pattern.'$)', $name);
	}

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

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

	$query->execute();

	return $query->getIdentifierMap();
	}

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	index f36869686f..447db08e6c 100644
	--- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	+++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	@@ -1,861 +1,866 @@
	<?php

	final class PhabricatorRepositoryCommit
	extends PhabricatorRepositoryDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorFlaggableInterface,
	PhabricatorProjectInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorSubscribableInterface,
	PhabricatorMentionableInterface,
	HarbormasterBuildableInterface,
	HarbormasterCircleCIBuildableInterface,
	HarbormasterBuildkiteBuildableInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorFulltextInterface,
	PhabricatorFerretInterface,
	PhabricatorConduitResultInterface,
	PhabricatorDraftInterface {

	protected $repositoryID;
	protected $phid;
	protected $authorIdentityPHID;
	protected $committerIdentityPHID;
	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;
	const IMPORTED_UNREACHABLE = 2048;

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

	private $drafts = array();
	private $auditAuthorityPHIDs = array();

	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 isUnreachable() {
	return $this->isPartiallyImported(self::IMPORTED_UNREACHABLE);
	}

	public function writeImportStatusFlag($flag) {
	return $this->adjustImportStatusFlag($flag, true);
	}

	public function clearImportStatusFlag($flag) {
	return $this->adjustImportStatusFlag($flag, false);
	}

	private function adjustImportStatusFlag($flag, $set) {
	$conn_w = $this->establishConnection('w');
	$table_name = $this->getTableName();
	$id = $this->getID();

	if ($set) {
	queryfx(
	$conn_w,
	'UPDATE %T SET importStatus = (importStatus \| %d) WHERE id = %d',
	$table_name,
	$flag,
	$id);

	$this->setImportStatus($this->getImportStatus() \| $flag);
	} else {
	queryfx(
	$conn_w,
	'UPDATE %T SET importStatus = (importStatus & ~%d) WHERE id = %d',
	$table_name,
	$flag,
	$id);

	$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?',
	'authorIdentityPHID' => 'phid?',
	'committerIdentityPHID' => 'phid?',
	'auditStatus' => 'uint32',
	'summary' => 'text255',
	'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 hasAttachedAudits() {
	return ($this->audits !== self::ATTACHABLE);
	}

	public function attachIdentities(
	PhabricatorRepositoryIdentity $author = null,
	PhabricatorRepositoryIdentity $committer = null) {

	$this->authorIdentity = $author;
	$this->committerIdentity = $committer;

	return $this;
	}

	public function getAuthorIdentity() {
	return $this->assertAttached($this->authorIdentity);
	}

	public function getCommitterIdentity() {
	return $this->assertAttached($this->committerIdentity);
	}

	public function loadAndAttachAuditAuthority(
	PhabricatorUser $viewer,
	$actor_phid = null) {

	if ($actor_phid === null) {
	$actor_phid = $viewer->getPHID();
	}

	// TODO: This method is a little weird and sketchy, but worlds better than
	// what came before it. Eventually, this should probably live in a Query
	// class.

	// Figure out which requests the actor has authority over: these are user
	// requests where they are the auditor, and packages and projects they are
	// a member of.

	if (!$actor_phid) {
	$attach_key = $viewer->getCacheFragment();
	$phids = array();
	} else {
	$attach_key = $actor_phid;
	// At least currently, when modifying your own commits, you act only on
	// behalf of yourself, not your packages/projects -- the idea being that
	// you can't accept your own commits. This may change or depend on
	// config.
	$actor_is_author = ($actor_phid == $this->getAuthorPHID());
	if ($actor_is_author) {
	$phids = array($actor_phid);
	} else {
	$phids = array();
	$phids[$actor_phid] = true;

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

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withMemberPHIDs(array($actor_phid))
	->execute();
	foreach ($projects as $project) {
	$phids[$project->getPHID()] = true;
	}

	$phids = array_keys($phids);
	}
	}

	$this->auditAuthorityPHIDs[$attach_key] = array_fuse($phids);

	return $this;
	}

	public function hasAuditAuthority(
	PhabricatorUser $viewer,
	PhabricatorRepositoryAuditRequest $audit,
	$actor_phid = null) {

	if ($actor_phid === null) {
	$actor_phid = $viewer->getPHID();
	}

	if (!$actor_phid) {
	$attach_key = $viewer->getCacheFragment();
	} else {
	$attach_key = $actor_phid;
	}

	$map = $this->assertAttachedKey($this->auditAuthorityPHIDs, $attach_key);

	if (!$actor_phid) {
	return false;
	}

	return isset($map[$audit->getAuditorPHID()]);
	}

	public function writeOwnersEdges(array $package_phids) {
	$src_phid = $this->getPHID();
	$edge_type = DiffusionCommitHasPackageEdgeType::EDGECONST;

	$editor = new PhabricatorEdgeEditor();

	$dst_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$src_phid,
	$edge_type);

	foreach ($dst_phids as $dst_phid) {
	$editor->removeEdge($src_phid, $edge_type, $dst_phid);
	}

	foreach ($package_phids as $package_phid) {
	$editor->addEdge($src_phid, $edge_type, $package_phid);
	}

	$editor->save();

	return $this;
	}

	public function getAuditorPHIDsForEdit() {
	$audits = $this->getAudits();
	return mpull($audits, 'getAuditorPHID');
	}

	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() {
	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:
	case PhabricatorAuditStatusConstants::AUDIT_REQUESTED:
	$any_need = true;
	break;
	case PhabricatorAuditStatusConstants::ACCEPTED:
	$any_accept = true;
	break;
	case PhabricatorAuditStatusConstants::CONCERNED:
	$any_concern = true;
	break;
	}
	}

	$current_status = $this->getAuditStatus();
	$status_verify = PhabricatorAuditCommitStatusConstants::NEEDS_VERIFICATION;

	if ($any_concern) {
	if ($current_status == $status_verify) {
	// If the change is in "Needs Verification", we keep it there as
	// long as any auditors still have concerns.
	$status = $status_verify;
	} else {
	$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();
	if ($callsign !== null) {
	return "r{$callsign}{$identifier}";
	} else {
	$id = $repository->getID();
	return "R{$id}:{$identifier}";
	}
	}

	public function getDisplayName() {
	$repository = $this->getRepository();
	$identifier = $this->getCommitIdentifier();
	return $repository->formatCommitName($identifier);
	}

	/**
	* Return a local display name for use in the context of the containing
	* repository.
	*
	* In Git and Mercurial, this returns only a short hash, like "abcdef012345".
	* See @{method:getDisplayName} for a short name that always includes
	* repository context.
	*
	* @return string Short human-readable name for use inside a repository.
	*/
	public function getLocalName() {
	$repository = $this->getRepository();
	$identifier = $this->getCommitIdentifier();
	return $repository->formatCommitName($identifier, $local = true);
	}

	/**
	* Make a strong effort to find a way to render this commit's committer.
	* This currently attempts to use @{PhabricatorRepositoryIdentity}, and
	* falls back to examining the commit detail information. After we force
	* the migration to using identities, update this method to remove the
	* fallback. See T12164 for details.
	*/
	public function renderAnyCommitter(PhabricatorUser $viewer, $handles) {
	$committer = $this->renderCommitter($viewer, $handles);
	if ($committer) {
	return $committer;
	}

	return $this->renderAuthor($viewer, $handles);
	}

	public function renderCommitter(PhabricatorUser $viewer, $handles) {
	$committer_phid = $this->getCommitterDisplayPHID();
	if ($committer_phid) {
	return $handles[$committer_phid]->renderLink();
	}

	$data = $this->getCommitData();
	$committer_name = $data->getCommitDetail('committer');
	if (strlen($committer_name)) {
	return DiffusionView::renderName($committer_name);
	}

	return null;
	}

	public function renderAuthor(PhabricatorUser $viewer, $handles) {
	$author_phid = $this->getAuthorDisplayPHID();
	if ($author_phid) {
	return $handles[$author_phid]->renderLink();
	}

	$data = $this->getCommitData();
	$author_name = $data->getAuthorName();
	if (strlen($author_name)) {
	return DiffusionView::renderName($author_name);
	}

	return null;
	}

	public function loadIdentities(PhabricatorUser $viewer) {
	if ($this->authorIdentity !== self::ATTACHABLE) {
	return $this;
	}

	$commit = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIDs(array($this->getID()))
	->needIdentities(true)
	->executeOne();

	$author_identity = $commit->getAuthorIdentity();
	$committer_identity = $commit->getCommitterIdentity();

	return $this->attachIdentities($author_identity, $committer_identity);
	}

	public function hasCommitterIdentity() {
	return ($this->getCommitterIdentity() !== null);
	}

	public function hasAuthorIdentity() {
	return ($this->getAuthorIdentity() !== null);
	}

	public function getCommitterDisplayPHID() {
	if ($this->hasCommitterIdentity()) {
	return $this->getCommitterIdentity()->getIdentityDisplayPHID();
	}

	$data = $this->getCommitData();
	return $data->getCommitDetail('committerPHID');
	}

	public function getAuthorDisplayPHID() {
	if ($this->hasAuthorIdentity()) {
	return $this->getAuthorIdentity()->getIdentityDisplayPHID();
	}

	$data = $this->getCommitData();
	return $data->getCommitDetail('authorPHID');
	}

	+ public function getAuditStatusObject() {
	+ $status = $this->getAuditStatus();
	+ return PhabricatorAuditCommitStatusConstants::newForLegacyStatus($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:
	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 getHarbormasterBuildableDisplayPHID() {
	return $this->getHarbormasterBuildablePHID();
	}

	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.'),
	);
	}

	public function newBuildableEngine() {
	return new DiffusionBuildableEngine();
	}


	/* -( HarbormasterCircleCIBuildableInterface )----------------------------- */


	public function getCircleCIGitHubRepositoryURI() {
	$repository = $this->getRepository();

	$commit_phid = $this->getPHID();
	$repository_phid = $repository->getPHID();

	if ($repository->isHosted()) {
	throw new Exception(
	pht(
	'This commit ("%s") is associated with a hosted repository '.
	'("%s"). Repositories must be imported from GitHub to be built '.
	'with CircleCI.',
	$commit_phid,
	$repository_phid));
	}

	$remote_uri = $repository->getRemoteURI();
	$path = HarbormasterCircleCIBuildStepImplementation::getGitHubPath(
	$remote_uri);
	if (!$path) {
	throw new Exception(
	pht(
	'This commit ("%s") is associated with a repository ("%s") that '.
	'with a remote URI ("%s") that does not appear to be hosted on '.
	'GitHub. Repositories must be hosted on GitHub to be built with '.
	'CircleCI.',
	$commit_phid,
	$repository_phid,
	$remote_uri));
	}

	return $remote_uri;
	}

	public function getCircleCIBuildIdentifierType() {
	return 'revision';
	}

	public function getCircleCIBuildIdentifier() {
	return $this->getCommitIdentifier();
	}


	/* -( HarbormasterBuildkiteBuildableInterface )---------------------------- */


	public function getBuildkiteBranch() {
	$viewer = PhabricatorUser::getOmnipotentUser();
	$repository = $this->getRepository();

	$branches = DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	DiffusionRequest::newFromDictionary(
	array(
	'repository' => $repository,
	'user' => $viewer,
	)),
	'diffusion.branchquery',
	array(
	'contains' => $this->getCommitIdentifier(),
	'repository' => $repository->getPHID(),
	));

	if (!$branches) {
	throw new Exception(
	pht(
	'Commit "%s" is not an ancestor of any branch head, so it can not '.
	'be built with Buildkite.',
	$this->getCommitIdentifier()));
	}

	$branch = head($branches);

	return 'refs/heads/'.$branch['shortName'];
	}

	public function getBuildkiteCommit() {
	return $this->getCommitIdentifier();
	}


	/* -( 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. (It should not
	// include resigned auditors.)

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


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


	/* -( PhabricatorFerretInterface )----------------------------------------- */


	public function newFerretEngine() {
	return new DiffusionCommitFerretEngine();
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */

	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('identifier')
	->setType('string')
	->setDescription(pht('The commit identifier.')),
	);
	}

	public function getFieldValuesForConduit() {

	// NOTE: This data should be similar to the information returned about
	// commmits by "differential.diff.search" with the "commits" attachment.

	return array(
	'identifier' => $this->getCommitIdentifier(),
	);
	}

	public function getConduitSearchAttachments() {
	return array();
	}


	/* -( PhabricatorDraftInterface )------------------------------------------ */

	public function newDraftEngine() {
	return new DiffusionCommitDraftEngine();
	}

	public function getHasDraft(PhabricatorUser $viewer) {
	return $this->assertAttachedKey($this->drafts, $viewer->getCacheFragment());
	}

	public function attachHasDraft(PhabricatorUser $viewer, $has_draft) {
	$this->drafts[$viewer->getCacheFragment()] = $has_draft;
	return $this;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 19:17 (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1127883
Default Alt Text: (46 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions