No OneTemporary
Actions

Size

42 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/auth/oauth/provider/PhabricatorOAuthProviderPhabricator.php b/src/applications/auth/oauth/provider/PhabricatorOAuthProviderPhabricator.php
	index fde311a552..ee7d413b54 100644
	--- a/src/applications/auth/oauth/provider/PhabricatorOAuthProviderPhabricator.php
	+++ b/src/applications/auth/oauth/provider/PhabricatorOAuthProviderPhabricator.php
	@@ -1,131 +1,131 @@
	<?php

	final class PhabricatorOAuthProviderPhabricator
	extends PhabricatorOAuthProvider {
	private $userData;

	public function getExtraAuthParameters() {
	return array(
	'response_type' => 'code',
	);
	}

	public function getExtraTokenParameters() {
	return array(
	'grant_type' => 'authorization_code',
	);
	-
	}
	+
	public function decodeTokenResponse($response) {
	$decoded = json_decode($response, true);
	if (!is_array($decoded)) {
	throw new Exception('Invalid token response.');
	}
	return $decoded;
	}

	public function getProviderKey() {
	return self::PROVIDER_PHABRICATOR;
	}

	public function getProviderName() {
	return 'Phabricator';
	}

	public function isProviderEnabled() {
	return PhabricatorEnv::getEnvConfig('phabricator.auth-enabled');
	}

	public function isProviderLinkPermanent() {
	return PhabricatorEnv::getEnvConfig('phabricator.auth-permanent');
	}

	public function isProviderRegistrationEnabled() {
	return PhabricatorEnv::getEnvConfig('phabricator.registration-enabled');
	}

	public function getClientID() {
	return PhabricatorEnv::getEnvConfig('phabricator.application-id');
	}

	public function renderGetClientIDHelp() {
	return null;
	}

	public function getClientSecret() {
	return PhabricatorEnv::getEnvConfig('phabricator.application-secret');
	}

	public function renderGetClientSecretHelp() {
	return null;
	}

	public function getAuthURI() {
	return $this->getURI('/oauthserver/auth/');
	}

	public function getTestURIs() {
	return array(
	$this->getURI('/'),
	$this->getURI('/api/user.whoami/')
	);
	}

	public function getTokenURI() {
	return $this->getURI('/oauthserver/token/');
	}

	protected function getTokenExpiryKey() {
	return 'expires_in';
	}

	public function getUserInfoURI() {
	return $this->getURI('/api/user.whoami');
	}

	public function getMinimumScope() {
	return 'whoami';
	}

	public function setUserData($data) {
	// legacy conditionally strip shield. see D3265 for discussion.
	if (strncmp($data, 'for(;;);', 8) === 0) {
	$data = substr($data, 8);
	}
	$data = idx(json_decode($data, true), 'result');
	$this->validateUserData($data);
	$this->userData = $data;
	return $this;
	}

	public function retrieveUserID() {
	return $this->userData['phid'];
	}

	public function retrieveUserEmail() {
	return $this->userData['email'];
	}

	public function retrieveUserAccountName() {
	return $this->userData['userName'];
	}

	public function retrieveUserProfileImage() {
	$uri = $this->userData['image'];
	return HTTPSFuture::loadContent($uri);
	}

	public function retrieveUserAccountURI() {
	return $this->userData['uri'];
	}

	public function retrieveUserRealName() {
	return $this->userData['realName'];
	}

	private function getURI($path) {
	return
	rtrim(PhabricatorEnv::getEnvConfig('phabricator.oauth-uri'), '/') .
	$path;
	}
	}
	diff --git a/src/applications/differential/field/specification/DifferentialLintFieldSpecification.php b/src/applications/differential/field/specification/DifferentialLintFieldSpecification.php
	index f15f718245..aed26f056c 100644
	--- a/src/applications/differential/field/specification/DifferentialLintFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialLintFieldSpecification.php
	@@ -1,269 +1,270 @@
	<?php

	final class DifferentialLintFieldSpecification
	extends DifferentialFieldSpecification {

	public function shouldAppearOnDiffView() {
	return true;
	}

	public function renderLabelForDiffView() {
	return $this->renderLabelForRevisionView();
	}

	public function renderValueForDiffView() {
	return $this->renderValueForRevisionView();
	}
	+
	public function shouldAppearOnRevisionView() {
	return true;
	}

	public function renderLabelForRevisionView() {
	return 'Lint:';
	}

	private function getLintExcuse() {
	return $this->getDiffProperty('arc:lint-excuse');
	}

	private function getPostponedLinters() {
	return $this->getDiffProperty('arc:lint-postponed');
	}

	public function renderValueForRevisionView() {
	$diff = $this->getManualDiff();
	$path_changesets = mpull($diff->loadChangesets(), 'getID', 'getFilename');

	$lstar = DifferentialRevisionUpdateHistoryView::renderDiffLintStar($diff);
	$lmsg = DifferentialRevisionUpdateHistoryView::getDiffLintMessage($diff);
	$ldata = $this->getDiffProperty('arc:lint');
	$ltail = null;

	$rows = array();

	$rows[] = array(
	'style' => 'star',
	'name' => $lstar,
	'value' => $lmsg,
	'show' => true,
	);

	$excuse = $this->getLintExcuse();
	if ($excuse) {
	$rows[] = array(
	'style' => 'excuse',
	'name' => 'Excuse',
	'value' => phutil_escape_html_newlines($excuse),
	'show' => true,
	);
	}

	$show_limit = 10;
	$hidden = array();

	if ($ldata) {
	$ldata = igroup($ldata, 'path');
	foreach ($ldata as $path => $messages) {

	$rows[] = array(
	'style' => 'section',
	'name' => $path,
	'show' => $show_limit,
	);

	foreach ($messages as $message) {
	$path = idx($message, 'path');
	$line = idx($message, 'line');

	$code = idx($message, 'code');
	$severity = idx($message, 'severity');

	$name = idx($message, 'name');
	$description = idx($message, 'description');

	$line_link = 'line '.intval($line);
	if (isset($path_changesets[$path])) {
	$href = '#C'.$path_changesets[$path].'NL'.max(1, $line);
	if ($diff->getID() != $this->getDiff()->getID()) {
	$href = '/D'.$diff->getRevisionID().'?id='.$diff->getID().$href;
	}
	$line_link = phutil_tag(
	'a',
	array(
	'href' => $href,
	),
	$line_link);
	}

	if ($show_limit) {
	--$show_limit;
	$show = true;
	} else {
	$show = false;
	if (empty($hidden[$severity])) {
	$hidden[$severity] = 0;
	}
	$hidden[$severity]++;
	}

	$rows[] = array(
	'style' => $this->getSeverityStyle($severity),
	'name' => ucwords($severity),
	'value' => hsprintf(
	'(%s) %s at %s',
	$code,
	$name,
	$line_link),
	'show' => $show,
	);

	if (!empty($message['locations'])) {
	$locations = array();
	foreach ($message['locations'] as $location) {
	$other_line = idx($location, 'line');
	$locations[] =
	idx($location, 'path', $path).
	($other_line ? ":{$other_line}" : "");
	}
	$description .= "\nOther locations: ".implode(", ", $locations);
	}

	if (strlen($description)) {
	$rows[] = array(
	'style' => 'details',
	'value' => phutil_escape_html_newlines($description),
	'show' => false,
	);
	if (empty($hidden['details'])) {
	$hidden['details'] = 0;
	}
	$hidden['details']++;
	}
	}
	}
	}

	$postponed = $this->getPostponedLinters();
	if ($postponed) {
	foreach ($postponed as $linter) {
	$rows[] = array(
	'style' => $this->getPostponedStyle(),
	'name' => 'Postponed',
	'value' => $linter,
	'show' => false,
	);
	if (empty($hidden['postponed'])) {
	$hidden['postponed'] = 0;
	}
	$hidden['postponed']++;
	}
	}

	$show_string = $this->renderShowString($hidden);

	$view = new DifferentialResultsTableView();
	$view->setRows($rows);
	$view->setShowMoreString($show_string);

	return $view->render();
	}

	private function getSeverityStyle($severity) {
	$map = array(
	ArcanistLintSeverity::SEVERITY_ERROR => 'red',
	ArcanistLintSeverity::SEVERITY_WARNING => 'yellow',
	ArcanistLintSeverity::SEVERITY_AUTOFIX => 'yellow',
	ArcanistLintSeverity::SEVERITY_ADVICE => 'yellow',
	);
	return idx($map, $severity);
	}

	private function getPostponedStyle() {
	return 'blue';
	}

	private function renderShowString(array $hidden) {
	if (!$hidden) {
	return null;
	}

	// Reorder hidden things by severity.
	$hidden = array_select_keys(
	$hidden,
	array(
	ArcanistLintSeverity::SEVERITY_ERROR,
	ArcanistLintSeverity::SEVERITY_WARNING,
	ArcanistLintSeverity::SEVERITY_AUTOFIX,
	ArcanistLintSeverity::SEVERITY_ADVICE,
	'details',
	'postponed',
	)) + $hidden;

	$show = array();
	foreach ($hidden as $key => $value) {
	switch ($key) {
	case ArcanistLintSeverity::SEVERITY_ERROR:
	$show[] = pht('%d Error(s)', $value);
	break;
	case ArcanistLintSeverity::SEVERITY_WARNING:
	$show[] = pht('%d Warning(s)', $value);
	break;
	case ArcanistLintSeverity::SEVERITY_AUTOFIX:
	$show[] = pht('%d Auto-Fix(es)', $value);
	break;
	case ArcanistLintSeverity::SEVERITY_ADVICE:
	$show[] = pht('%d Advice(s)', $value);
	break;
	case 'details':
	$show[] = pht('%d Detail(s)', $value);
	break;
	case 'postponed':
	$show[] = pht('%d Postponed', $value);
	break;
	default:
	$show[] = $value;
	break;
	}
	}

	return "Show Full Lint Results (".implode(', ', $show).")";
	}

	public function renderWarningBoxForRevisionAccept() {
	$status = $this->getDiff()->getLintStatus();
	if ($status < DifferentialLintStatus::LINT_WARN) {
	return null;
	}

	$severity = AphrontErrorView::SEVERITY_ERROR;
	$titles = array(
	DifferentialLintStatus::LINT_WARN => 'Lint Warning',
	DifferentialLintStatus::LINT_FAIL => 'Lint Failure',
	DifferentialLintStatus::LINT_SKIP => 'Lint Skipped',
	DifferentialLintStatus::LINT_POSTPONED => 'Lint Postponed',
	);

	if ($status == DifferentialLintStatus::LINT_SKIP) {
	$content =
	"This diff was created without running lint. Make sure you are ".
	"OK with that before you accept this diff.";

	} else if ($status == DifferentialLintStatus::LINT_POSTPONED) {
	$severity = AphrontErrorView::SEVERITY_WARNING;
	$content =
	"Postponed linters didn't finish yet. Make sure you are OK with ".
	"that before you accept this diff.";

	} else {
	$content =
	"This diff has Lint Problems. Make sure you are OK with them ".
	"before you accept this diff.";
	}

	return id(new AphrontErrorView())
	->setSeverity($severity)
	->appendChild(phutil_tag('p', array(), $content))
	->setTitle(idx($titles, $status, 'Warning'));
	}

	}
	diff --git a/src/applications/feed/PhabricatorFeedStoryPublisher.php b/src/applications/feed/PhabricatorFeedStoryPublisher.php
	index 9c26feab7a..4999a35a35 100644
	--- a/src/applications/feed/PhabricatorFeedStoryPublisher.php
	+++ b/src/applications/feed/PhabricatorFeedStoryPublisher.php
	@@ -1,218 +1,219 @@
	<?php

	final class PhabricatorFeedStoryPublisher {

	private $relatedPHIDs;
	private $storyType;
	private $storyData;
	private $storyTime;
	private $storyAuthorPHID;
	private $primaryObjectPHID;
	private $subscribedPHIDs = array();
	private $mailRecipientPHIDs = array();

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

	public function setSubscribedPHIDs(array $phids) {
	$this->subscribedPHIDs = $phids;
	return $this;
	}
	+
	public function setPrimaryObjectPHID($phid) {
	$this->primaryObjectPHID = $phid;
	return $this;
	}

	public function setStoryType($story_type) {
	$this->storyType = $story_type;
	return $this;
	}

	public function setStoryData(array $data) {
	$this->storyData = $data;
	return $this;
	}

	public function setStoryTime($time) {
	$this->storyTime = $time;
	return $this;
	}

	public function setStoryAuthorPHID($phid) {
	$this->storyAuthorPHID = $phid;
	return $this;
	}

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

	public function publish() {
	$class = $this->storyType;
	if (!$class) {
	throw new Exception("Call setStoryType() before publishing!");
	}

	if (!class_exists($class)) {
	throw new Exception(
	"Story type must be a valid class name and must subclass ".
	"PhabricatorFeedStory. ".
	"'{$class}' is not a loadable class.");
	}

	if (!is_subclass_of($class, 'PhabricatorFeedStory')) {
	throw new Exception(
	"Story type must be a valid class name and must subclass ".
	"PhabricatorFeedStory. ".
	"'{$class}' is not a subclass of PhabricatorFeedStory.");
	}

	$chrono_key = $this->generateChronologicalKey();

	$story = new PhabricatorFeedStoryData();
	$story->setStoryType($this->storyType);
	$story->setStoryData($this->storyData);
	$story->setAuthorPHID((string)$this->storyAuthorPHID);
	$story->setChronologicalKey($chrono_key);
	$story->save();

	if ($this->relatedPHIDs) {
	$ref = new PhabricatorFeedStoryReference();

	$sql = array();
	$conn = $ref->establishConnection('w');
	foreach (array_unique($this->relatedPHIDs) as $phid) {
	$sql[] = qsprintf(
	$conn,
	'(%s, %s)',
	$phid,
	$chrono_key);
	}

	queryfx(
	$conn,
	'INSERT INTO %T (objectPHID, chronologicalKey) VALUES %Q',
	$ref->getTableName(),
	implode(', ', $sql));
	}

	$this->insertNotifications($chrono_key);
	if (PhabricatorEnv::getEnvConfig('notification.enabled')) {
	$this->sendNotification($chrono_key);
	}

	$uris = PhabricatorEnv::getEnvConfig('feed.http-hooks');
	foreach ($uris as $uri) {
	$task = PhabricatorWorker::scheduleTask(
	'FeedPublisherWorker',
	array('chrono_key' => $chrono_key, 'uri' => $uri));
	}

	return $story;
	}

	private function insertNotifications($chrono_key) {
	$subscribed_phids = $this->subscribedPHIDs;
	$subscribed_phids = array_diff(
	$subscribed_phids,
	array($this->storyAuthorPHID));

	if (!$subscribed_phids) {
	return;
	}

	if (!$this->primaryObjectPHID) {
	throw new Exception(
	"You must call setPrimaryObjectPHID() if you setSubscribedPHIDs()!");
	}

	$notif = new PhabricatorFeedStoryNotification();
	$sql = array();
	$conn = $notif->establishConnection('w');

	$will_receive_mail = array_fill_keys($this->mailRecipientPHIDs, true);

	foreach (array_unique($subscribed_phids) as $user_phid) {
	if (isset($will_receive_mail[$user_phid])) {
	$mark_read = 1;
	} else {
	$mark_read = 0;
	}

	$sql[] = qsprintf(
	$conn,
	'(%s, %s, %s, %d)',
	$this->primaryObjectPHID,
	$user_phid,
	$chrono_key,
	$mark_read);
	}

	queryfx(
	$conn,
	'INSERT INTO %T
	(primaryObjectPHID, userPHID, chronologicalKey, hasViewed)
	VALUES %Q',
	$notif->getTableName(),
	implode(', ', $sql));
	}

	private function sendNotification($chrono_key) {
	$server_uri = PhabricatorEnv::getEnvConfig('notification.server-uri');

	$data = array(
	'key' => (string)$chrono_key,
	);

	id(new HTTPSFuture($server_uri, $data))
	->setMethod('POST')
	->setTimeout(1)
	->resolve();
	}

	/**
	* We generate a unique chronological key for each story type because we want
	* to be able to page through the stream with a cursor (i.e., select stories
	* after ID = X) so we can efficiently perform filtering after selecting data,
	* and multiple stories with the same ID make this cumbersome without putting
	* a bunch of logic in the client. We could use the primary key, but that
	* would prevent publishing stories which happened in the past. Since it's
	* potentially useful to do that (e.g., if you're importing another data
	* source) build a unique key for each story which has chronological ordering.
	*
	* @return string A unique, time-ordered key which identifies the story.
	*/
	private function generateChronologicalKey() {
	// Use the epoch timestamp for the upper 32 bits of the key. Default to
	// the current time if the story doesn't have an explicit timestamp.
	$time = nonempty($this->storyTime, time());

	// Generate a random number for the lower 32 bits of the key.
	$rand = head(unpack('L', Filesystem::readRandomBytes(4)));

	// On 32-bit machines, we have to get creative.
	if (PHP_INT_SIZE < 8) {
	// We're on a 32-bit machine.
	if (function_exists('bcadd')) {
	// Try to use the 'bc' extension.
	return bcadd(bcmul($time, bcpow(2, 32)), $rand);
	} else {
	// Do the math in MySQL. TODO: If we formalize a bc dependency, get
	// rid of this.
	$conn_r = id(new PhabricatorFeedStoryData())->establishConnection('r');
	$result = queryfx_one(
	$conn_r,
	'SELECT (%d << 32) + %d as N',
	$time,
	$rand);
	return $result['N'];
	}
	} else {
	// This is a 64 bit machine, so we can just do the math.
	return ($time << 32) + $rand;
	}
	}
	}
	diff --git a/src/applications/owners/controller/PhabricatorOwnersController.php b/src/applications/owners/controller/PhabricatorOwnersController.php
	index 2bc82f2086..51df5fc638 100644
	--- a/src/applications/owners/controller/PhabricatorOwnersController.php
	+++ b/src/applications/owners/controller/PhabricatorOwnersController.php
	@@ -1,76 +1,77 @@
	<?php

	abstract class PhabricatorOwnersController extends PhabricatorController {

	private $filter;

	private function getSideNavFilter() {
	return $this->filter;
	}
	protected function setSideNavFilter($filter) {
	$this->filter = $filter;
	return $this;
	}
	+
	public function buildStandardPageResponse($view, array $data) {

	$page = $this->buildStandardPageView();

	$page->setApplicationName('Owners');
	$page->setBaseURI('/owners/');
	$page->setTitle(idx($data, 'title'));
	$page->setGlyph("\xE2\x98\x81");
	$nav = $this->renderSideNav();
	$nav->appendChild($view);
	$page->appendChild($nav);

	$filter = $nav->getSelectedFilter();
	switch ($filter) {
	case 'view/owned':
	case 'view/all':
	$crumbs = $this->buildApplicationCrumbs();

	if ($filter == 'view/owned') {
	$title = pht('Owned Packages');
	} else {
	$title = pht('All Packages');
	}

	$crumbs->addCrumb(
	id(new PhabricatorCrumbView())
	->setName($title));

	$crumbs->addAction(
	id(new PhabricatorMenuItemView())
	->setName(pht('Create Package'))
	->setHref('/owners/new/')
	->setIcon('create'));

	$nav->setCrumbs($crumbs);
	break;
	}

	$response = new AphrontWebpageResponse();
	return $response->setContent($page->render());
	}

	public function renderSideNav() {
	$nav = new AphrontSideNavFilterView();
	$base_uri = new PhutilURI('/owners/');
	$nav->setBaseURI($base_uri);

	$nav->addLabel('Packages');
	$this->getExtraPackageViews($nav);
	$nav->addFilter('view/owned', 'Owned');
	$nav->addFilter('view/projects', 'Projects');
	$nav->addFilter('view/all', 'All');

	$nav->selectFilter($this->getSideNavFilter(), 'view/owned');

	return $nav;
	}

	protected function getExtraPackageViews(AphrontSideNavFilterView $view) {
	return;
	}

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepository.php b/src/applications/repository/storage/PhabricatorRepository.php
	index 56c06b5456..2623eae213 100644
	--- a/src/applications/repository/storage/PhabricatorRepository.php
	+++ b/src/applications/repository/storage/PhabricatorRepository.php
	@@ -1,711 +1,711 @@
	<?php

	/**
	* @task uri Repository URI Management
	*/
	final class PhabricatorRepository extends PhabricatorRepositoryDAO
	implements PhabricatorPolicyInterface {

	/**
	* Shortest hash we'll recognize in raw "a829f32" form.
	*/
	const MINIMUM_UNQUALIFIED_HASH = 7;

	/**
	* Shortest hash we'll recognize in qualified "rXab7ef2f8" form.
	*/
	const MINIMUM_QUALIFIED_HASH = 5;

	const TABLE_PATH = 'repository_path';
	const TABLE_PATHCHANGE = 'repository_pathchange';
	const TABLE_FILESYSTEM = 'repository_filesystem';
	const TABLE_SUMMARY = 'repository_summary';
	const TABLE_BADCOMMIT = 'repository_badcommit';
	const TABLE_LINTMESSAGE = 'repository_lintmessage';

	protected $phid;
	protected $name;
	protected $callsign;
	protected $uuid;

	protected $versionControlSystem;
	protected $details = array();

	private $sshKeyfile;

	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(
	PhabricatorPHIDConstants::PHID_TYPE_REPO);
	}

	public function toDictionary() {
	return array(
	'name' => $this->getName(),
	'phid' => $this->getPHID(),
	'callsign' => $this->getCallsign(),
	'vcs' => $this->getVersionControlSystem(),
	'uri' => PhabricatorEnv::getProductionURI($this->getURI()),
	'remoteURI' => (string)$this->getPublicRemoteURI(),
	'tracking' => $this->getDetail('tracking-enabled'),
	'description' => $this->getDetail('description'),
	);
	}

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

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

	public function getDiffusionBrowseURIForPath($path,
	$line = null,
	$branch = null) {
	$drequest = DiffusionRequest::newFromDictionary(
	array(
	'repository' => $this,
	'path' => $path,
	'branch' => $branch,
	));

	return $drequest->generateURI(
	array(
	'action' => 'browse',
	'line' => $line,
	));
	}

	public function getLocalPath() {
	return $this->getDetail('local-path');
	}

	public function execRemoteCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	$args = $this->formatRemoteCommand($args);
	return call_user_func_array('exec_manual', $args);
	}

	public function execxRemoteCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	$args = $this->formatRemoteCommand($args);
	return call_user_func_array('execx', $args);
	}

	public function getRemoteCommandFuture($pattern /* , $arg, ... */) {
	$args = func_get_args();
	$args = $this->formatRemoteCommand($args);
	return newv('ExecFuture', $args);
	}

	public function passthruRemoteCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	$args = $this->formatRemoteCommand($args);
	return call_user_func_array('phutil_passthru', $args);
	}

	public function execLocalCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	$args = $this->formatLocalCommand($args);
	return call_user_func_array('exec_manual', $args);
	}

	public function execxLocalCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	$args = $this->formatLocalCommand($args);
	return call_user_func_array('execx', $args);
	}

	public function getLocalCommandFuture($pattern /* , $arg, ... */) {
	$args = func_get_args();
	$args = $this->formatLocalCommand($args);
	return newv('ExecFuture', $args);
	-
	}
	+
	public function passthruLocalCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	$args = $this->formatLocalCommand($args);
	return call_user_func_array('phutil_passthru', $args);
	}


	private function formatRemoteCommand(array $args) {
	$pattern = $args[0];
	$args = array_slice($args, 1);

	if ($this->shouldUseSSH()) {
	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$pattern = "SVN_SSH=%s svn --non-interactive {$pattern}";
	array_unshift(
	$args,
	csprintf(
	'ssh -l %s -i %s',
	$this->getSSHLogin(),
	$this->getSSHKeyfile()));
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$command = call_user_func_array(
	'csprintf',
	array_merge(
	array(
	"(ssh-add %s && git {$pattern})",
	$this->getSSHKeyfile(),
	),
	$args));
	$pattern = "ssh-agent sh -c %s";
	$args = array($command);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$pattern = "hg --config ui.ssh=%s {$pattern}";
	array_unshift(
	$args,
	csprintf(
	'ssh -l %s -i %s',
	$this->getSSHLogin(),
	$this->getSSHKeyfile()));
	break;
	default:
	throw new Exception("Unrecognized version control system.");
	}
	} else if ($this->shouldUseHTTP()) {
	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$pattern =
	"svn ".
	"--non-interactive ".
	"--no-auth-cache ".
	"--trust-server-cert ".
	"--username %s ".
	"--password %s ".
	$pattern;
	array_unshift(
	$args,
	$this->getDetail('http-login'),
	$this->getDetail('http-pass'));
	break;
	default:
	throw new Exception(
	"No support for HTTP Basic Auth in this version control system.");
	}
	} else if ($this->shouldUseSVNProtocol()) {
	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$pattern =
	"svn ".
	"--non-interactive ".
	"--no-auth-cache ".
	"--username %s ".
	"--password %s ".
	$pattern;
	array_unshift(
	$args,
	$this->getDetail('http-login'),
	$this->getDetail('http-pass'));
	break;
	default:
	throw new Exception(
	"SVN protocol is SVN only.");
	}
	} else {
	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$pattern = "svn --non-interactive {$pattern}";
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$pattern = "git {$pattern}";
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$pattern = "hg {$pattern}";
	break;
	default:
	throw new Exception("Unrecognized version control system.");
	}
	}

	array_unshift($args, $pattern);

	return $args;
	}

	private function formatLocalCommand(array $args) {
	$pattern = $args[0];
	$args = array_slice($args, 1);

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$pattern = "(cd %s && svn --non-interactive {$pattern})";
	array_unshift($args, $this->getLocalPath());
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$pattern = "(cd %s && git {$pattern})";
	array_unshift($args, $this->getLocalPath());
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$pattern = "(cd %s && HGPLAIN=1 hg {$pattern})";
	array_unshift($args, $this->getLocalPath());
	break;
	default:
	throw new Exception("Unrecognized version control system.");
	}

	array_unshift($args, $pattern);

	return $args;
	}

	private function getSSHLogin() {
	return $this->getDetail('ssh-login');
	}

	private function getSSHKeyfile() {
	if ($this->sshKeyfile === null) {
	$key = $this->getDetail('ssh-key');
	$keyfile = $this->getDetail('ssh-keyfile');
	if ($keyfile) {
	// Make sure we can read the file, that it exists, etc.
	Filesystem::readFile($keyfile);
	$this->sshKeyfile = $keyfile;
	} else if ($key) {
	$keyfile = new TempFile('phabricator-repository-ssh-key');
	chmod($keyfile, 0600);
	Filesystem::writeFile($keyfile, $key);
	$this->sshKeyfile = $keyfile;
	} else {
	$this->sshKeyfile = '';
	}
	}

	return (string)$this->sshKeyfile;
	}

	public function getURI() {
	return '/diffusion/'.$this->getCallsign().'/';
	}

	public function isTracked() {
	return $this->getDetail('tracking-enabled', false);
	}

	public function getDefaultBranch() {
	$default = $this->getDetail('default-branch');
	if (strlen($default)) {
	return $default;
	}

	$default_branches = array(
	PhabricatorRepositoryType::REPOSITORY_TYPE_GIT => 'master',
	PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL => 'default',
	);

	return idx($default_branches, $this->getVersionControlSystem());
	}

	public function getDefaultArcanistBranch() {
	return coalesce($this->getDefaultBranch(), 'svn');
	}

	private function isBranchInFilter($branch, $filter_key) {
	$vcs = $this->getVersionControlSystem();

	$is_git = ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);

	$use_filter = ($is_git);

	if ($use_filter) {
	$filter = $this->getDetail($filter_key, array());
	if ($filter && empty($filter[$branch])) {
	return false;
	}
	}

	// By default, all branches pass.
	return true;
	}

	public function shouldTrackBranch($branch) {
	return $this->isBranchInFilter($branch, 'branch-filter');
	}

	public function shouldAutocloseBranch($branch) {
	if ($this->getDetail('disable-autoclose', false)) {
	return false;
	}

	return $this->isBranchInFilter($branch, 'close-commits-filter');
	}

	public function shouldAutocloseCommit(
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data) {

	if ($this->getDetail('disable-autoclose', false)) {
	return false;
	}

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	return true;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	return true;
	default:
	throw new Exception("Unrecognized version control system.");
	}

	$branches = $data->getCommitDetail('seenOnBranches', array());
	foreach ($branches as $branch) {
	if ($this->shouldAutocloseBranch($branch)) {
	return true;
	}
	}

	return false;
	}

	public function formatCommitName($commit_identifier) {
	$vcs = $this->getVersionControlSystem();

	$type_git = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
	$type_hg = PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL;

	$is_git = ($vcs == $type_git);
	$is_hg = ($vcs == $type_hg);
	if ($is_git \|\| $is_hg) {
	$short_identifier = substr($commit_identifier, 0, 12);
	} else {
	$short_identifier = $commit_identifier;
	}

	return 'r'.$this->getCallsign().$short_identifier;
	}

	public static function loadAllByPHIDOrCallsign(array $names) {
	$repositories = array();
	foreach ($names as $name) {
	$repo = id(new PhabricatorRepository())->loadOneWhere(
	'phid = %s OR callsign = %s',
	$name,
	$name);
	if (!$repo) {
	throw new Exception(
	"No repository with PHID or callsign '{$name}' exists!");
	}
	$repositories[$repo->getID()] = $repo;
	}
	return $repositories;
	}

	/* -( Repository URI Management )------------------------------------------ */


	/**
	* Get the remote URI for this repository.
	*
	* @return string
	* @task uri
	*/
	public function getRemoteURI() {
	return (string)$this->getRemoteURIObject();
	}


	/**
	* Get the remote URI for this repository, without authentication information.
	*
	* @return string Repository URI.
	* @task uri
	*/
	public function getPublicRemoteURI() {
	$uri = $this->getRemoteURIObject();

	// Make sure we don't leak anything if this repo is using HTTP Basic Auth
	// with the credentials in the URI or something zany like that.

	if ($uri instanceof PhutilGitURI) {
	if (!$this->getDetail('show-user', false)) {
	$uri->setUser(null);
	}
	} else {
	if (!$this->getDetail('show-user', false)) {
	$uri->setUser(null);
	}
	$uri->setPass(null);
	}

	return (string)$uri;
	}


	/**
	* Get the protocol for the repository's remote.
	*
	* @return string Protocol, like "ssh" or "git".
	* @task uri
	*/
	public function getRemoteProtocol() {
	$uri = $this->getRemoteURIObject();

	if ($uri instanceof PhutilGitURI) {
	return 'ssh';
	} else {
	return $uri->getProtocol();
	}
	}


	/**
	* Get a parsed object representation of the repository's remote URI. This
	* may be a normal URI (returned as a @{class@libphutil:PhutilURI}) or a git
	* URI (returned as a @{class@libphutil:PhutilGitURI}).
	*
	* @return wild A @{class@libphutil:PhutilURI} or
	* @{class@libphutil:PhutilGitURI}.
	* @task uri
	*/
	private function getRemoteURIObject() {
	$raw_uri = $this->getDetail('remote-uri');
	if (!$raw_uri) {
	return new PhutilURI('');
	}

	if (!strncmp($raw_uri, '/', 1)) {
	return new PhutilURI('file://'.$raw_uri);
	}

	$uri = new PhutilURI($raw_uri);
	if ($uri->getProtocol()) {
	if ($this->isSSHProtocol($uri->getProtocol())) {
	if ($this->getSSHLogin()) {
	$uri->setUser($this->getSSHLogin());
	}
	}
	return $uri;
	}

	$uri = new PhutilGitURI($raw_uri);
	if ($uri->getDomain()) {
	if ($this->getSSHLogin()) {
	$uri->setUser($this->getSSHLogin());
	}
	return $uri;
	}

	throw new Exception("Remote URI '{$raw_uri}' could not be parsed!");
	}


	/**
	* Determine if we should connect to the remote using SSH flags and
	* credentials.
	*
	* @return bool True to use the SSH protocol.
	* @task uri
	*/
	private function shouldUseSSH() {
	$protocol = $this->getRemoteProtocol();
	if ($this->isSSHProtocol($protocol)) {
	return (bool)$this->getSSHKeyfile();
	} else {
	return false;
	}
	}


	/**
	* Determine if we should connect to the remote using HTTP flags and
	* credentials.
	*
	* @return bool True to use the HTTP protocol.
	* @task uri
	*/
	private function shouldUseHTTP() {
	$protocol = $this->getRemoteProtocol();
	if ($protocol == 'http' \|\| $protocol == 'https') {
	return (bool)$this->getDetail('http-login');
	} else {
	return false;
	}
	}


	/**
	* Determine if we should connect to the remote using SVN flags and
	* credentials.
	*
	* @return bool True to use the SVN protocol.
	* @task uri
	*/
	private function shouldUseSVNProtocol() {
	$protocol = $this->getRemoteProtocol();
	if ($protocol == 'svn') {
	return (bool)$this->getDetail('http-login');
	} else {
	return false;
	}
	}


	/**
	* Determine if a protocol is SSH or SSH-like.
	*
	* @param string A protocol string, like "http" or "ssh".
	* @return bool True if the protocol is SSH-like.
	* @task uri
	*/
	private function isSSHProtocol($protocol) {
	return ($protocol == 'ssh' \|\| $protocol == 'svn+ssh');
	}

	public function delete() {
	$this->openTransaction();

	$paths = id(new PhabricatorOwnersPath())
	->loadAllWhere('repositoryPHID = %s', $this->getPHID());
	foreach ($paths as $path) {
	$path->delete();
	}

	$projects = id(new PhabricatorRepositoryArcanistProject())
	->loadAllWhere('repositoryID = %d', $this->getID());
	foreach ($projects as $project) {
	// note each project deletes its PhabricatorRepositorySymbols
	$project->delete();
	}

	$commits = id(new PhabricatorRepositoryCommit())
	->loadAllWhere('repositoryID = %d', $this->getID());
	foreach ($commits as $commit) {
	// note PhabricatorRepositoryAuditRequests and
	// PhabricatorRepositoryCommitData are deleted here too.
	$commit->delete();
	}

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

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d',
	self::TABLE_FILESYSTEM,
	$this->getID());

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d',
	self::TABLE_PATHCHANGE,
	$this->getID());

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d',
	self::TABLE_SUMMARY,
	$this->getID());

	$result = parent::delete();

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

	public function isGit() {
	$vcs = $this->getVersionControlSystem();
	return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
	}

	public function isSVN() {
	$vcs = $this->getVersionControlSystem();
	return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_SVN);
	}

	public function isHg() {
	$vcs = $this->getVersionControlSystem();
	return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL);
	}


	/**
	* Link external bug tracking system if defined.
	*
	* @param string Plain text.
	* @param string Commit identifier.
	* @return string Remarkup
	*/
	public function linkBugtraq($message, $revision = null) {
	$bugtraq_url = PhabricatorEnv::getEnvConfig('bugtraq.url');
	list($bugtraq_re, $id_re) =
	PhabricatorEnv::getEnvConfig('bugtraq.logregex') +
	array('', '');

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// TODO: Get bugtraq:logregex and bugtraq:url from SVN properties.
	break;
	}

	if (!$bugtraq_url \|\| $bugtraq_re == '') {
	return $message;
	}

	$matches = null;
	$flags = PREG_SET_ORDER \| PREG_OFFSET_CAPTURE;
	preg_match_all('('.$bugtraq_re.')', $message, $matches, $flags);
	foreach ($matches as $match) {
	list($all, $all_offset) = array_shift($match);

	if ($id_re != '') {
	// Match substrings with bug IDs
	preg_match_all('('.$id_re.')', $all, $match, PREG_OFFSET_CAPTURE);
	list(, $match) = $match;
	} else {
	$all_offset = 0;
	}

	foreach ($match as $val) {
	list($s, $offset) = $val;
	$message = substr_replace(
	$message,
	'[[ '.str_replace('%BUGID%', $s, $bugtraq_url).' \| '.$s.' ]]',
	$offset + $all_offset,
	strlen($s));
	}
	}

	return $message;
	}


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


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

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicies::POLICY_USER;
	case PhabricatorPolicyCapability::CAN_EDIT:
	return PhabricatorPolicies::POLICY_ADMIN;
	}
	}

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

	}
	diff --git a/src/view/form/control/AphrontFormTextControl.php b/src/view/form/control/AphrontFormTextControl.php
	index 7ba47a5728..78078fd949 100644
	--- a/src/view/form/control/AphrontFormTextControl.php
	+++ b/src/view/form/control/AphrontFormTextControl.php
	@@ -1,41 +1,42 @@
	<?php

	final class AphrontFormTextControl extends AphrontFormControl {

	private $disableAutocomplete;
	private $sigil;

	public function setDisableAutocomplete($disable) {
	$this->disableAutocomplete = $disable;
	return $this;
	}
	private function getDisableAutocomplete() {
	return $this->disableAutocomplete;
	}
	+
	public function getSigil() {
	return $this->sigil;
	}
	public function setSigil($sigil) {
	$this->sigil = $sigil;
	return $this;
	}

	protected function getCustomControlClass() {
	return 'aphront-form-control-text';
	}

	protected function renderInput() {
	return javelin_tag(
	'input',
	array(
	'type' => 'text',
	'name' => $this->getName(),
	'value' => $this->getValue(),
	'disabled' => $this->getDisabled() ? 'disabled' : null,
	'autocomplete' => $this->getDisableAutocomplete() ? 'off' : null,
	'id' => $this->getID(),
	'sigil' => $this->getSigil(),
	));
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Mar 16, 10:25 PM (19 h, 2 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 963441
Default Alt Text: (42 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions