No OneTemporary
Actions

Size

64 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/controller/DifferentialRevisionViewController.php b/src/applications/differential/controller/DifferentialRevisionViewController.php
	index 98403e2a81..f62fb62ea7 100644
	--- a/src/applications/differential/controller/DifferentialRevisionViewController.php
	+++ b/src/applications/differential/controller/DifferentialRevisionViewController.php
	@@ -1,945 +1,957 @@
	<?php

	final class DifferentialRevisionViewController extends DifferentialController {

	private $revisionID;

	public function shouldAllowPublic() {
	return true;
	}

	public function willProcessRequest(array $data) {
	$this->revisionID = $data['id'];
	}

	public function processRequest() {

	$request = $this->getRequest();
	$user = $request->getUser();
	$viewer_is_anonymous = !$user->isLoggedIn();

	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($this->revisionID))
	->setViewer($request->getUser())
	->needRelationships(true)
	->needReviewerStatus(true)
	->needReviewerAuthority(true)
	->executeOne();

	if (!$revision) {
	return new Aphront404Response();
	}

	$diffs = id(new DifferentialDiffQuery())
	->setViewer($request->getUser())
	->withRevisionIDs(array($this->revisionID))
	+ ->needArcanistProjects(true)
	->execute();
	$diffs = array_reverse($diffs, $preserve_keys = true);

	if (!$diffs) {
	throw new Exception(
	"This revision has no diffs. Something has gone quite wrong.");
	}

	$revision->attachActiveDiff(last($diffs));

	$diff_vs = $request->getInt('vs');

	$target_id = $request->getInt('id');
	$target = idx($diffs, $target_id, end($diffs));

	$target_manual = $target;
	if (!$target_id) {
	foreach ($diffs as $diff) {
	if ($diff->getCreationMethod() != 'commit') {
	$target_manual = $diff;
	}
	}
	}

	if (empty($diffs[$diff_vs])) {
	$diff_vs = null;
	}

	- $arc_project = $target->loadArcanistProject();
	- $repository = ($arc_project ? $arc_project->loadRepository() : null);
	+ $repository = null;
	+ $repository_phid = $target->getRepositoryPHID();
	+ if ($repository_phid) {
	+ if ($repository_phid == $revision->getRepositoryPHID()) {
	+ $repository = $revision->getRepository();
	+ } else {
	+ $repository = id(new PhabricatorRepositoryQuery())
	+ ->setViewer($user)
	+ ->withPHIDs(array($repository_phid))
	+ ->executeOne();
	+ }
	+ }

	list($changesets, $vs_map, $vs_changesets, $rendering_references) =
	$this->loadChangesetsAndVsMap(
	$target,
	idx($diffs, $diff_vs),
	$repository);

	if ($request->getExists('download')) {
	return $this->buildRawDiffResponse(
	$revision,
	$changesets,
	$vs_changesets,
	$vs_map,
	$repository);
	}

	$props = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d',
	$target_manual->getID());
	$props = mpull($props, 'getData', 'getName');

	$all_changesets = $changesets;
	$inlines = $this->loadInlineComments(
	$revision,
	$all_changesets);

	$object_phids = array_merge(
	$revision->getReviewers(),
	$revision->getCCPHIDs(),
	$revision->loadCommitPHIDs(),
	array(
	$revision->getAuthorPHID(),
	$user->getPHID(),
	));

	foreach ($revision->getAttached() as $type => $phids) {
	foreach ($phids as $phid => $info) {
	$object_phids[] = $phid;
	}
	}

	$handles = $this->loadViewerHandles($object_phids);

	$request_uri = $request->getRequestURI();

	$limit = 100;
	$large = $request->getStr('large');
	if (count($changesets) > $limit && !$large) {
	$count = count($changesets);
	$warning = new AphrontErrorView();
	$warning->setTitle('Very Large Diff');
	$warning->setSeverity(AphrontErrorView::SEVERITY_WARNING);
	$warning->appendChild(hsprintf(
	'%s <strong>%s</strong>',
	pht(
	'This diff is very large and affects %s files. Load each file '.
	'individually.',
	new PhutilNumber($count)),
	phutil_tag(
	'a',
	array(
	'href' => $request_uri
	->alter('large', 'true')
	->setFragment('toc'),
	),
	pht('Show All Files Inline'))));
	$warning = $warning->render();

	$my_inlines = id(new DifferentialInlineCommentQuery())
	->withDraftComments($user->getPHID(), $this->revisionID)
	->execute();

	$visible_changesets = array();
	foreach ($inlines + $my_inlines as $inline) {
	$changeset_id = $inline->getChangesetID();
	if (isset($changesets[$changeset_id])) {
	$visible_changesets[$changeset_id] = $changesets[$changeset_id];
	}
	}

	if (!empty($props['arc:lint'])) {
	$changeset_paths = mpull($changesets, null, 'getFilename');
	foreach ($props['arc:lint'] as $lint) {
	$changeset = idx($changeset_paths, $lint['path']);
	if ($changeset) {
	$visible_changesets[$changeset->getID()] = $changeset;
	}
	}
	}

	} else {
	$warning = null;
	$visible_changesets = $changesets;
	}

	$field_list = PhabricatorCustomField::getObjectFields(
	$revision,
	PhabricatorCustomField::ROLE_VIEW);

	$field_list->setViewer($user);
	$field_list->readFieldsFromStorage($revision);


	// TODO: This should be in a DiffQuery or similar.
	$need_props = array();
	foreach ($field_list->getFields() as $field) {
	foreach ($field->getRequiredDiffPropertiesForRevisionView() as $prop) {
	$need_props[$prop] = $prop;
	}
	}

	if ($need_props) {
	$prop_diff = $revision->getActiveDiff();
	$load_props = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d AND name IN (%Ls)',
	$prop_diff->getID(),
	$need_props);
	$load_props = mpull($load_props, 'getData', 'getName');
	foreach ($need_props as $need) {
	$prop_diff->attachProperty($need, idx($load_props, $need));
	}
	}

	$commit_hashes = mpull($diffs, 'getSourceControlBaseRevision');
	$local_commits = idx($props, 'local:commits', array());
	foreach ($local_commits as $local_commit) {
	$commit_hashes[] = idx($local_commit, 'tree');
	$commit_hashes[] = idx($local_commit, 'local');
	}
	$commit_hashes = array_unique(array_filter($commit_hashes));
	if ($commit_hashes) {
	$commits_for_links = id(new DiffusionCommitQuery())
	->setViewer($user)
	->withIdentifiers($commit_hashes)
	->execute();
	$commits_for_links = mpull(
	$commits_for_links,
	null,
	'getCommitIdentifier');
	} else {
	$commits_for_links = array();
	}

	$revision_detail = id(new DifferentialRevisionDetailView())
	->setUser($user)
	->setRevision($revision)
	->setDiff(end($diffs))
	->setCustomFields($field_list)
	->setURI($request->getRequestURI());

	$actions = $this->getRevisionActions($revision);

	$whitespace = $request->getStr(
	'whitespace',
	DifferentialChangesetParser::WHITESPACE_IGNORE_ALL);

	+ $arc_project = $target->getArcanistProject();
	if ($arc_project) {
	list($symbol_indexes, $project_phids) = $this->buildSymbolIndexes(
	$arc_project,
	$visible_changesets);
	} else {
	$symbol_indexes = array();
	$project_phids = null;
	}

	$revision_detail->setActions($actions);
	$revision_detail->setUser($user);

	$revision_detail_box = $revision_detail->render();

	$revision_warnings = $this->buildRevisionWarnings($revision, $handles);
	if ($revision_warnings) {
	$revision_detail_box->setErrorView($revision_warnings);
	}

	$comment_view = $this->buildTransactions(
	$revision,
	$diff_vs ? $diffs[$diff_vs] : $target,
	$target,
	$all_changesets);

	$wrap_id = celerity_generate_unique_node_id();
	$comment_view = phutil_tag(
	'div',
	array(
	'id' => $wrap_id,
	),
	$comment_view);

	if ($arc_project) {
	Javelin::initBehavior(
	'repository-crossreference',
	array(
	'section' => $wrap_id,
	'projects' => $project_phids,
	));
	}

	$changeset_view = new DifferentialChangesetListView();
	$changeset_view->setChangesets($changesets);
	$changeset_view->setVisibleChangesets($visible_changesets);

	if (!$viewer_is_anonymous) {
	$changeset_view->setInlineCommentControllerURI(
	'/differential/comment/inline/edit/'.$revision->getID().'/');
	}

	$changeset_view->setStandaloneURI('/differential/changeset/');
	$changeset_view->setRawFileURIs(
	'/differential/changeset/?view=old',
	'/differential/changeset/?view=new');

	$changeset_view->setUser($user);
	$changeset_view->setDiff($target);
	$changeset_view->setRenderingReferences($rendering_references);
	$changeset_view->setVsMap($vs_map);
	$changeset_view->setWhitespace($whitespace);
	if ($repository) {
	$changeset_view->setRepository($repository);
	}
	$changeset_view->setSymbolIndexes($symbol_indexes);
	$changeset_view->setTitle('Diff '.$target->getID());

	$diff_history = id(new DifferentialRevisionUpdateHistoryView())
	->setUser($user)
	->setDiffs($diffs)
	->setSelectedVersusDiffID($diff_vs)
	->setSelectedDiffID($target->getID())
	->setSelectedWhitespace($whitespace)
	->setCommitsForLinks($commits_for_links);

	$local_view = id(new DifferentialLocalCommitsView())
	->setUser($user)
	->setLocalCommits(idx($props, 'local:commits'))
	->setCommitsForLinks($commits_for_links);

	if ($repository) {
	$other_revisions = $this->loadOtherRevisions(
	$changesets,
	$target,
	$repository);
	} else {
	$other_revisions = array();
	}

	$other_view = null;
	if ($other_revisions) {
	$other_view = $this->renderOtherRevisions($other_revisions);
	}

	$toc_view = new DifferentialDiffTableOfContentsView();
	$toc_view->setChangesets($changesets);
	$toc_view->setVisibleChangesets($visible_changesets);
	$toc_view->setRenderingReferences($rendering_references);
	$toc_view->setUnitTestData(idx($props, 'arc:unit', array()));
	if ($repository) {
	$toc_view->setRepository($repository);
	}
	$toc_view->setDiff($target);
	$toc_view->setUser($user);
	$toc_view->setRevisionID($revision->getID());
	$toc_view->setWhitespace($whitespace);

	$comment_form = null;
	if (!$viewer_is_anonymous) {
	$draft = id(new PhabricatorDraft())->loadOneWhere(
	'authorPHID = %s AND draftKey = %s',
	$user->getPHID(),
	'differential-comment-'.$revision->getID());

	$reviewers = array();
	$ccs = array();
	if ($draft) {
	$reviewers = idx($draft->getMetadata(), 'reviewers', array());
	$ccs = idx($draft->getMetadata(), 'ccs', array());
	if ($reviewers \|\| $ccs) {
	$handles = $this->loadViewerHandles(array_merge($reviewers, $ccs));
	$reviewers = array_select_keys($handles, $reviewers);
	$ccs = array_select_keys($handles, $ccs);
	}
	}

	$comment_form = new DifferentialAddCommentView();
	$comment_form->setRevision($revision);

	$review_warnings = array();
	foreach ($field_list->getFields() as $field) {
	$review_warnings[] = $field->getWarningsForDetailView();
	}
	$review_warnings = array_mergev($review_warnings);

	if ($review_warnings) {
	$review_warnings_panel = id(new AphrontErrorView())
	->setSeverity(AphrontErrorView::SEVERITY_WARNING)
	->setErrors($review_warnings);
	$comment_form->setErrorView($review_warnings_panel);
	}

	// TODO: Restore the ability for fields to add accept warnings.

	$comment_form->setActions($this->getRevisionCommentActions($revision));
	$action_uri = $this->getApplicationURI(
	'comment/save/'.$revision->getID().'/');

	$comment_form->setActionURI($action_uri);
	$comment_form->setUser($user);
	$comment_form->setDraft($draft);
	$comment_form->setReviewers(mpull($reviewers, 'getFullName', 'getPHID'));
	$comment_form->setCCs(mpull($ccs, 'getFullName', 'getPHID'));

	// TODO: This just makes the "Z" key work. Generalize this and remove
	// it at some point.
	$comment_form = phutil_tag(
	'div',
	array(
	'class' => 'differential-add-comment-panel',
	),
	$comment_form);
	}

	$pane_id = celerity_generate_unique_node_id();
	Javelin::initBehavior(
	'differential-keyboard-navigation',
	array(
	'haunt' => $pane_id,
	));
	Javelin::initBehavior('differential-user-select');

	$page_pane = id(new DifferentialPrimaryPaneView())
	->setID($pane_id)
	->appendChild(array(
	$comment_view,
	$diff_history,
	$warning,
	$local_view,
	$toc_view,
	$other_view,
	$changeset_view,
	));
	if ($comment_form) {
	$page_pane->appendChild($comment_form);
	} else {
	// TODO: For now, just use this to get "Login to Comment".
	$page_pane->appendChild(
	id(new PhabricatorApplicationTransactionCommentView())
	->setUser($user)
	->setRequestURI($request->getRequestURI()));
	}


	$object_id = 'D'.$revision->getID();

	$top_anchor = id(new PhabricatorAnchorView())
	->setAnchorName('top')
	->setNavigationMarker(true);

	$content = array(
	$top_anchor,
	$revision_detail_box,
	$page_pane,
	);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb($object_id, '/'.$object_id);
	$crumbs->setActionList($revision_detail->getActionList());

	$prefs = $user->loadPreferences();

	$pref_filetree = PhabricatorUserPreferences::PREFERENCE_DIFF_FILETREE;
	if ($prefs->getPreference($pref_filetree)) {
	$collapsed = $prefs->getPreference(
	PhabricatorUserPreferences::PREFERENCE_NAV_COLLAPSED,
	false);

	$nav = id(new DifferentialChangesetFileTreeSideNavBuilder())
	->setAnchorName('top')
	->setTitle('D'.$revision->getID())
	->setBaseURI(new PhutilURI('/D'.$revision->getID()))
	->setCollapsed((bool)$collapsed)
	->build($changesets);
	$nav->appendChild($content);
	$nav->setCrumbs($crumbs);
	$content = $nav;
	} else {
	array_unshift($content, $crumbs);
	}

	return $this->buildApplicationPage(
	$content,
	array(
	'title' => $object_id.' '.$revision->getTitle(),
	'pageObjects' => array($revision->getPHID()),
	'device' => true,
	));
	}

	private function getRevisionActions(DifferentialRevision $revision) {
	$viewer = $this->getRequest()->getUser();
	$revision_id = $revision->getID();
	$revision_phid = $revision->getPHID();

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

	$actions = array();

	$actions[] = id(new PhabricatorActionView())
	->setIcon('edit')
	->setHref("/differential/revision/edit/{$revision_id}/")
	->setName(pht('Edit Revision'))
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit);

	$this->requireResource('phabricator-object-selector-css');
	$this->requireResource('javelin-behavior-phabricator-object-selector');

	$actions[] = id(new PhabricatorActionView())
	->setIcon('link')
	->setName(pht('Edit Dependencies'))
	->setHref("/search/attach/{$revision_phid}/DREV/dependencies/")
	->setWorkflow(true)
	->setDisabled(!$can_edit);

	$maniphest = 'PhabricatorApplicationManiphest';
	if (PhabricatorApplication::isClassInstalled($maniphest)) {
	$actions[] = id(new PhabricatorActionView())
	->setIcon('attach')
	->setName(pht('Edit Maniphest Tasks'))
	->setHref("/search/attach/{$revision_phid}/TASK/")
	->setWorkflow(true)
	->setDisabled(!$can_edit);
	}

	$request_uri = $this->getRequest()->getRequestURI();
	$actions[] = id(new PhabricatorActionView())
	->setIcon('download')
	->setName(pht('Download Raw Diff'))
	->setHref($request_uri->alter('download', 'true'));

	return $actions;
	}

	private function getRevisionCommentActions(DifferentialRevision $revision) {

	$actions = array(
	DifferentialAction::ACTION_COMMENT => true,
	);

	$viewer = $this->getRequest()->getUser();
	$viewer_phid = $viewer->getPHID();
	$viewer_is_owner = ($viewer_phid == $revision->getAuthorPHID());
	$viewer_is_reviewer = in_array($viewer_phid, $revision->getReviewers());
	$status = $revision->getStatus();

	$viewer_has_accepted = false;
	$viewer_has_rejected = false;
	$status_accepted = DifferentialReviewerStatus::STATUS_ACCEPTED;
	$status_rejected = DifferentialReviewerStatus::STATUS_REJECTED;
	foreach ($revision->getReviewerStatus() as $reviewer) {
	if ($reviewer->getReviewerPHID() == $viewer_phid) {
	if ($reviewer->getStatus() == $status_accepted) {
	$viewer_has_accepted = true;
	}
	if ($reviewer->getStatus() == $status_rejected) {
	$viewer_has_rejected = true;
	}
	break;
	}
	}

	$allow_self_accept = PhabricatorEnv::getEnvConfig(
	'differential.allow-self-accept');
	$always_allow_close = PhabricatorEnv::getEnvConfig(
	'differential.always-allow-close');
	$allow_reopen = PhabricatorEnv::getEnvConfig(
	'differential.allow-reopen');

	if ($viewer_is_owner) {
	switch ($status) {
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	$actions[DifferentialAction::ACTION_ACCEPT] = $allow_self_accept;
	$actions[DifferentialAction::ACTION_ABANDON] = true;
	$actions[DifferentialAction::ACTION_RETHINK] = true;
	break;
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
	$actions[DifferentialAction::ACTION_ACCEPT] = $allow_self_accept;
	$actions[DifferentialAction::ACTION_ABANDON] = true;
	$actions[DifferentialAction::ACTION_REQUEST] = true;
	break;
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	$actions[DifferentialAction::ACTION_ABANDON] = true;
	$actions[DifferentialAction::ACTION_REQUEST] = true;
	$actions[DifferentialAction::ACTION_RETHINK] = true;
	$actions[DifferentialAction::ACTION_CLOSE] = true;
	break;
	case ArcanistDifferentialRevisionStatus::CLOSED:
	break;
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	$actions[DifferentialAction::ACTION_RECLAIM] = true;
	break;
	}
	} else {
	switch ($status) {
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	$actions[DifferentialAction::ACTION_ACCEPT] = true;
	$actions[DifferentialAction::ACTION_REJECT] = true;
	$actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
	break;
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
	$actions[DifferentialAction::ACTION_ACCEPT] = true;
	$actions[DifferentialAction::ACTION_REJECT] = !$viewer_has_rejected;
	$actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
	break;
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	$actions[DifferentialAction::ACTION_ACCEPT] = !$viewer_has_accepted;
	$actions[DifferentialAction::ACTION_REJECT] = true;
	$actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
	break;
	case ArcanistDifferentialRevisionStatus::CLOSED:
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	break;
	}
	if ($status != ArcanistDifferentialRevisionStatus::CLOSED) {
	$actions[DifferentialAction::ACTION_CLAIM] = true;
	$actions[DifferentialAction::ACTION_CLOSE] = $always_allow_close;
	}
	}

	$actions[DifferentialAction::ACTION_ADDREVIEWERS] = true;
	$actions[DifferentialAction::ACTION_ADDCCS] = true;
	$actions[DifferentialAction::ACTION_REOPEN] = $allow_reopen &&
	($status == ArcanistDifferentialRevisionStatus::CLOSED);

	$actions = array_keys(array_filter($actions));
	$actions_dict = array();
	foreach ($actions as $action) {
	$actions_dict[$action] = DifferentialAction::getActionVerb($action);
	}

	return $actions_dict;
	}

	private function loadInlineComments(
	DifferentialRevision $revision,
	array &$changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');

	$inline_comments = array();

	$inline_comments = id(new DifferentialInlineCommentQuery())
	->withRevisionIDs(array($revision->getID()))
	->withNotDraft(true)
	->execute();

	$load_changesets = array();
	foreach ($inline_comments as $inline) {
	$changeset_id = $inline->getChangesetID();
	if (isset($changesets[$changeset_id])) {
	continue;
	}
	$load_changesets[$changeset_id] = true;
	}

	$more_changesets = array();
	if ($load_changesets) {
	$changeset_ids = array_keys($load_changesets);
	$more_changesets += id(new DifferentialChangeset())
	->loadAllWhere(
	'id IN (%Ld)',
	$changeset_ids);
	}

	if ($more_changesets) {
	$changesets += $more_changesets;
	$changesets = msort($changesets, 'getSortKey');
	}

	return $inline_comments;
	}

	private function loadChangesetsAndVsMap(
	DifferentialDiff $target,
	DifferentialDiff $diff_vs = null,
	PhabricatorRepository $repository = null) {

	$load_ids = array();
	if ($diff_vs) {
	$load_ids[] = $diff_vs->getID();
	}
	$load_ids[] = $target->getID();

	$raw_changesets = id(new DifferentialChangeset())
	->loadAllWhere(
	'diffID IN (%Ld)',
	$load_ids);
	$changeset_groups = mgroup($raw_changesets, 'getDiffID');

	$changesets = idx($changeset_groups, $target->getID(), array());
	$changesets = mpull($changesets, null, 'getID');

	$refs = array();
	$vs_map = array();
	$vs_changesets = array();
	if ($diff_vs) {
	$vs_id = $diff_vs->getID();
	$vs_changesets_path_map = array();
	foreach (idx($changeset_groups, $vs_id, array()) as $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $diff_vs);
	$vs_changesets_path_map[$path] = $changeset;
	$vs_changesets[$changeset->getID()] = $changeset;
	}
	foreach ($changesets as $key => $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $target);
	if (isset($vs_changesets_path_map[$path])) {
	$vs_map[$changeset->getID()] =
	$vs_changesets_path_map[$path]->getID();
	$refs[$changeset->getID()] =
	$changeset->getID().'/'.$vs_changesets_path_map[$path]->getID();
	unset($vs_changesets_path_map[$path]);
	} else {
	$refs[$changeset->getID()] = $changeset->getID();
	}
	}
	foreach ($vs_changesets_path_map as $path => $changeset) {
	$changesets[$changeset->getID()] = $changeset;
	$vs_map[$changeset->getID()] = -1;
	$refs[$changeset->getID()] = $changeset->getID().'/-1';
	}
	} else {
	foreach ($changesets as $changeset) {
	$refs[$changeset->getID()] = $changeset->getID();
	}
	}

	$changesets = msort($changesets, 'getSortKey');

	return array($changesets, $vs_map, $vs_changesets, $refs);
	}

	private function buildSymbolIndexes(
	PhabricatorRepositoryArcanistProject $arc_project,
	array $visible_changesets) {
	assert_instances_of($visible_changesets, 'DifferentialChangeset');

	$engine = PhabricatorSyntaxHighlighter::newEngine();

	$langs = $arc_project->getSymbolIndexLanguages();
	if (!$langs) {
	return array(array(), array());
	}

	$symbol_indexes = array();

	$project_phids = array_merge(
	array($arc_project->getPHID()),
	nonempty($arc_project->getSymbolIndexProjects(), array()));

	$indexed_langs = array_fill_keys($langs, true);
	foreach ($visible_changesets as $key => $changeset) {
	$lang = $engine->getLanguageFromFilename($changeset->getFilename());
	if (isset($indexed_langs[$lang])) {
	$symbol_indexes[$key] = array(
	'lang' => $lang,
	'projects' => $project_phids,
	);
	}
	}

	return array($symbol_indexes, $project_phids);
	}

	private function loadOtherRevisions(
	array $changesets,
	DifferentialDiff $target,
	PhabricatorRepository $repository) {
	assert_instances_of($changesets, 'DifferentialChangeset');

	$paths = array();
	foreach ($changesets as $changeset) {
	$paths[] = $changeset->getAbsoluteRepositoryPath(
	$repository,
	$target);
	}

	if (!$paths) {
	return array();
	}

	$path_map = id(new DiffusionPathIDQuery($paths))->loadPathIDs();

	if (!$path_map) {
	return array();
	}

	$query = id(new DifferentialRevisionQuery())
	->setViewer($this->getRequest()->getUser())
	->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
	->setOrder(DifferentialRevisionQuery::ORDER_PATH_MODIFIED)
	->setLimit(10)
	->needFlags(true)
	->needDrafts(true)
	->needRelationships(true);

	foreach ($path_map as $path => $path_id) {
	$query->withPath($repository->getID(), $path_id);
	}

	$results = $query->execute();

	// Strip out this revision.
	foreach ($results as $key => $result) {
	if ($result->getID() == $this->revisionID) {
	unset($results[$key]);
	}
	}

	return $results;
	}

	private function renderOtherRevisions(array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');

	$user = $this->getRequest()->getUser();

	$view = id(new DifferentialRevisionListView())
	->setRevisions($revisions)
	->setUser($user);

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

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Open Revisions Affecting These Files'))
	->appendChild($view);
	}


	/**
	* Note this code is somewhat similar to the buildPatch method in
	* @{class:DifferentialReviewRequestMail}.
	*
	* @return @{class:AphrontRedirectResponse}
	*/
	private function buildRawDiffResponse(
	DifferentialRevision $revision,
	array $changesets,
	array $vs_changesets,
	array $vs_map,
	PhabricatorRepository $repository = null) {

	assert_instances_of($changesets, 'DifferentialChangeset');
	assert_instances_of($vs_changesets, 'DifferentialChangeset');

	$viewer = $this->getRequest()->getUser();

	foreach ($changesets as $changeset) {
	$changeset->attachHunks($changeset->loadHunks());
	}

	$diff = new DifferentialDiff();
	$diff->attachChangesets($changesets);
	$raw_changes = $diff->buildChangesList();
	$changes = array();
	foreach ($raw_changes as $changedict) {
	$changes[] = ArcanistDiffChange::newFromDictionary($changedict);
	}

	$loader = id(new PhabricatorFileBundleLoader())
	->setViewer($viewer);

	$bundle = ArcanistBundle::newFromChanges($changes);
	$bundle->setLoadFileDataCallback(array($loader, 'loadFileData'));

	$vcs = $repository ? $repository->getVersionControlSystem() : null;
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$raw_diff = $bundle->toGitPatch();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	default:
	$raw_diff = $bundle->toUnifiedDiff();
	break;
	}

	$request_uri = $this->getRequest()->getRequestURI();

	// this ends up being something like
	// D123.diff
	// or the verbose
	// D123.vs123.id123.whitespaceignore-all.diff
	// lame but nice to include these options
	$file_name = ltrim($request_uri->getPath(), '/').'.';
	foreach ($request_uri->getQueryParams() as $key => $value) {
	if ($key == 'download') {
	continue;
	}
	$file_name .= $key.$value.'.';
	}
	$file_name .= 'diff';

	$file = PhabricatorFile::buildFromFileDataOrHash(
	$raw_diff,
	array(
	'name' => $file_name,
	'ttl' => (60 * 60 * 24),
	'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
	));

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$file->attachToObject(
	$this->getRequest()->getUser(),
	$revision->getPHID());
	unset($unguarded);

	return id(new AphrontRedirectResponse())->setURI($file->getBestURI());

	}

	private function buildTransactions(
	DifferentialRevision $revision,
	DifferentialDiff $left_diff,
	DifferentialDiff $right_diff,
	array $changesets) {
	$viewer = $this->getRequest()->getUser();

	$xactions = id(new DifferentialTransactionQuery())
	->setViewer($viewer)
	->withObjectPHIDs(array($revision->getPHID()))
	->needComments(true)
	->execute();

	$timeline = id(new DifferentialTransactionView())
	->setUser($viewer)
	->setObjectPHID($revision->getPHID())
	->setChangesets($changesets)
	->setRevision($revision)
	->setLeftDiff($left_diff)
	->setRightDiff($right_diff)
	->setTransactions($xactions);

	return $timeline;
	}

	private function buildRevisionWarnings(
	DifferentialRevision $revision,
	array $handles) {

	$status_needs_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
	if ($revision->getStatus() != $status_needs_review) {
	return;
	}

	foreach ($revision->getReviewers() as $reviewer) {
	if (!$handles[$reviewer]->isDisabled()) {
	return;
	}
	}

	$warnings = array();
	if ($revision->getReviewers()) {
	$warnings[] = pht(
	'This revision needs review, but all specified reviewers are '.
	'disabled or inactive.');
	} else {
	$warnings[] = pht(
	'This revision needs review, but there are no reviewers specified.');
	}

	return id(new AphrontErrorView())
	->setSeverity(AphrontErrorView::SEVERITY_WARNING)
	->setErrors($warnings);
	}

	}
	diff --git a/src/applications/differential/storage/DifferentialDiff.php b/src/applications/differential/storage/DifferentialDiff.php
	index db6029233f..6af2bb9f6f 100644
	--- a/src/applications/differential/storage/DifferentialDiff.php
	+++ b/src/applications/differential/storage/DifferentialDiff.php
	@@ -1,373 +1,352 @@
	<?php

	final class DifferentialDiff
	extends DifferentialDAO
	implements
	PhabricatorPolicyInterface,
	HarbormasterBuildableInterface {

	protected $revisionID;
	protected $authorPHID;
	protected $repositoryPHID;

	protected $sourceMachine;
	protected $sourcePath;

	protected $sourceControlSystem;
	protected $sourceControlBaseRevision;
	protected $sourceControlPath;

	protected $lintStatus;
	protected $unitStatus;

	protected $lineCount;

	protected $branch;
	protected $bookmark;

	protected $arcanistProjectPHID;
	protected $creationMethod;
	protected $repositoryUUID;

	protected $description;

	private $unsavedChangesets = array();
	private $changesets = self::ATTACHABLE;
	private $arcanistProject = self::ATTACHABLE;
	private $revision = self::ATTACHABLE;
	private $properties = array();

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

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

	public function addUnsavedChangeset(DifferentialChangeset $changeset) {
	if ($this->changesets === null) {
	$this->changesets = array();
	}
	$this->unsavedChangesets[] = $changeset;
	$this->changesets[] = $changeset;
	return $this;
	}

	public function attachChangesets(array $changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');
	$this->changesets = $changesets;
	return $this;
	}

	public function getChangesets() {
	return $this->assertAttached($this->changesets);
	}

	public function loadChangesets() {
	if (!$this->getID()) {
	return array();
	}
	return id(new DifferentialChangeset())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	}

	public function attachArcanistProject(
	PhabricatorRepositoryArcanistProject $project = null) {
	$this->arcanistProject = $project;
	return $this;
	}

	public function getArcanistProject() {
	return $this->assertAttached($this->arcanistProject);
	}

	public function getArcanistProjectName() {
	$name = '';
	if ($this->arcanistProject) {
	$project = $this->getArcanistProject();
	$name = $project->getName();
	}
	return $name;
	}

	- public function loadArcanistProject() {
	- if (!$this->getArcanistProjectPHID()) {
	- return null;
	- }
	- return id(new PhabricatorRepositoryArcanistProject())->loadOneWhere(
	- 'phid = %s',
	- $this->getArcanistProjectPHID());
	- }
	-
	- public function getBackingVersionControlSystem() {
	- $arcanist_project = $this->loadArcanistProject();
	- if (!$arcanist_project) {
	- return null;
	- }
	- $repository = $arcanist_project->loadRepository();
	- if (!$repository) {
	- return null;
	- }
	- return $repository->getVersionControlSystem();
	- }
	-
	public function save() {
	$this->openTransaction();
	$ret = parent::save();
	foreach ($this->unsavedChangesets as $changeset) {
	$changeset->setDiffID($this->getID());
	$changeset->save();
	}
	$this->saveTransaction();
	return $ret;
	}

	public function delete() {
	$this->openTransaction();
	foreach ($this->loadChangesets() as $changeset) {
	$changeset->delete();
	}

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	foreach ($properties as $prop) {
	$prop->delete();
	}

	$ret = parent::delete();
	$this->saveTransaction();
	return $ret;
	}

	public static function newFromRawChanges(array $changes) {
	assert_instances_of($changes, 'ArcanistDiffChange');
	$diff = new DifferentialDiff();

	// There may not be any changes; initialize the changesets list so that
	// we don't throw later when accessing it.
	$diff->attachChangesets(array());

	$lines = 0;
	foreach ($changes as $change) {
	if ($change->getType() == ArcanistDiffChangeType::TYPE_MESSAGE) {
	// If a user pastes a diff into Differential which includes a commit
	// message (e.g., they ran `git show` to generate it), discard that
	// change when constructing a DifferentialDiff.
	continue;
	}

	$changeset = new DifferentialChangeset();
	$add_lines = 0;
	$del_lines = 0;
	$first_line = PHP_INT_MAX;
	$hunks = $change->getHunks();
	if ($hunks) {
	foreach ($hunks as $hunk) {
	$dhunk = new DifferentialHunk();
	$dhunk->setOldOffset($hunk->getOldOffset());
	$dhunk->setOldLen($hunk->getOldLength());
	$dhunk->setNewOffset($hunk->getNewOffset());
	$dhunk->setNewLen($hunk->getNewLength());
	$dhunk->setChanges($hunk->getCorpus());
	$changeset->addUnsavedHunk($dhunk);
	$add_lines += $hunk->getAddLines();
	$del_lines += $hunk->getDelLines();
	$added_lines = $hunk->getChangedLines('new');
	if ($added_lines) {
	$first_line = min($first_line, head_key($added_lines));
	}
	}
	$lines += $add_lines + $del_lines;
	} else {
	// This happens when you add empty files.
	$changeset->attachHunks(array());
	}

	$metadata = $change->getAllMetadata();
	if ($first_line != PHP_INT_MAX) {
	$metadata['line:first'] = $first_line;
	}

	$changeset->setOldFile($change->getOldPath());
	$changeset->setFilename($change->getCurrentPath());
	$changeset->setChangeType($change->getType());

	$changeset->setFileType($change->getFileType());
	$changeset->setMetadata($metadata);
	$changeset->setOldProperties($change->getOldProperties());
	$changeset->setNewProperties($change->getNewProperties());
	$changeset->setAwayPaths($change->getAwayPaths());
	$changeset->setAddLines($add_lines);
	$changeset->setDelLines($del_lines);

	$diff->addUnsavedChangeset($changeset);
	}
	$diff->setLineCount($lines);

	$parser = new DifferentialChangesetParser();
	$changesets = $parser->detectCopiedCode(
	$diff->getChangesets(),
	$min_width = 30,
	$min_lines = 3);
	$diff->attachChangesets($changesets);

	return $diff;
	}


	public function getDiffDict() {
	$dict = array(
	'id' => $this->getID(),
	'revisionID' => $this->getRevisionID(),
	'dateCreated' => $this->getDateCreated(),
	'dateModified' => $this->getDateModified(),
	'sourceControlBaseRevision' => $this->getSourceControlBaseRevision(),
	'sourceControlPath' => $this->getSourceControlPath(),
	'sourceControlSystem' => $this->getSourceControlSystem(),
	'branch' => $this->getBranch(),
	'bookmark' => $this->getBookmark(),
	'creationMethod' => $this->getCreationMethod(),
	'description' => $this->getDescription(),
	'unitStatus' => $this->getUnitStatus(),
	'lintStatus' => $this->getLintStatus(),
	'changes' => array(),
	'properties' => array(),
	'projectName' => $this->getArcanistProjectName()
	);

	$dict['changes'] = $this->buildChangesList();

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	foreach ($properties as $property) {
	$dict['properties'][$property->getName()] = $property->getData();

	if ($property->getName() == 'local:commits') {
	foreach ($property->getData() as $commit) {
	$dict['authorName'] = $commit['author'];
	$dict['authorEmail'] = idx($commit, 'authorEmail');
	break;
	}
	}
	}

	return $dict;
	}

	public function buildChangesList() {
	$changes = array();
	foreach ($this->getChangesets() as $changeset) {
	$hunks = array();
	foreach ($changeset->getHunks() as $hunk) {
	$hunks[] = array(
	'oldOffset' => $hunk->getOldOffset(),
	'newOffset' => $hunk->getNewOffset(),
	'oldLength' => $hunk->getOldLen(),
	'newLength' => $hunk->getNewLen(),
	'addLines' => null,
	'delLines' => null,
	'isMissingOldNewline' => null,
	'isMissingNewNewline' => null,
	'corpus' => $hunk->getChanges(),
	);
	}
	$change = array(
	'id' => $changeset->getID(),
	'metadata' => $changeset->getMetadata(),
	'oldPath' => $changeset->getOldFile(),
	'currentPath' => $changeset->getFilename(),
	'awayPaths' => $changeset->getAwayPaths(),
	'oldProperties' => $changeset->getOldProperties(),
	'newProperties' => $changeset->getNewProperties(),
	'type' => $changeset->getChangeType(),
	'fileType' => $changeset->getFileType(),
	'commitHash' => null,
	'addLines' => $changeset->getAddLines(),
	'delLines' => $changeset->getDelLines(),
	'hunks' => $hunks,
	);
	$changes[] = $change;
	}
	return $changes;
	}

	public function getRevision() {
	return $this->assertAttached($this->revision);
	}

	public function attachRevision(DifferentialRevision $revision = null) {
	$this->revision = $revision;
	return $this;
	}

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

	public function getProperty($key) {
	return $this->assertAttachedKey($this->properties, $key);
	}


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


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

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

	return PhabricatorPolicies::POLICY_USER;
	}

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

	return false;
	}

	public function describeAutomaticCapability($capability) {
	if ($this->getRevision()) {
	return pht(
	'This diff is attached to a revision, and inherits its policies.');
	}
	return null;
	}



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


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

	public function getHarbormasterContainerPHID() {
	if ($this->getRevisionID()) {
	$revision = id(new DifferentialRevision())->load($this->getRevisionID());
	if ($revision) {
	return $revision->getPHID();
	}
	}

	return null;
	}

	}
	diff --git a/src/applications/releeph/controller/project/ReleephProductEditController.php b/src/applications/releeph/controller/project/ReleephProductEditController.php
	index b35d42ff5e..2f921db7e4 100644
	--- a/src/applications/releeph/controller/project/ReleephProductEditController.php
	+++ b/src/applications/releeph/controller/project/ReleephProductEditController.php
	@@ -1,280 +1,281 @@
	<?php

	final class ReleephProductEditController extends ReleephProductController {

	private $productID;

	public function willProcessRequest(array $data) {
	$this->productID = $data['projectID'];
	}

	public function processRequest() {
	$request = $this->getRequest();
	$viewer = $request->getUser();

	$product = id(new ReleephProjectQuery())
	->setViewer($viewer)
	->withIDs(array($this->productID))
	+ ->needArcanistProjects(true)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$product) {
	return new Aphront404Response();
	}
	$this->setProduct($product);

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

	$product_name = $request->getStr('name', $product->getName());

	$trunk_branch = $request->getStr('trunkBranch', $product->getTrunkBranch());
	$branch_template = $request->getStr('branchTemplate');
	if ($branch_template === null) {
	$branch_template = $product->getDetail('branchTemplate');
	}
	$pick_failure_instructions = $request->getStr('pickFailureInstructions',
	$product->getDetail('pick_failure_instructions'));
	$test_paths = $request->getStr('testPaths');
	if ($test_paths !== null) {
	$test_paths = array_filter(explode("\n", $test_paths));
	} else {
	$test_paths = $product->getDetail('testPaths', array());
	}

	$arc_project_id = $product->getArcanistProjectID();

	if ($request->isFormPost()) {
	$pusher_phids = $request->getArr('pushers');

	if (!$product_name) {
	$e_name = pht('Required');
	$errors[] =
	pht('Your releeph product should have a simple descriptive name.');
	}

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

	$other_releeph_products = id(new ReleephProject())
	->loadAllWhere('id != %d', $product->getID());
	$other_releeph_product_names = mpull($other_releeph_products,
	'getName', 'getID');

	if (in_array($product_name, $other_releeph_product_names)) {
	$errors[] = pht("Releeph product name %s is already taken",
	$product_name);
	}

	foreach ($test_paths as $test_path) {
	$result = @preg_match($test_path, '');
	$is_a_valid_regexp = $result !== false;
	if (!$is_a_valid_regexp) {
	$errors[] = pht('Please provide a valid regular expression: '.
	'%s is not valid', $test_path);
	}
	}

	$product
	->setTrunkBranch($trunk_branch)
	->setDetail('pushers', $pusher_phids)
	->setDetail('pick_failure_instructions', $pick_failure_instructions)
	->setDetail('branchTemplate', $branch_template)
	->setDetail('testPaths', $test_paths);

	$fake_commit_handle =
	ReleephBranchTemplate::getFakeCommitHandleFor($arc_project_id);

	if ($branch_template) {
	list($branch_name, $template_errors) = id(new ReleephBranchTemplate())
	->setCommitHandle($fake_commit_handle)
	->setReleephProjectName($product_name)
	->interpolate($branch_template);

	if ($template_errors) {
	$e_branch_template = pht('Whoopsies!');
	foreach ($template_errors as $template_error) {
	$errors[] = "Template error: {$template_error}";
	}
	}
	}

	if (!$errors) {
	$product->save();

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

	$pusher_phids = $request->getArr(
	'pushers',
	$product->getDetail('pushers', array()));

	$handles = id(new PhabricatorHandleQuery())
	->setViewer($request->getUser())
	->withPHIDs($pusher_phids)
	->execute();

	$pusher_handles = array_select_keys($handles, $pusher_phids);

	$form = id(new AphrontFormView())
	->setUser($request->getUser())
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Name'))
	->setName('name')
	->setValue($product_name)
	->setError($e_name)
	->setCaption(pht('A name like "Thrift" but not "Thrift releases".')))
	->appendChild(
	id(new AphrontFormStaticControl())
	->setLabel(pht('Repository'))
	->setValue(
	$product
	->loadPhabricatorRepository()
	->getName()))
	->appendChild(
	id(new AphrontFormStaticControl())
	->setLabel(pht('Arc Project'))
	->setValue(
	- $product->loadArcanistProject()->getName()))
	+ $product->getArcanistProject()->getName()))
	->appendChild(
	id(new AphrontFormStaticControl())
	->setLabel(pht('Releeph Project PHID'))
	->setValue(
	$product->getPHID()))
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Trunk'))
	->setValue($trunk_branch)
	->setName('trunkBranch')
	->setError($e_trunk_branch))
	->appendChild(
	id(new AphrontFormTextAreaControl())
	->setLabel(pht('Pick Instructions'))
	->setValue($pick_failure_instructions)
	->setName('pickFailureInstructions')
	->setCaption(
	pht("Instructions for pick failures, which will be used " .
	"in emails generated by failed picks")))
	->appendChild(
	id(new AphrontFormTextAreaControl())
	->setLabel(pht('Tests paths'))
	->setValue(implode("\n", $test_paths))
	->setName('testPaths')
	->setCaption(
	pht('List of strings that all test files contain in their path '.
	'in this project. One string per line. '.
	'Examples: \'__tests__\', \'/javatests/\'...')));

	$branch_template_input = id(new AphrontFormTextControl())
	->setName('branchTemplate')
	->setValue($branch_template)
	->setLabel('Branch Template')
	->setError($e_branch_template)
	->setCaption(
	pht("Leave this blank to use your installation's default."));

	$branch_template_preview = id(new ReleephBranchPreviewView())
	->setLabel(pht('Preview'))
	->addControl('template', $branch_template_input)
	->addStatic('arcProjectID', $arc_project_id)
	->addStatic('isSymbolic', false)
	->addStatic('projectName', $product->getName());

	$form
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setLabel(pht('Pushers'))
	->setName('pushers')
	->setDatasource('/typeahead/common/users/')
	->setValue($pusher_handles))
	->appendChild($branch_template_input)
	->appendChild($branch_template_preview)
	->appendRemarkupInstructions($this->getBranchHelpText());

	$form
	->appendChild(
	id(new AphrontFormSubmitControl())
	->addCancelButton('/releeph/project/')
	->setValue(pht('Save')));

	$box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Edit Releeph Product'))
	->setFormErrors($errors)
	->appendChild($form);

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

	return $this->buildStandardPageResponse(
	array(
	$crumbs,
	$box,
	),
	array(
	'title' => pht('Edit Releeph Product'),
	'device' => true,
	));
	}

	private function getBranchHelpText() {
	return <<<EOTEXT

	==== Interpolations ====

	\| Code \| Meaning
	\| ----- \| -------
	\| `%P` \| The name of your product, with spaces changed to "-".
	\| `%p` \| Like %P, but all lowercase.
	\| `%Y` \| The four digit year associated with the branch date.
	\| `%m` \| The two digit month.
	\| `%d` \| The two digit day.
	\| `%v` \| The handle of the commit where the branch was cut ("rXYZa4b3c2d1").
	\| `%V` \| The abbreviated commit id where the branch was cut ("a4b3c2d1").
	\| `%..` \| Any other sequence interpreted by `strftime()`.
	\| `%%` \| A literal percent sign.


	==== Tips for Branch Templates ====

	Use a directory to separate your release branches from other branches:

	lang=none
	releases/%Y-%M-%d-%v
	=> releases/2012-30-16-rHERGE32cd512a52b7

	Include a second hierarchy if you share your repository with other products:

	lang=none
	releases/%P/%p-release-%Y%m%d-%V
	=> releases/Tintin/tintin-release-20121116-32cd512a52b7

	Keep your branch names simple, avoiding strange punctuation, most of which is
	forbidden or escaped anyway:

	lang=none, counterexample
	releases//..clown-releases..//`date --iso=seconds`-$(sudo halt)

	Include the date early in your template, in an order which sorts properly:

	lang=none
	releases/%Y%m%d-%v
	=> releases/20121116-rHERGE32cd512a52b7 (good!)

	releases/%V-%m.%d.%Y
	=> releases/32cd512a52b7-11.16.2012 (awful!)


	EOTEXT;
	}

	}
	diff --git a/src/applications/releeph/controller/project/ReleephProductListController.php b/src/applications/releeph/controller/project/ReleephProductListController.php
	index 3651358dbe..fd8e60289e 100644
	--- a/src/applications/releeph/controller/project/ReleephProductListController.php
	+++ b/src/applications/releeph/controller/project/ReleephProductListController.php
	@@ -1,79 +1,79 @@
	<?php

	final class ReleephProductListController extends ReleephController
	implements PhabricatorApplicationSearchResultsControllerInterface {

	private $queryKey;

	public function shouldAllowPublic() {
	return true;
	}

	public function willProcessRequest(array $data) {
	$this->queryKey = idx($data, 'queryKey');
	}

	public function processRequest() {
	$request = $this->getRequest();
	$controller = id(new PhabricatorApplicationSearchController($request))
	->setQueryKey($this->queryKey)
	->setSearchEngine(new ReleephProductSearchEngine())
	->setNavigation($this->buildSideNavView());

	return $this->delegateToController($controller);
	}

	public function renderResultsList(
	array $products,
	PhabricatorSavedQuery $query) {
	assert_instances_of($products, 'ReleephProject');
	$viewer = $this->getRequest()->getUser();

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

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

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

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

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

	- $arc = $product->loadArcanistProject();
	+ $arc = $product->getArcanistProject();
	if ($arc) {
	$item->addAttribute($arc->getName());
	}

	$list->addItem($item);
	}

	return $list;
	}

	public function buildApplicationCrumbs() {
	$crumbs = parent::buildApplicationCrumbs();

	$crumbs->addAction(
	id(new PHUIListItemView())
	->setName(pht('Create Product'))
	->setHref($this->getApplicationURI('project/create/'))
	->setIcon('create'));

	return $crumbs;
	}

	}
	diff --git a/src/applications/releeph/query/ReleephProductSearchEngine.php b/src/applications/releeph/query/ReleephProductSearchEngine.php
	index 8269230c02..0d4b757069 100644
	--- a/src/applications/releeph/query/ReleephProductSearchEngine.php
	+++ b/src/applications/releeph/query/ReleephProductSearchEngine.php
	@@ -1,85 +1,86 @@
	<?php

	final class ReleephProductSearchEngine
	extends PhabricatorApplicationSearchEngine {

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

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

	return $saved;
	}

	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
	$query = id(new ReleephProjectQuery())
	- ->setOrder(ReleephProjectQuery::ORDER_NAME);
	+ ->setOrder(ReleephProjectQuery::ORDER_NAME)
	+ ->needArcanistProjects(true);

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

	return $query;
	}

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

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

	}

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

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

	return $names;
	}

	public function buildSavedQueryFromBuiltin($query_key) {

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

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

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

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

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

	}
	diff --git a/src/applications/releeph/query/ReleephProjectQuery.php b/src/applications/releeph/query/ReleephProjectQuery.php
	index 2823633499..a4fe82a45f 100644
	--- a/src/applications/releeph/query/ReleephProjectQuery.php
	+++ b/src/applications/releeph/query/ReleephProjectQuery.php
	@@ -1,134 +1,163 @@
	<?php

	final class ReleephProjectQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $active;
	private $ids;
	private $phids;

	private $needRepositories;
	+ private $needArcanistProjects;

	private $order = 'order-id';
	const ORDER_ID = 'order-id';
	const ORDER_NAME = 'order-name';

	public function withActive($active) {
	$this->active = $active;
	return $this;
	}

	public function setOrder($order) {
	$this->order = $order;
	return $this;
	}

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

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

	+ public function needArcanistProjects($need) {
	+ $this->needArcanistProjects = $need;
	+ return $this;
	+ }
	+
	public function loadPage() {
	$table = new ReleephProject();
	$conn_r = $table->establishConnection('r');

	$rows = 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($rows);
	}

	public function willFilterPage(array $projects) {
	assert_instances_of($projects, 'ReleephProject');

	$repository_phids = mpull($projects, 'getRepositoryPHID');

	$repositories = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withPHIDs($repository_phids)
	->execute();
	$repositories = mpull($repositories, null, 'getPHID');

	foreach ($projects as $key => $project) {
	$repo = idx($repositories, $project->getRepositoryPHID());
	if (!$repo) {
	unset($projects[$key]);
	continue;
	}
	$project->attachRepository($repo);
	}

	return $projects;
	}

	+ public function didFilterPage(array $products) {
	+
	+ if ($this->needArcanistProjects) {
	+ $project_ids = array_filter(mpull($products, 'getArcanistProjectID'));
	+ if ($project_ids) {
	+ $projects = id(new PhabricatorRepositoryArcanistProject())
	+ ->loadAllWhere('id IN (%Ld)', $project_ids);
	+ $projects = mpull($projects, null, 'getID');
	+ } else {
	+ $projects = array();
	+ }
	+
	+ foreach ($products as $product) {
	+ $project_id = $product->getArcanistProjectID();
	+ $project = idx($projects, $project_id);
	+ $product->attachArcanistProject($project);
	+ }
	+ }
	+
	+ return $products;
	+ }
	+
	+
	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if ($this->active !== null) {
	$where[] = qsprintf(
	$conn_r,
	'isActive = %d',
	(int)$this->active);
	}

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

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

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

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

	protected function getReversePaging() {
	switch ($this->order) {
	case self::ORDER_NAME:
	return true;
	}
	return parent::getReversePaging();
	}

	protected function getPagingValue($result) {
	switch ($this->order) {
	case self::ORDER_NAME:
	return $result->getName();
	}
	return parent::getPagingValue();
	}

	protected function getPagingColumn() {
	switch ($this->order) {
	case self::ORDER_NAME:
	return 'name';
	case self::ORDER_ID:
	return parent::getPagingColumn();
	default:
	throw new Exception("Uknown order '{$this->order}'!");
	}
	}

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

	}
	diff --git a/src/applications/releeph/storage/ReleephProject.php b/src/applications/releeph/storage/ReleephProject.php
	index 84623d24ed..989a556343 100644
	--- a/src/applications/releeph/storage/ReleephProject.php
	+++ b/src/applications/releeph/storage/ReleephProject.php
	@@ -1,139 +1,143 @@
	<?php

	final class ReleephProject extends ReleephDAO
	implements PhabricatorPolicyInterface {

	const DEFAULT_BRANCH_NAMESPACE = 'releeph-releases';
	const SYSTEM_AGENT_USERNAME_PREFIX = 'releeph-agent-';

	protected $name;

	// Specifying the place to pick from is a requirement for svn, though not
	// for git. It's always useful though for reasoning about what revs have
	// been picked and which haven't.
	protected $trunkBranch;

	protected $repositoryPHID;
	protected $isActive;
	protected $createdByUserPHID;
	protected $arcanistProjectID;

	protected $details = array();

	private $repository = self::ATTACHABLE;
	+ private $arcanistProject = self::ATTACHABLE;

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

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

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

	public function getURI($path = null) {
	$components = array(
	'/releeph/project',
	$this->getID(),
	$path
	);
	return implode('/', $components);
	}

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

	- public function loadArcanistProject() {
	- return $this->loadOneRelative(
	- new PhabricatorRepositoryArcanistProject(),
	- 'id',
	- 'getArcanistProjectID');
	+ public function getArcanistProject() {
	+ return $this->assertAttached($this->arcanistProject);
	+ }
	+
	+ public function attachArcanistProject(
	+ PhabricatorRepositoryArcanistProject $arcanist_project = null) {
	+ $this->arcanistProject = $arcanist_project;
	+ return $this;
	}

	public function getPushers() {
	return $this->getDetail('pushers', array());
	}

	public function isPusher(PhabricatorUser $user) {
	// TODO Deprecate this once `isPusher` is out of the Facebook codebase.
	return $this->isAuthoritative($user);
	}

	public function isAuthoritative(PhabricatorUser $user) {
	return $this->isAuthoritativePHID($user->getPHID());
	}

	public function isAuthoritativePHID($phid) {
	$pushers = $this->getPushers();
	if (!$pushers) {
	return true;
	} else {
	return in_array($phid, $pushers);
	}
	}

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

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

	// TODO: Remove once everything uses ProjectQuery. Also, T603.
	public function loadPhabricatorRepository() {
	return $this->loadOneRelative(
	new PhabricatorRepository(),
	'phid',
	'getRepositoryPHID');
	}

	public function getReleephFieldSelector() {
	return new ReleephDefaultFieldSelector();
	}

	public function isTestFile($filename) {
	$test_paths = $this->getDetail('testPaths', array());

	foreach ($test_paths as $test_path) {
	if (preg_match($test_path, $filename)) {
	return true;
	}
	}
	return false;
	}

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

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

	public function getPolicy($capability) {
	return PhabricatorPolicies::POLICY_USER;
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return false;
	}

	public function describeAutomaticCapability($capability) {
	return null;
	}


	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jul 29, 8:07 AM (3 w, 20 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 188332
Default Alt Text: (64 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions