No OneTemporary
Actions

Size

36 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/releeph/conduit/ConduitAPI_releeph_queryrequests_Method.php b/src/applications/releeph/conduit/ConduitAPI_releeph_queryrequests_Method.php
	index 9683215576..44767e6b6b 100644
	--- a/src/applications/releeph/conduit/ConduitAPI_releeph_queryrequests_Method.php
	+++ b/src/applications/releeph/conduit/ConduitAPI_releeph_queryrequests_Method.php
	@@ -1,71 +1,77 @@
	<?php

	final class ConduitAPI_releeph_queryrequests_Method
	extends ConduitAPI_releeph_Method {

	public function getMethodDescription() {
	return
	"Return information about all Releeph requests linked to the given ids.";
	}

	public function defineParamTypes() {
	return array(
	'revisionPHIDs' => 'optional list<phid>',
	'requestedCommitPHIDs' => 'optional list<phid>'
	);
	}

	public function defineReturnType() {
	return 'dict<string, wild>';
	}

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

	protected function execute(ConduitAPIRequest $conduit_request) {
	$revision_phids = $conduit_request->getValue('revisionPHIDs');
	$requested_commit_phids =
	$conduit_request->getValue('requestedCommitPHIDs');
	$result = array();

	if (!$revision_phids && !$requested_commit_phids) {
	return $result;
	}

	$query = new ReleephRequestQuery();
	$query->setViewer($conduit_request->getUser());

	if ($revision_phids) {
	- $query->withRevisionPHIDs($revision_phids);
	+ $query->withRequestedObjectPHIDs($revision_phids);
	} else if ($requested_commit_phids) {
	$query->withRequestedCommitPHIDs($requested_commit_phids);
	}

	$releephRequests = $query->execute();

	foreach ($releephRequests as $releephRequest) {
	$branch = $releephRequest->getBranch();

	$request_commit_phid = $releephRequest->getRequestCommitPHID();
	- $revisionPHID =
	- $query->getRevisionPHID($request_commit_phid);
	+
	+ $object = $releephRequest->getRequestedObject();
	+ if ($object instanceof DifferentialRevision) {
	+ $object_phid = $object->getPHID();
	+ } else {
	+ $object_phid = null;
	+ }
	+
	$status = $releephRequest->getStatus();
	$statusName = ReleephRequestStatus::getStatusDescriptionFor($status);
	$url = PhabricatorEnv::getProductionURI('/RQ'.$releephRequest->getID());

	$result[] = array(
	'branchBasename' => $branch->getBasename(),
	'branchSymbolic' => $branch->getSymbolicName(),
	'requestID' => $releephRequest->getID(),
	- 'revisionPHID' => $revisionPHID,
	+ 'revisionPHID' => $object_phid,
	'status' => $status,
	'statusName' => $statusName,
	'url' => $url,
	);
	}

	return $result;
	}

	}
	diff --git a/src/applications/releeph/conduit/work/ConduitAPI_releephwork_nextrequest_Method.php b/src/applications/releeph/conduit/work/ConduitAPI_releephwork_nextrequest_Method.php
	index 329b3f0451..f39a02568d 100644
	--- a/src/applications/releeph/conduit/work/ConduitAPI_releephwork_nextrequest_Method.php
	+++ b/src/applications/releeph/conduit/work/ConduitAPI_releephwork_nextrequest_Method.php
	@@ -1,216 +1,223 @@
	<?php

	final class ConduitAPI_releephwork_nextrequest_Method
	extends ConduitAPI_releeph_Method {

	private $project;
	private $branch;

	public function getMethodStatus() {
	return self::METHOD_STATUS_UNSTABLE;
	}

	public function getMethodDescription() {
	return
	"Return info required to cut a branch, ".
	"and pick and revert ReleephRequests";
	}

	public function defineParamTypes() {
	return array(
	'branchPHID' => 'required phid',
	'seen' => 'required map<string, bool>',
	);
	}

	public function defineReturnType() {
	return '';
	}

	public function defineErrorTypes() {
	return array(
	'ERR-NOT-PUSHER' =>
	'You are not listed as a pusher for thie Releeph project!',
	);
	}

	protected function execute(ConduitAPIRequest $request) {
	$viewer = $request->getUser();
	$seen = $request->getValue('seen');

	$branch = id(new ReleephBranchQuery())
	->setViewer($viewer)
	->withPHIDs(array($request->getValue('branchPHID')))
	->executeOne();

	$project = $branch->getProduct();

	$needs_pick = array();
	$needs_revert = array();

	// Load every request ever made for this branch...?!!!
	$releeph_requests = id(new ReleephRequestQuery())
	->setViewer($viewer)
	->withBranchIDs(array($branch->getID()))
	->execute();

	foreach ($releeph_requests as $candidate) {
	$phid = $candidate->getPHID();
	if (idx($seen, $phid)) {
	continue;
	}

	$should = $candidate->shouldBeInBranch();
	$in = $candidate->getInBranch();
	if ($should && !$in) {
	$needs_pick[] = $candidate;
	}
	if (!$should && $in) {
	$needs_revert[] = $candidate;
	}
	}

	/**
	* Sort both needs_pick and needs_revert in ascending commit order, as
	* discovered by Phabricator (using the `id` column to perform that
	* ordering).
	*
	* This is easy for $needs_pick as the ordinal is stored. It is hard for
	* reverts, as we have to look that information up.
	*/
	$needs_pick = $this->sortPicks($needs_pick);
	$needs_revert = $this->sortReverts($needs_revert);

	/**
	* Do reverts first in reverse order, then the picks in original-commit
	* order.
	*
	* This seems like the correct thing to do, but there may be a better
	* algorithm for the releephwork.nextrequest Conduit call that orders
	* things better.
	*
	* We could also button-mash our way through everything that failed (at the
	* end of the run) to try failed things again.
	*/
	$releeph_request = null;
	$action = null;
	if ($needs_revert) {
	$releeph_request = last($needs_revert);
	$action = 'revert';
	$commit_id = $releeph_request->getCommitIdentifier();
	$commit_phid = $releeph_request->getCommitPHID();
	} elseif ($needs_pick) {
	$releeph_request = head($needs_pick);
	$action = 'pick';
	$commit = $releeph_request->loadPhabricatorRepositoryCommit();
	$commit_id = $commit->getCommitIdentifier();
	$commit_phid = $commit->getPHID();
	} else {
	// Return early if there's nothing to do!
	return array();
	}

	// Build the response
	$phids = array();
	$phids[] = $commit_phid;

	$diff_phid = null;
	$diff_rev_id = null;
	- $diff_rev = $releeph_request->loadDifferentialRevision();
	+
	+ $requested_object = $releeph_request->getRequestedObject();
	+ if ($requested_object instanceof DifferentialRevision) {
	+ $diff_rev = $requested_object;
	+ } else {
	+ $diff_rev = null;
	+ }
	+
	if ($diff_rev) {
	$diff_phid = $diff_rev->getPHID();
	$phids[] = $diff_phid;
	$diff_rev_id = $diff_rev->getID();
	}

	$phids[] = $releeph_request->getPHID();
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($request->getUser())
	->withPHIDs($phids)
	->execute();

	$diff_name = null;
	if ($diff_rev) {
	$diff_name = $handles[$diff_phid]->getName();
	}

	$new_author_phid = null;
	if ($diff_rev) {
	$new_author_phid = $diff_rev->getAuthorPHID();
	} else {
	$pr_commit = $releeph_request->loadPhabricatorRepositoryCommit();
	if ($pr_commit) {
	$new_author_phid = $pr_commit->getAuthorPHID();
	}
	}

	return array(
	'requestID' => $releeph_request->getID(),
	'requestPHID' => $releeph_request->getPHID(),
	'requestName' => $handles[$releeph_request->getPHID()]->getName(),
	'requestorPHID' => $releeph_request->getRequestUserPHID(),
	'action' => $action,
	'diffRevID' => $diff_rev_id,
	'diffName' => $diff_name,
	'commitIdentifier' => $commit_id,
	'commitPHID' => $commit_phid,
	'commitName' => $handles[$commit_phid]->getName(),
	'needsRevert' => mpull($needs_revert, 'getID'),
	'needsPick' => mpull($needs_pick, 'getID'),
	'newAuthorPHID' => $new_author_phid,
	);
	}

	private function sortPicks(array $releeph_requests) {
	$surrogate = array();
	foreach ($releeph_requests as $rq) {
	// TODO: it's likely that relying on the `id` column to provide
	// trunk-commit-order is thoroughly broken.
	$ordinal = (int) $rq->loadPhabricatorRepositoryCommit()->getID();
	$surrogate[$ordinal] = $rq;
	}
	ksort($surrogate);
	return $surrogate;
	}

	/**
	* Sort an array of ReleephRequests, that have been picked into a branch, in
	* the order in which they were picked to the branch.
	*/
	private function sortReverts(array $releeph_requests) {
	if (!$releeph_requests) {
	return array();
	}

	// ReleephRequests, keyed by <branch-commit-id>
	$releeph_requests = mpull($releeph_requests, null, 'getCommitIdentifier');

	$commits = id(new PhabricatorRepositoryCommit())
	->loadAllWhere(
	'commitIdentifier IN (%Ls)',
	mpull($releeph_requests, 'getCommitIdentifier'));

	// A map of <branch-commit-id> => <branch-commit-ordinal>
	$surrogate = mpull($commits, 'getID', 'getCommitIdentifier');

	$unparsed = array();
	$result = array();

	foreach ($releeph_requests as $commit_id => $releeph_request) {
	$ordinal = idx($surrogate, $commit_id);
	if ($ordinal) {
	$result[$ordinal] = $releeph_request;
	} else {
	$unparsed[] = $releeph_request;
	}
	}

	// Sort $result in ascending order
	ksort($result);

	// Unparsed commits we'll just have to guess, based on time
	$unparsed = msort($unparsed, 'getDateModified');

	return array_merge($result, $unparsed);
	}
	}
	diff --git a/src/applications/releeph/field/specification/ReleephDependsOnFieldSpecification.php b/src/applications/releeph/field/specification/ReleephDependsOnFieldSpecification.php
	index e951b4bf11..7048b5d3e7 100644
	--- a/src/applications/releeph/field/specification/ReleephDependsOnFieldSpecification.php
	+++ b/src/applications/releeph/field/specification/ReleephDependsOnFieldSpecification.php
	@@ -1,33 +1,33 @@
	<?php

	final class ReleephDependsOnFieldSpecification
	extends ReleephFieldSpecification {
	public function getFieldKey() {
	return 'dependsOn';
	}

	public function getName() {
	return pht('Depends On');
	}

	public function getRequiredHandlePHIDsForPropertyView() {
	return $this->getDependentRevisionPHIDs();
	}

	public function renderPropertyViewValue(array $handles) {
	return $this->renderHandleList($handles);
	}

	private function getDependentRevisionPHIDs() {
	- $revision = $this
	- ->getReleephRequest()
	- ->loadDifferentialRevision();
	- if (!$revision) {
	+ $requested_object = $this->getObject()->getRequestedObjectPHID();
	+ if (!($requested_object instanceof DifferentialRevision)) {
	return array();
	}

	+ $revision = $requested_object;
	+
	return PhabricatorEdgeQuery::loadDestinationPHIDs(
	$revision->getPHID(),
	PhabricatorEdgeConfig::TYPE_DREV_DEPENDS_ON_DREV);
	}
	}
	diff --git a/src/applications/releeph/field/specification/ReleephDiffChurnFieldSpecification.php b/src/applications/releeph/field/specification/ReleephDiffChurnFieldSpecification.php
	index 43d1b024c4..026392a1bc 100644
	--- a/src/applications/releeph/field/specification/ReleephDiffChurnFieldSpecification.php
	+++ b/src/applications/releeph/field/specification/ReleephDiffChurnFieldSpecification.php
	@@ -1,90 +1,89 @@
	<?php

	final class ReleephDiffChurnFieldSpecification
	extends ReleephFieldSpecification {

	const REJECTIONS_WEIGHT = 30;
	const COMMENTS_WEIGHT = 7;
	const UPDATES_WEIGHT = 10;
	const MAX_POINTS = 100;

	public function getFieldKey() {
	return 'churn';
	}

	public function getName() {
	return 'Churn';
	}

	public function renderPropertyViewValue(array $handles) {
	- $diff_rev = $this->getReleephRequest()->loadDifferentialRevision();
	- if (!$diff_rev) {
	+ $requested_object = $this->getObject()->getRequestedObject();
	+ if (!($requested_object instanceof DifferentialRevision)) {
	return null;
	}
	-
	- $diff_rev = $this->getReleephRequest()->loadDifferentialRevision();
	+ $diff_rev = $requested_object;

	$xactions = id(new DifferentialTransactionQuery())
	- ->setViewer(PhabricatorUser::getOmnipotentUser())
	+ ->setViewer($this->getViewer())
	->withObjectPHIDs(array($diff_rev->getPHID()))
	->execute();

	$rejections = 0;
	$comments = 0;
	$updates = 0;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	$comments++;
	break;
	case DifferentialTransaction::TYPE_UPDATE:
	$updates++;
	break;
	case DifferentialTransaction::TYPE_ACTION:
	switch ($xaction->getNewValue()) {
	case DifferentialAction::ACTION_REJECT:
	$rejections++;
	break;
	}
	break;
	}
	}

	$points =
	self::REJECTIONS_WEIGHT * $rejections +
	self::COMMENTS_WEIGHT * $comments +
	self::UPDATES_WEIGHT * $updates;

	if ($points === 0) {
	$points = 0.15 * self::MAX_POINTS;
	$blurb = 'Silent diff';
	} else {
	$parts = array();
	if ($rejections) {
	$parts[] = pht('%d rejection(s)', $rejections);
	}
	if ($comments) {
	$parts[] = pht('%d comment(s)', $comments);
	}
	if ($updates) {
	$parts[] = pht('%d update(s)', $updates);
	}

	if (count($parts) === 0) {
	$blurb = '';
	} else if (count($parts) === 1) {
	$blurb = head($parts);
	} else {
	$last = array_pop($parts);
	$blurb = implode(', ', $parts).' and '.$last;
	}
	}

	return id(new AphrontProgressBarView())
	->setValue($points)
	->setMax(self::MAX_POINTS)
	->setCaption($blurb)
	->render();
	}

	}
	diff --git a/src/applications/releeph/field/specification/ReleephDiffSizeFieldSpecification.php b/src/applications/releeph/field/specification/ReleephDiffSizeFieldSpecification.php
	index 9c269d3c81..b0e1e44bf9 100644
	--- a/src/applications/releeph/field/specification/ReleephDiffSizeFieldSpecification.php
	+++ b/src/applications/releeph/field/specification/ReleephDiffSizeFieldSpecification.php
	@@ -1,112 +1,113 @@
	<?php

	final class ReleephDiffSizeFieldSpecification
	extends ReleephFieldSpecification {

	const LINES_WEIGHT = 1;
	const PATHS_WEIGHT = 30;
	const MAX_POINTS = 1000;

	public function getFieldKey() {
	return 'commit:size';
	}

	public function getName() {
	return 'Size';
	}

	public function renderPropertyViewValue(array $handles) {
	- $diff_rev = $this->getReleephRequest()->loadDifferentialRevision();
	- if (!$diff_rev) {
	+ $requested_object = $this->getObject()->getRequestedObject();
	+ if (!($requested_object instanceof DifferentialRevision)) {
	return null;
	}
	+ $diff_rev = $requested_object;

	$diffs = $diff_rev->loadRelatives(
	new DifferentialDiff(),
	'revisionID',
	'getID',
	'creationMethod <> "commit"');

	$all_changesets = array();
	$most_recent_changesets = null;
	foreach ($diffs as $diff) {
	$changesets = $diff->loadRelatives(new DifferentialChangeset(), 'diffID');
	$all_changesets += $changesets;
	$most_recent_changesets = $changesets;
	}

	// The score is based on all changesets for all versions of this diff
	$all_changes = $this->countLinesAndPaths($all_changesets);
	$points =
	self::LINES_WEIGHT * $all_changes['code']['lines'] +
	self::PATHS_WEIGHT * count($all_changes['code']['paths']);

	// The blurb is just based on the most recent version of the diff
	$mr_changes = $this->countLinesAndPaths($most_recent_changesets);

	$test_tag = '';
	if ($mr_changes['tests']['paths']) {
	Javelin::initBehavior('phabricator-tooltips');
	require_celerity_resource('aphront-tooltip-css');

	$test_blurb =
	pht('%d line(s)', $mr_changes['tests']['lines']).' and '.
	pht('%d path(s)', count($mr_changes['tests']['paths'])).
	" contain changes to test code:\n";
	foreach ($mr_changes['tests']['paths'] as $mr_test_path) {
	$test_blurb .= pht("%s\n", $mr_test_path);
	}

	$test_tag = javelin_tag(
	'span',
	array(
	'sigil' => 'has-tooltip',
	'meta' => array(
	'tip' => $test_blurb,
	'align' => 'E',
	'size' => 'auto'),
	'style' => ''),
	' + tests');
	}

	$blurb = hsprintf("%s%s.",
	pht('%d line(s)', $mr_changes['code']['lines']).' and '.
	pht('%d path(s)', count($mr_changes['code']['paths'])).' over '.
	pht('%d diff(s)', count($diffs)),
	$test_tag);

	return id(new AphrontProgressBarView())
	->setValue($points)
	->setMax(self::MAX_POINTS)
	->setCaption($blurb)
	->render();
	}

	private function countLinesAndPaths(array $changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');
	$lines = 0;
	$paths_touched = array();
	$test_lines = 0;
	$test_paths_touched = array();

	foreach ($changesets as $ch) {
	if ($this->getReleephProject()->isTestFile($ch->getFilename())) {
	$test_lines += $ch->getAddLines() + $ch->getDelLines();
	$test_paths_touched[] = $ch->getFilename();
	} else {
	$lines += $ch->getAddLines() + $ch->getDelLines();
	$paths_touched[] = $ch->getFilename();
	}
	}
	return array(
	'code' => array(
	'lines' => $lines,
	'paths' => array_unique($paths_touched),
	),
	'tests' => array(
	'lines' => $test_lines,
	'paths' => array_unique($test_paths_touched),
	)
	);
	}
	}
	diff --git a/src/applications/releeph/field/specification/ReleephRevisionFieldSpecification.php b/src/applications/releeph/field/specification/ReleephRevisionFieldSpecification.php
	index a070ddd8a8..f9aa6fd2a1 100644
	--- a/src/applications/releeph/field/specification/ReleephRevisionFieldSpecification.php
	+++ b/src/applications/releeph/field/specification/ReleephRevisionFieldSpecification.php
	@@ -1,29 +1,29 @@
	<?php

	final class ReleephRevisionFieldSpecification
	extends ReleephFieldSpecification {

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

	public function getName() {
	return 'Revision';
	}

	public function getRequiredHandlePHIDsForPropertyView() {
	- $phids = array();
	-
	- $phid = $this->getReleephRequest()->loadRequestCommitDiffPHID();
	- if ($phid) {
	- $phids[] = $phid;
	+ $requested_object = $this->getObject()->getRequestedObjectPHID();
	+ if (!($requested_object instanceof DifferentialRevision)) {
	+ return array();
	}

	- return $phids;
	+ return array(
	+ $requested_object->getPHID(),
	+ );
	}

	public function renderPropertyViewValue(array $handles) {
	return $this->renderHandleList($handles);
	}

	}
	diff --git a/src/applications/releeph/query/ReleephRequestQuery.php b/src/applications/releeph/query/ReleephRequestQuery.php
	index 5108e6361d..5a0a0056d2 100644
	--- a/src/applications/releeph/query/ReleephRequestQuery.php
	+++ b/src/applications/releeph/query/ReleephRequestQuery.php
	@@ -1,257 +1,249 @@
	<?php

	final class ReleephRequestQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $requestedCommitPHIDs;
	- private $commitToRevMap;
	private $ids;
	private $phids;
	private $severities;
	private $requestorPHIDs;
	private $branchIDs;
	- private $revisionPHIDs;
	+ private $requestedObjectPHIDs;

	const STATUS_ALL = 'status-all';
	const STATUS_OPEN = 'status-open';
	const STATUS_REQUESTED = 'status-requested';
	const STATUS_NEEDS_PULL = 'status-needs-pull';
	const STATUS_REJECTED = 'status-rejected';
	const STATUS_ABANDONED = 'status-abandoned';
	const STATUS_PULLED = 'status-pulled';
	const STATUS_NEEDS_REVERT = 'status-needs-revert';
	const STATUS_REVERTED = 'status-reverted';

	private $status = self::STATUS_ALL;

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

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

	public function withBranchIDs(array $branch_ids) {
	$this->branchIDs = $branch_ids;
	return $this;
	}

	- public function getRevisionPHID($commit_phid) {
	- if ($this->commitToRevMap) {
	- return idx($this->commitToRevMap, $commit_phid, null);
	- }
	-
	- return null;
	- }
	-
	public function withStatus($status) {
	$this->status = $status;
	return $this;
	}

	public function withRequestedCommitPHIDs(array $requested_commit_phids) {
	$this->requestedCommitPHIDs = $requested_commit_phids;
	return $this;
	}

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

	public function withSeverities(array $severities) {
	$this->severities = $severities;
	return $this;
	}

	- public function withRevisionPHIDs(array $revision_phids) {
	- $this->revisionPHIDs = $revision_phids;
	+ public function withRequestedObjectPHIDs(array $phids) {
	+ $this->requestedObjectPHIDs = $phids;
	return $this;
	}

	public function loadPage() {
	$table = new ReleephRequest();
	$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 $requests) {

	+ // Load requested objects: you must be able to see an object to see
	+ // requests for it.
	+ $object_phids = mpull($requests, 'getRequestedObjectPHID');
	+ $objects = id(new PhabricatorObjectQuery())
	+ ->setViewer($this->getViewer())
	+ ->setParentQuery($this)
	+ ->withPHIDs($object_phids)
	+ ->execute();
	+
	+ foreach ($requests as $key => $request) {
	+ $object_phid = $request->getRequestedObjectPHID();
	+ $object = idx($objects, $object_phid);
	+ if (!$object) {
	+ unset($requests[$key]);
	+ continue;
	+ }
	+ $request->attachRequestedObject($object);
	+ }
	+
	if ($this->severities) {
	$severities = array_fuse($this->severities);
	foreach ($requests as $key => $request) {

	// NOTE: Facebook uses a custom field here.
	if (ReleephDefaultFieldSelector::isFacebook()) {
	$severity = $request->getDetail('severity');
	} else {
	$severity = $request->getDetail('releeph:severity');
	}

	if (empty($severities[$severity])) {
	unset($requests[$key]);
	}
	}
	}

	$branch_ids = array_unique(mpull($requests, 'getBranchID'));
	$branches = id(new ReleephBranchQuery())
	->withIDs($branch_ids)
	->setViewer($this->getViewer())
	->execute();
	$branches = mpull($branches, null, 'getID');
	foreach ($requests as $key => $request) {
	$branch = idx($branches, $request->getBranchID());
	if (!$branch) {
	unset($requests[$key]);
	continue;
	}
	$request->attachBranch($branch);
	}

	// TODO: These should be serviced by the query, but are not currently
	// denormalized anywhere. For now, filter them here instead. Note that
	// we must perform this filtering after querying and attaching branches,
	// because request status depends on the product.

	$keep_status = array_fuse($this->getKeepStatusConstants());
	if ($keep_status) {
	foreach ($requests as $key => $request) {
	if (empty($keep_status[$request->getStatus()])) {
	unset($requests[$key]);
	}
	}
	}

	return $requests;
	}

	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

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

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

	- if ($this->branchIDs) {
	+ if ($this->branchIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'branchID IN (%Ld)',
	$this->branchIDs);
	}

	- if ($this->requestedCommitPHIDs) {
	+ if ($this->requestedCommitPHIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'requestCommitPHID IN (%Ls)',
	$this->requestedCommitPHIDs);
	}

	- if ($this->requestorPHIDs) {
	+ if ($this->requestorPHIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	'requestUserPHID IN (%Ls)',
	$this->requestorPHIDs);
	}

	- if ($this->revisionPHIDs) {
	- $type = PhabricatorEdgeConfig::TYPE_DREV_HAS_COMMIT;
	-
	- $edges = id(new PhabricatorEdgeQuery())
	- ->withSourcePHIDs($this->revisionPHIDs)
	- ->withEdgeTypes(array($type))
	- ->execute();
	-
	- $this->commitToRevMap = array();
	- foreach ($edges as $revision_phid => $edge) {
	- foreach ($edge[$type] as $commitPHID => $item) {
	- $this->commitToRevMap[$commitPHID] = $revision_phid;
	- }
	- }
	-
	- if (!$this->commitToRevMap) {
	- throw new PhabricatorEmptyQueryException("Malformed Revision Phids");
	- }
	-
	+ if ($this->requestedObjectPHIDs !== null) {
	$where[] = qsprintf(
	$conn_r,
	- 'requestCommitPHID IN (%Ls)',
	- array_keys($this->commitToRevMap));
	+ 'requestedObjectPHID IN (%Ls)',
	+ $this->requestedObjectPHIDs);
	}

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}

	private function getKeepStatusConstants() {
	switch ($this->status) {
	case self::STATUS_ALL:
	return array();
	case self::STATUS_OPEN:
	return array(
	ReleephRequestStatus::STATUS_REQUESTED,
	ReleephRequestStatus::STATUS_NEEDS_PICK,
	ReleephRequestStatus::STATUS_NEEDS_REVERT,
	);
	case self::STATUS_REQUESTED:
	return array(
	ReleephRequestStatus::STATUS_REQUESTED,
	);
	case self::STATUS_NEEDS_PULL:
	return array(
	ReleephRequestStatus::STATUS_NEEDS_PICK,
	);
	case self::STATUS_REJECTED:
	return array(
	ReleephRequestStatus::STATUS_REJECTED,
	);
	case self::STATUS_ABANDONED:
	return array(
	ReleephRequestStatus::STATUS_ABANDONED,
	);
	case self::STATUS_PULLED:
	return array(
	ReleephRequestStatus::STATUS_PICKED,
	);
	case self::STATUS_NEEDS_REVERT:
	return array(
	ReleephRequestStatus::NEEDS_REVERT,
	);
	case self::STATUS_REVERTED:
	return array(
	ReleephRequestStatus::REVERTED,
	);
	default:
	throw new Exception("Unknown status '{$this->status}'!");
	}
	}


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

	}
	diff --git a/src/applications/releeph/storage/ReleephRequest.php b/src/applications/releeph/storage/ReleephRequest.php
	index 4ff2af1ae7..487f1de7cb 100644
	--- a/src/applications/releeph/storage/ReleephRequest.php
	+++ b/src/applications/releeph/storage/ReleephRequest.php
	@@ -1,335 +1,320 @@
	<?php

	final class ReleephRequest extends ReleephDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorCustomFieldInterface {

	protected $branchID;
	protected $requestUserPHID;
	protected $details = array();
	protected $userIntents = array();
	protected $inBranch;
	protected $pickStatus;
	protected $mailKey;

	/**
	* The object which is being requested. Normally this is a commit, but it
	* might also be a revision. In the future, it could be a repository branch
	* or an external object (like a GitHub pull request).
	*/
	protected $requestedObjectPHID;

	// Information about the thing being requested
	protected $requestCommitPHID;

	// Information about the last commit to the releeph branch
	protected $commitIdentifier;
	protected $commitPHID;


	private $customFields = self::ATTACHABLE;
	private $branch = self::ATTACHABLE;
	+ private $requestedObject = self::ATTACHABLE;


	/* -( Constants and helper methods )--------------------------------------- */

	const INTENT_WANT = 'want';
	const INTENT_PASS = 'pass';

	const PICK_PENDING = 1; // old
	const PICK_FAILED = 2;
	const PICK_OK = 3;
	const PICK_MANUAL = 4; // old
	const REVERT_OK = 5;
	const REVERT_FAILED = 6;

	public function shouldBeInBranch() {
	return
	$this->getPusherIntent() == self::INTENT_WANT &&
	/**
	* We use "!= pass" instead of "== want" in case the requestor intent is
	* not present. In other words, only revert if the requestor explicitly
	* passed.
	*/
	$this->getRequestorIntent() != self::INTENT_PASS;
	}

	/**
	* Will return INTENT_WANT if any pusher wants this request, and no pusher
	* passes on this request.
	*/
	public function getPusherIntent() {
	$product = $this->getBranch()->getProduct();

	if (!$product->getPushers()) {
	return self::INTENT_WANT;
	}

	$found_pusher_want = false;
	foreach ($this->userIntents as $phid => $intent) {
	if ($product->isAuthoritativePHID($phid)) {
	if ($intent == self::INTENT_PASS) {
	return self::INTENT_PASS;
	}

	$found_pusher_want = true;
	}
	}

	if ($found_pusher_want) {
	return self::INTENT_WANT;
	} else {
	return null;
	}
	}

	public function getRequestorIntent() {
	return idx($this->userIntents, $this->requestUserPHID);
	}

	public function getStatus() {
	return $this->calculateStatus();
	}

	public function getMonogram() {
	return 'Y'.$this->getID();
	}

	public function getBranch() {
	return $this->assertAttached($this->branch);
	}

	public function attachBranch(ReleephBranch $branch) {
	$this->branch = $branch;
	return $this;
	}

	+ public function getRequestedObject() {
	+ return $this->assertAttached($this->requestedObject);
	+ }
	+
	+ public function attachRequestedObject($object) {
	+ $this->requestedObject = $object;
	+ return $this;
	+ }
	+
	private function calculateStatus() {
	if ($this->shouldBeInBranch()) {
	if ($this->getInBranch()) {
	return ReleephRequestStatus::STATUS_PICKED;
	} else {
	return ReleephRequestStatus::STATUS_NEEDS_PICK;
	}
	} else {
	if ($this->getInBranch()) {
	return ReleephRequestStatus::STATUS_NEEDS_REVERT;
	} else {
	$has_been_in_branch = $this->getCommitIdentifier();
	// Regardless of why we reverted something, always say reverted if it
	// was once in the branch.
	if ($has_been_in_branch) {
	return ReleephRequestStatus::STATUS_REVERTED;
	} elseif ($this->getPusherIntent() === ReleephRequest::INTENT_PASS) {
	// Otherwise, if it has never been in the branch, explicitly say why:
	return ReleephRequestStatus::STATUS_REJECTED;
	} elseif ($this->getRequestorIntent() === ReleephRequest::INTENT_WANT) {
	return ReleephRequestStatus::STATUS_REQUESTED;
	} else {
	return ReleephRequestStatus::STATUS_ABANDONED;
	}
	}
	}
	}


	/* -( Lisk mechanics )----------------------------------------------------- */

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'details' => self::SERIALIZATION_JSON,
	'userIntents' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

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

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


	/* -( Helpful accessors )--------------------------------------------------- */


	public function getDetail($key, $default = null) {
	return idx($this->getDetails(), $key, $default);
	}

	public function setDetail($key, $value) {
	$this->details[$key] = $value;
	return $this;
	}


	/**
	* Get the commit PHIDs this request is requesting.
	*
	* NOTE: For now, this always returns one PHID.
	*
	* @return list<phid> Commit PHIDs requested by this request.
	*/
	public function getCommitPHIDs() {
	return array(
	$this->requestCommitPHID,
	);
	}

	public function getReason() {
	// Backward compatibility: reason used to be called comments
	$reason = $this->getDetail('reason');
	if (!$reason) {
	return $this->getDetail('comments');
	}
	return $reason;
	}

	/**
	* Allow a null summary, and fall back to the title of the commit.
	*/
	public function getSummaryForDisplay() {
	$summary = $this->getDetail('summary');

	if (!strlen($summary)) {
	$commit = $this->loadPhabricatorRepositoryCommit();
	if ($commit) {
	$summary = $commit->getSummary();
	}
	}

	if (!strlen($summary)) {
	$summary = pht('None');
	}

	return $summary;
	}

	- public function loadRequestCommitDiffPHID() {
	- $phids = array();
	- $commit = $this->loadPhabricatorRepositoryCommit();
	- if ($commit) {
	- $phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	- $commit->getPHID(),
	- PhabricatorEdgeConfig::TYPE_COMMIT_HAS_DREV);
	- }
	-
	- return head($phids);
	- }
	-
	-
	/* -( Loading external objects )------------------------------------------- */

	public function loadPhabricatorRepositoryCommit() {
	return $this->loadOneRelative(
	new PhabricatorRepositoryCommit(),
	'phid',
	'getRequestCommitPHID');
	}

	public function loadPhabricatorRepositoryCommitData() {
	$commit = $this->loadPhabricatorRepositoryCommit();
	if ($commit) {
	return $commit->loadOneRelative(
	new PhabricatorRepositoryCommitData(),
	'commitID');
	}
	}

	- // TODO: (T603) Get rid of all this one-off ad-hoc loading.
	- public function loadDifferentialRevision() {
	- $diff_phid = $this->loadRequestCommitDiffPHID();
	- if (!$diff_phid) {
	- return null;
	- }
	- return $this->loadOneRelative(
	- new DifferentialRevision(),
	- 'phid',
	- 'loadRequestCommitDiffPHID');
	- }
	-

	/* -( State change helpers )----------------------------------------------- */

	public function setUserIntent(PhabricatorUser $user, $intent) {
	$this->userIntents[$user->getPHID()] = $intent;
	return $this;
	}


	/* -( Migrating to status-less ReleephRequests )--------------------------- */

	protected function didReadData() {
	if ($this->userIntents === null) {
	$this->userIntents = array();
	}
	}

	public function setStatus($value) {
	throw new Exception('`status` is now deprecated!');
	}

	/* -( Make magic Lisk methods private )------------------------------------ */

	private function setUserIntents(array $ar) {
	return parent::setUserIntents($ar);
	}


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


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

	public function getPolicy($capability) {
	return $this->getBranch()->getPolicy($capability);
	}

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

	public function describeAutomaticCapability($capability) {
	return pht(
	'Pull requests have the same policies as the branches they are '.
	'requested against.');
	}



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


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

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

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

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


	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jul 29, 1:40 PM (3 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 188700
Default Alt Text: (36 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions