diff --git a/src/applications/almanac/controller/AlmanacController.php b/src/applications/almanac/controller/AlmanacController.php
index 24a8986766..7fad62a509 100644
--- a/src/applications/almanac/controller/AlmanacController.php
+++ b/src/applications/almanac/controller/AlmanacController.php
@@ -1,215 +1,209 @@
 <?php
 
 abstract class AlmanacController
   extends PhabricatorController {
 
   protected function buildAlmanacPropertiesTable(
     AlmanacPropertyInterface $object) {
 
     $viewer = $this->getViewer();
     $properties = $object->getAlmanacProperties();
 
     $this->requireResource('almanac-css');
     Javelin::initBehavior('phabricator-tooltips', array());
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $object,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $properties = $object->getAlmanacProperties();
 
     $icon_builtin = id(new PHUIIconView())
       ->setIcon('fa-circle')
       ->addSigil('has-tooltip')
       ->setMetadata(
         array(
           'tip' => pht('Builtin Property'),
           'align' => 'E',
         ));
 
     $icon_custom = id(new PHUIIconView())
       ->setIcon('fa-circle-o grey')
       ->addSigil('has-tooltip')
       ->setMetadata(
         array(
           'tip' => pht('Custom Property'),
           'align' => 'E',
         ));
 
     $builtins = $object->getAlmanacPropertyFieldSpecifications();
     $defaults = mpull($builtins, 'getValueForTransaction');
 
     // Sort fields so builtin fields appear first, then fields are ordered
     // alphabetically.
     $properties = msort($properties, 'getFieldName');
 
     $head = array();
     $tail = array();
     foreach ($properties as $property) {
       $key = $property->getFieldName();
       if (isset($builtins[$key])) {
         $head[$key] = $property;
       } else {
         $tail[$key] = $property;
       }
     }
 
     $properties = $head + $tail;
 
     $delete_base = $this->getApplicationURI('property/delete/');
     $edit_base = $this->getApplicationURI('property/update/');
 
     $rows = array();
     foreach ($properties as $key => $property) {
       $value = $property->getFieldValue();
 
       $is_builtin = isset($builtins[$key]);
       $is_persistent = (bool)$property->getID();
 
-      $delete_uri = id(new PhutilURI($delete_base))
-        ->setQueryParams(
-          array(
-            'key' => $key,
-            'objectPHID' => $object->getPHID(),
-          ));
+      $params = array(
+        'key' => $key,
+        'objectPHID' => $object->getPHID(),
+      );
 
-      $edit_uri = id(new PhutilURI($edit_base))
-        ->setQueryParams(
-          array(
-            'key' => $key,
-            'objectPHID' => $object->getPHID(),
-          ));
+      $delete_uri = new PhutilURI($delete_base, $params);
+      $edit_uri = new PhutilURI($edit_base, $params);
 
       $delete = javelin_tag(
         'a',
         array(
           'class' => (($can_edit && $is_persistent)
             ? 'button button-grey small'
             : 'button button-grey small disabled'),
           'sigil' => 'workflow',
           'href' => $delete_uri,
         ),
         $is_builtin ? pht('Reset') : pht('Delete'));
 
       $default = idx($defaults, $key);
       $is_default = ($default !== null && $default === $value);
 
       $display_value = PhabricatorConfigJSON::prettyPrintJSON($value);
       if ($is_default) {
         $display_value = phutil_tag(
           'span',
           array(
             'class' => 'almanac-default-property-value',
           ),
           $display_value);
       }
 
       $display_key = $key;
       if ($can_edit) {
         $display_key = javelin_tag(
           'a',
           array(
             'href' => $edit_uri,
             'sigil' => 'workflow',
           ),
           $display_key);
       }
 
       $rows[] = array(
         ($is_builtin ? $icon_builtin : $icon_custom),
         $display_key,
         $display_value,
         $delete,
       );
     }
 
     $table = id(new AphrontTableView($rows))
       ->setNoDataString(pht('No properties.'))
       ->setHeaders(
         array(
           null,
           pht('Name'),
           pht('Value'),
           null,
         ))
       ->setColumnClasses(
         array(
           null,
           null,
           'wide',
           'action',
         ));
 
     $phid = $object->getPHID();
     $add_uri = id(new PhutilURI($edit_base))
       ->setQueryParam('objectPHID', $object->getPHID());
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $object,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $add_button = id(new PHUIButtonView())
       ->setTag('a')
       ->setHref($add_uri)
       ->setWorkflow(true)
       ->setDisabled(!$can_edit)
       ->setText(pht('Add Property'))
       ->setIcon('fa-plus');
 
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('Properties'))
       ->addActionLink($add_button);
 
     return id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->setTable($table);
   }
 
   protected function addClusterMessage(
     $positive,
     $negative) {
 
     $can_manage = $this->hasApplicationCapability(
       AlmanacManageClusterServicesCapability::CAPABILITY);
 
     $doc_link = phutil_tag(
       'a',
       array(
         'href' => PhabricatorEnv::getDoclink(
           'Clustering Introduction'),
         'target' => '_blank',
       ),
       pht('Learn More'));
 
     if ($can_manage) {
       $severity = PHUIInfoView::SEVERITY_NOTICE;
       $message = $positive;
     } else {
       $severity = PHUIInfoView::SEVERITY_WARNING;
       $message = $negative;
     }
 
     $icon = id(new PHUIIconView())
       ->setIcon('fa-sitemap');
 
     return id(new PHUIInfoView())
       ->setSeverity($severity)
       ->setErrors(
         array(
           array($icon, ' ', $message, ' ', $doc_link),
         ));
 
   }
 
   protected function getPropertyDeleteURI($object) {
     return null;
   }
 
   protected function getPropertyUpdateURI($object) {
     return null;
   }
 
 }
diff --git a/src/applications/auth/controller/PhabricatorAuthOneTimeLoginController.php b/src/applications/auth/controller/PhabricatorAuthOneTimeLoginController.php
index 26f8785c0a..353f31562c 100644
--- a/src/applications/auth/controller/PhabricatorAuthOneTimeLoginController.php
+++ b/src/applications/auth/controller/PhabricatorAuthOneTimeLoginController.php
@@ -1,247 +1,247 @@
 <?php
 
 final class PhabricatorAuthOneTimeLoginController
   extends PhabricatorAuthController {
 
   public function shouldRequireLogin() {
     return false;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $this->getViewer();
     $id = $request->getURIData('id');
     $link_type = $request->getURIData('type');
     $key = $request->getURIData('key');
     $email_id = $request->getURIData('emailID');
 
     $target_user = id(new PhabricatorPeopleQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withIDs(array($id))
       ->executeOne();
     if (!$target_user) {
       return new Aphront404Response();
     }
 
     // NOTE: We allow you to use a one-time login link for your own current
     // login account. This supports the "Set Password" flow.
 
     $is_logged_in = false;
     if ($viewer->isLoggedIn()) {
       if ($viewer->getPHID() !== $target_user->getPHID()) {
         return $this->renderError(
           pht('You are already logged in.'));
       } else {
         $is_logged_in = true;
       }
     }
 
     // NOTE: As a convenience to users, these one-time login URIs may also
     // be associated with an email address which will be verified when the
     // URI is used.
 
     // This improves the new user experience for users receiving "Welcome"
     // emails on installs that require verification: if we did not verify the
     // email, they'd immediately get roadblocked with a "Verify Your Email"
     // error and have to go back to their email account, wait for a
     // "Verification" email, and then click that link to actually get access to
     // their account. This is hugely unwieldy, and if the link was only sent
     // to the user's email in the first place we can safely verify it as a
     // side effect of login.
 
     // The email hashed into the URI so users can't verify some email they
     // do not own by doing this:
     //
     //  - Add some address you do not own;
     //  - request a password reset;
     //  - change the URI in the email to the address you don't own;
     //  - login via the email link; and
     //  - get a "verified" address you don't control.
 
     $target_email = null;
     if ($email_id) {
       $target_email = id(new PhabricatorUserEmail())->loadOneWhere(
         'userPHID = %s AND id = %d',
         $target_user->getPHID(),
         $email_id);
       if (!$target_email) {
         return new Aphront404Response();
       }
     }
 
     $engine = new PhabricatorAuthSessionEngine();
     $token = $engine->loadOneTimeLoginKey(
       $target_user,
       $target_email,
       $key);
 
     if (!$token) {
       return $this->newDialog()
         ->setTitle(pht('Unable to Log In'))
         ->setShortTitle(pht('Login Failure'))
         ->appendParagraph(
           pht(
             'The login link you clicked is invalid, out of date, or has '.
             'already been used.'))
         ->appendParagraph(
           pht(
             'Make sure you are copy-and-pasting the entire link into '.
             'your browser. Login links are only valid for 24 hours, and '.
             'can only be used once.'))
         ->appendParagraph(
           pht('You can try again, or request a new link via email.'))
         ->addCancelButton('/login/email/', pht('Send Another Email'));
     }
 
     if (!$target_user->canEstablishWebSessions()) {
       return $this->newDialog()
         ->setTitle(pht('Unable to Establish Web Session'))
         ->setShortTitle(pht('Login Failure'))
         ->appendParagraph(
           pht(
             'You are trying to gain access to an account ("%s") that can not '.
             'establish a web session.',
             $target_user->getUsername()))
         ->appendParagraph(
           pht(
             'Special users like daemons and mailing lists are not permitted '.
             'to log in via the web. Log in as a normal user instead.'))
         ->addCancelButton('/');
     }
 
     if ($request->isFormPost() || $is_logged_in) {
       // If we have an email bound into this URI, verify email so that clicking
       // the link in the "Welcome" email is good enough, without requiring users
       // to go through a second round of email verification.
 
       $editor = id(new PhabricatorUserEditor())
         ->setActor($target_user);
 
       $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
         // Nuke the token and all other outstanding password reset tokens.
         // There is no particular security benefit to destroying them all, but
         // it should reduce HackerOne reports of nebulous harm.
         $editor->revokePasswordResetLinks($target_user);
 
         if ($target_email) {
           $editor->verifyEmail($target_user, $target_email);
         }
       unset($unguarded);
 
       $next_uri = $this->getNextStepURI($target_user);
 
       // If the user is already logged in, we're just doing a "password set"
       // flow. Skip directly to the next step.
       if ($is_logged_in) {
         return id(new AphrontRedirectResponse())->setURI($next_uri);
       }
 
       PhabricatorCookies::setNextURICookie($request, $next_uri, $force = true);
 
       $force_full_session = false;
       if ($link_type === PhabricatorAuthSessionEngine::ONETIME_RECOVER) {
         $force_full_session = $token->getShouldForceFullSession();
       }
 
       return $this->loginUser($target_user, $force_full_session);
     }
 
     // NOTE: We need to CSRF here so attackers can't generate an email link,
     // then log a user in to an account they control via sneaky invisible
     // form submissions.
 
     switch ($link_type) {
       case PhabricatorAuthSessionEngine::ONETIME_WELCOME:
         $title = pht('Welcome to Phabricator');
         break;
       case PhabricatorAuthSessionEngine::ONETIME_RECOVER:
         $title = pht('Account Recovery');
         break;
       case PhabricatorAuthSessionEngine::ONETIME_USERNAME:
       case PhabricatorAuthSessionEngine::ONETIME_RESET:
       default:
         $title = pht('Log in to Phabricator');
         break;
     }
 
     $body = array();
     $body[] = pht(
       'Use the button below to log in as: %s',
       phutil_tag('strong', array(), $target_user->getUsername()));
 
     if ($target_email && !$target_email->getIsVerified()) {
       $body[] = pht(
         'Logging in will verify %s as an email address you own.',
         phutil_tag('strong', array(), $target_email->getAddress()));
 
     }
 
     $body[] = pht(
       'After logging in you should set a password for your account, or '.
       'link your account to an external account that you can use to '.
       'authenticate in the future.');
 
     $dialog = $this->newDialog()
       ->setTitle($title)
       ->addSubmitButton(pht('Log In (%s)', $target_user->getUsername()))
       ->addCancelButton('/');
 
     foreach ($body as $paragraph) {
       $dialog->appendParagraph($paragraph);
     }
 
     return id(new AphrontDialogResponse())->setDialog($dialog);
   }
 
   private function getNextStepURI(PhabricatorUser $user) {
     $request = $this->getRequest();
 
     // If we have password auth, let the user set or reset their password after
     // login.
     $have_passwords = PhabricatorPasswordAuthProvider::getPasswordProvider();
     if ($have_passwords) {
       // We're going to let the user reset their password without knowing
       // the old one. Generate a one-time token for that.
       $key = Filesystem::readRandomCharacters(16);
       $password_type =
         PhabricatorAuthPasswordResetTemporaryTokenType::TOKENTYPE;
 
       $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
         id(new PhabricatorAuthTemporaryToken())
           ->setTokenResource($user->getPHID())
           ->setTokenType($password_type)
           ->setTokenExpires(time() + phutil_units('1 hour in seconds'))
           ->setTokenCode(PhabricatorHash::weakDigest($key))
           ->save();
       unset($unguarded);
 
       $panel_uri = '/auth/password/';
 
       $request->setTemporaryCookie(PhabricatorCookies::COOKIE_HISEC, 'yes');
 
-      return (string)id(new PhutilURI($panel_uri))
-        ->setQueryParams(
-          array(
-            'key' => $key,
-          ));
+      $params = array(
+        'key' => $key,
+      );
+
+      return (string)new PhutilURI($panel_uri, $params);
     }
 
     $providers = id(new PhabricatorAuthProviderConfigQuery())
       ->setViewer($user)
       ->withIsEnabled(true)
       ->execute();
 
     // If there are no configured providers and the user is an administrator,
     // send them to Auth to configure a provider. This is probably where they
     // want to go. You can end up in this state by accidentally losing your
     // first session during initial setup, or after restoring exported data
     // from a hosted instance.
     if (!$providers && $user->getIsAdmin()) {
       return '/auth/';
     }
 
     // If we didn't find anywhere better to send them, give up and just send
     // them to the home page.
     return '/';
   }
 
 }
diff --git a/src/applications/auth/future/PhabricatorDuoFuture.php b/src/applications/auth/future/PhabricatorDuoFuture.php
index 81a5a2a2b8..1e70ec2a57 100644
--- a/src/applications/auth/future/PhabricatorDuoFuture.php
+++ b/src/applications/auth/future/PhabricatorDuoFuture.php
@@ -1,151 +1,154 @@
 <?php
 
 final class PhabricatorDuoFuture
   extends FutureProxy {
 
   private $future;
 
   private $integrationKey;
   private $secretKey;
   private $apiHostname;
 
   private $httpMethod = 'POST';
   private $method;
   private $parameters;
   private $timeout;
 
   public function __construct() {
     parent::__construct(null);
   }
 
   public function setIntegrationKey($integration_key) {
     $this->integrationKey = $integration_key;
     return $this;
   }
 
   public function setSecretKey(PhutilOpaqueEnvelope $key) {
     $this->secretKey = $key;
     return $this;
   }
 
   public function setAPIHostname($hostname) {
     $this->apiHostname = $hostname;
     return $this;
   }
 
   public function setMethod($method, array $parameters) {
     $this->method = $method;
     $this->parameters = $parameters;
     return $this;
   }
 
   public function setTimeout($timeout) {
     $this->timeout = $timeout;
     return $this;
   }
 
   public function getTimeout() {
     return $this->timeout;
   }
 
   public function setHTTPMethod($method) {
     $this->httpMethod = $method;
     return $this;
   }
 
   public function getHTTPMethod() {
     return $this->httpMethod;
   }
 
   protected function getProxiedFuture() {
     if (!$this->future) {
       if ($this->integrationKey === null) {
         throw new PhutilInvalidStateException('setIntegrationKey');
       }
 
       if ($this->secretKey === null) {
         throw new PhutilInvalidStateException('setSecretKey');
       }
 
       if ($this->apiHostname === null) {
         throw new PhutilInvalidStateException('setAPIHostname');
       }
 
       if ($this->method === null || $this->parameters === null) {
         throw new PhutilInvalidStateException('setMethod');
       }
 
       $path = (string)urisprintf('/auth/v2/%s', $this->method);
 
       $host = $this->apiHostname;
       $host = phutil_utf8_strtolower($host);
 
-      $uri = id(new PhutilURI(''))
-        ->setProtocol('https')
-        ->setDomain($host)
-        ->setPath($path);
-
       $data = $this->parameters;
       $date = date('r');
 
       $http_method = $this->getHTTPMethod();
 
       ksort($data);
       $data_parts = phutil_build_http_querystring($data);
 
       $corpus = array(
         $date,
         $http_method,
         $host,
         $path,
         $data_parts,
       );
       $corpus = implode("\n", $corpus);
 
       $signature = hash_hmac(
         'sha1',
         $corpus,
         $this->secretKey->openEnvelope());
       $signature = new PhutilOpaqueEnvelope($signature);
 
       if ($http_method === 'GET') {
-        $uri->setQueryParams($data);
-        $data = array();
+        $uri_data = $data;
+        $body_data = array();
+      } else {
+        $uri_data = array();
+        $body_data = $data;
       }
 
-      $future = id(new HTTPSFuture($uri, $data))
+      $uri = id(new PhutilURI('', $uri_data))
+        ->setProtocol('https')
+        ->setDomain($host)
+        ->setPath($path);
+
+      $future = id(new HTTPSFuture($uri, $body_data))
         ->setHTTPBasicAuthCredentials($this->integrationKey, $signature)
         ->setMethod($http_method)
         ->addHeader('Accept', 'application/json')
         ->addHeader('Date', $date);
 
       $timeout = $this->getTimeout();
       if ($timeout) {
         $future->setTimeout($timeout);
       }
 
       $this->future = $future;
     }
 
     return $this->future;
   }
 
   protected function didReceiveResult($result) {
     list($status, $body, $headers) = $result;
 
     if ($status->isError()) {
       throw $status;
     }
 
     try {
       $data = phutil_json_decode($body);
     } catch (PhutilJSONParserException $ex) {
       throw new PhutilProxyException(
         pht('Expected JSON response from Duo.'),
         $ex);
     }
 
     return $data;
   }
 
 }
diff --git a/src/applications/diffusion/view/DiffusionView.php b/src/applications/diffusion/view/DiffusionView.php
index eb7f3eb72f..123d22af5e 100644
--- a/src/applications/diffusion/view/DiffusionView.php
+++ b/src/applications/diffusion/view/DiffusionView.php
@@ -1,265 +1,265 @@
 <?php
 
 abstract class DiffusionView extends AphrontView {
 
   private $diffusionRequest;
 
   final public function setDiffusionRequest(DiffusionRequest $request) {
     $this->diffusionRequest = $request;
     return $this;
   }
 
   final public function getDiffusionRequest() {
     return $this->diffusionRequest;
   }
 
   final public function linkHistory($path) {
     $href = $this->getDiffusionRequest()->generateURI(
       array(
         'action' => 'history',
         'path'   => $path,
       ));
 
     return $this->renderHistoryLink($href);
   }
 
   final public function linkBranchHistory($branch) {
     $href = $this->getDiffusionRequest()->generateURI(
       array(
         'action' => 'history',
         'branch' => $branch,
       ));
 
     return $this->renderHistoryLink($href);
   }
 
   final public function linkTagHistory($tag) {
     $href = $this->getDiffusionRequest()->generateURI(
       array(
         'action' => 'history',
         'commit' => $tag,
       ));
 
     return $this->renderHistoryLink($href);
   }
 
   private function renderHistoryLink($href) {
     return javelin_tag(
       'a',
       array(
         'href' => $href,
         'class' => 'diffusion-link-icon',
         'sigil' => 'has-tooltip',
         'meta' => array(
           'tip' => pht('History'),
           'align' => 'E',
         ),
       ),
       id(new PHUIIconView())->setIcon('fa-history bluegrey'));
   }
 
   final public function linkBrowse(
     $path,
     array $details = array(),
     $button = false) {
     require_celerity_resource('diffusion-icons-css');
     Javelin::initBehavior('phabricator-tooltips');
 
     $file_type = idx($details, 'type');
     unset($details['type']);
 
     $display_name = idx($details, 'name');
     unset($details['name']);
 
     if (strlen($display_name)) {
       $display_name = phutil_tag(
         'span',
         array(
           'class' => 'diffusion-browse-name',
         ),
         $display_name);
     }
 
     if (isset($details['external'])) {
-      $href = id(new PhutilURI('/diffusion/external/'))
-        ->setQueryParams(
-          array(
-            'uri' => idx($details, 'external'),
-            'id'  => idx($details, 'hash'),
-          ));
+      $params = array(
+        'uri' => idx($details, 'external'),
+        'id'  => idx($details, 'hash'),
+      );
+
+      $href = new PhutilURI('/diffusion/external/', $params);
       $tip = pht('Browse External');
     } else {
       $href = $this->getDiffusionRequest()->generateURI(
         $details + array(
           'action' => 'browse',
           'path'   => $path,
         ));
       $tip = pht('Browse');
     }
 
     $icon = DifferentialChangeType::getIconForFileType($file_type);
     $color = DifferentialChangeType::getIconColorForFileType($file_type);
     $icon_view = id(new PHUIIconView())
       ->setIcon($icon.' '.$color);
 
     // If we're rendering a file or directory name, don't show the tooltip.
     if ($display_name !== null) {
       $sigil = null;
       $meta = null;
     } else {
       $sigil = 'has-tooltip';
       $meta = array(
         'tip' => $tip,
         'align' => 'E',
       );
     }
 
     if ($button) {
       return id(new PHUIButtonView())
         ->setTag('a')
         ->setIcon('fa-code')
         ->setHref($href)
         ->setToolTip(pht('Browse'))
         ->setButtonType(PHUIButtonView::BUTTONTYPE_SIMPLE);
     }
 
     return javelin_tag(
       'a',
       array(
         'href' => $href,
         'class' => 'diffusion-link-icon',
         'sigil' => $sigil,
         'meta' => $meta,
       ),
       array(
         $icon_view,
         $display_name,
       ));
   }
 
   final public static function linkCommit(
     PhabricatorRepository $repository,
     $commit,
     $summary = '') {
 
     $commit_name = $repository->formatCommitName($commit, $local = true);
 
     if (strlen($summary)) {
       $commit_name .= ': '.$summary;
     }
 
     return phutil_tag(
       'a',
       array(
         'href' => $repository->getCommitURI($commit),
       ),
       $commit_name);
   }
 
   final public static function linkDetail(
     PhabricatorRepository $repository,
     $commit,
     $detail) {
 
     return phutil_tag(
       'a',
       array(
         'href' => $repository->getCommitURI($commit),
       ),
       $detail);
   }
 
   final public static function linkRevision($id) {
     if (!$id) {
       return null;
     }
 
     return phutil_tag(
       'a',
       array(
         'href' => "/D{$id}",
       ),
       "D{$id}");
   }
 
   final public static function renderName($name) {
     $email = new PhutilEmailAddress($name);
     if ($email->getDisplayName() && $email->getDomainName()) {
       Javelin::initBehavior('phabricator-tooltips', array());
       require_celerity_resource('aphront-tooltip-css');
       return javelin_tag(
         'span',
         array(
           'sigil' => 'has-tooltip',
           'meta'  => array(
             'tip'   => $email->getAddress(),
             'align' => 'S',
             'size'  => 'auto',
           ),
         ),
         $email->getDisplayName());
     }
     return hsprintf('%s', $name);
   }
 
   final protected function renderBuildable(
     HarbormasterBuildable $buildable,
     $type = null) {
     Javelin::initBehavior('phabricator-tooltips');
 
     $icon = $buildable->getStatusIcon();
     $color = $buildable->getStatusColor();
     $name = $buildable->getStatusDisplayName();
 
     if ($type == 'button') {
       return id(new PHUIButtonView())
         ->setTag('a')
         ->setText($name)
         ->setIcon($icon)
         ->setColor($color)
         ->setHref('/'.$buildable->getMonogram())
         ->addClass('mmr')
         ->setButtonType(PHUIButtonView::BUTTONTYPE_SIMPLE)
         ->addClass('diffusion-list-build-status');
     }
 
     return id(new PHUIIconView())
       ->setIcon($icon.' '.$color)
       ->addSigil('has-tooltip')
       ->setHref('/'.$buildable->getMonogram())
       ->setMetadata(
         array(
           'tip' => $name,
         ));
 
   }
 
   final protected function loadBuildables(array $commits) {
     assert_instances_of($commits, 'PhabricatorRepositoryCommit');
 
     if (!$commits) {
       return array();
     }
 
     $viewer = $this->getUser();
 
     $harbormaster_app = 'PhabricatorHarbormasterApplication';
     $have_harbormaster = PhabricatorApplication::isClassInstalledForViewer(
       $harbormaster_app,
       $viewer);
 
     if ($have_harbormaster) {
       $buildables = id(new HarbormasterBuildableQuery())
         ->setViewer($viewer)
         ->withBuildablePHIDs(mpull($commits, 'getPHID'))
         ->withManualBuildables(false)
         ->execute();
       $buildables = mpull($buildables, null, 'getBuildablePHID');
     } else {
       $buildables = array();
     }
 
     return $buildables;
   }
 
 }
diff --git a/src/applications/diviner/markup/DivinerSymbolRemarkupRule.php b/src/applications/diviner/markup/DivinerSymbolRemarkupRule.php
index 7fdb4cb37e..db68927625 100644
--- a/src/applications/diviner/markup/DivinerSymbolRemarkupRule.php
+++ b/src/applications/diviner/markup/DivinerSymbolRemarkupRule.php
@@ -1,167 +1,167 @@
 <?php
 
 final class DivinerSymbolRemarkupRule extends PhutilRemarkupRule {
 
   const KEY_RULE_ATOM_REF = 'rule.diviner.atomref';
 
   public function getPriority() {
     return 200.0;
   }
 
   public function apply($text) {
     // Grammar here is:
     //
     //         rule = '@{' maybe_type name maybe_title '}'
     //   maybe_type = null | type ':' | type '@' book ':'
     //         name = name | name '@' context
     //  maybe_title = null | '|' title
     //
     // So these are all valid:
     //
     //   @{name}
     //   @{type : name}
     //   @{name | title}
     //   @{type @ book : name @ context | title}
 
     return preg_replace_callback(
       '/(?:^|\B)@{'.
         '(?:(?P<type>[^:]+?):)?'.
         '(?P<name>[^}|]+?)'.
         '(?:[|](?P<title>[^}]+))?'.
       '}/',
       array($this, 'markupSymbol'),
       $text);
   }
 
   public function markupSymbol(array $matches) {
     if (!$this->isFlatText($matches[0])) {
       return $matches[0];
     }
 
     $type = (string)idx($matches, 'type');
     $name = (string)$matches['name'];
     $title = (string)idx($matches, 'title');
 
     // Collapse sequences of whitespace into a single space.
     $type = preg_replace('/\s+/', ' ', trim($type));
     $name = preg_replace('/\s+/', ' ', trim($name));
     $title = preg_replace('/\s+/', ' ', trim($title));
 
     $ref = array();
 
     if (strpos($type, '@') !== false) {
       list($type, $book) = explode('@', $type, 2);
       $ref['type'] = trim($type);
       $ref['book'] = trim($book);
     } else {
       $ref['type'] = $type;
     }
 
     if (strpos($name, '@') !== false) {
       list($name, $context) = explode('@', $name, 2);
       $ref['name'] = trim($name);
       $ref['context'] = trim($context);
     } else {
       $ref['name'] = $name;
     }
 
     $ref['title'] = nonempty($title, $name);
 
     foreach ($ref as $key => $value) {
       if ($value === '') {
         unset($ref[$key]);
       }
     }
 
     $engine = $this->getEngine();
     $token = $engine->storeText('');
 
     $key = self::KEY_RULE_ATOM_REF;
     $data = $engine->getTextMetadata($key, array());
     $data[$token] = $ref;
     $engine->setTextMetadata($key, $data);
 
     return $token;
   }
 
   public function didMarkupText() {
     $engine = $this->getEngine();
 
     $key = self::KEY_RULE_ATOM_REF;
     $data = $engine->getTextMetadata($key, array());
 
     $renderer = $engine->getConfig('diviner.renderer');
 
     foreach ($data as $token => $ref_dict) {
       $ref = DivinerAtomRef::newFromDictionary($ref_dict);
       $title = $ref->getTitle();
 
       $href = null;
       if ($renderer) {
         // Here, we're generating documentation. If possible, we want to find
         // the real atom ref so we can render the correct default title and
         // render invalid links in an alternate style.
 
         $ref = $renderer->normalizeAtomRef($ref);
         if ($ref) {
           $title = nonempty($ref->getTitle(), $ref->getName());
           $href = $renderer->getHrefForAtomRef($ref);
         }
       } else {
         // Here, we're generating comment text or something like that. Just
         // link to Diviner and let it sort things out.
 
-        $href = id(new PhutilURI('/diviner/find/'))
-          ->setQueryParams(
-            array(
-              'book' => $ref->getBook(),
-              'name' => $ref->getName(),
-              'type' => $ref->getType(),
-              'context' => $ref->getContext(),
-              'jump' => true,
-            ));
+        $params = array(
+          'book' => $ref->getBook(),
+          'name' => $ref->getName(),
+          'type' => $ref->getType(),
+          'context' => $ref->getContext(),
+          'jump' => true,
+        );
+
+        $href = new PhutilURI('/diviner/find/', $params);
       }
 
       // TODO: This probably is not the best place to do this. Move it somewhere
       // better when it becomes more clear where it should actually go.
       if ($ref) {
         switch ($ref->getType()) {
           case 'function':
           case 'method':
             $title = $title.'()';
             break;
         }
       }
 
       if ($this->getEngine()->isTextMode()) {
         if ($href) {
           $link = $title.' <'.PhabricatorEnv::getProductionURI($href).'>';
         } else {
           $link = $title;
         }
       } else if ($href) {
         if ($this->getEngine()->isHTMLMailMode()) {
           $href = PhabricatorEnv::getProductionURI($href);
         }
 
         $link = $this->newTag(
           'a',
           array(
             'class' => 'atom-ref',
             'href' => $href,
           ),
           $title);
       } else {
         $link = $this->newTag(
           'span',
           array(
             'class' => 'atom-ref-invalid',
           ),
           $title);
       }
 
       $engine->overwriteStoredText($token, $link);
     }
   }
 
 }
diff --git a/src/applications/herald/controller/HeraldNewController.php b/src/applications/herald/controller/HeraldNewController.php
index fbaf1aeb9e..f571aeb395 100644
--- a/src/applications/herald/controller/HeraldNewController.php
+++ b/src/applications/herald/controller/HeraldNewController.php
@@ -1,316 +1,316 @@
 <?php
 
 final class HeraldNewController extends HeraldController {
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $request->getViewer();
 
     $content_type_map = HeraldAdapter::getEnabledAdapterMap($viewer);
     $rule_type_map = HeraldRuleTypeConfig::getRuleTypeMap();
 
     $errors = array();
 
     $e_type = null;
     $e_rule = null;
     $e_object = null;
 
     $step = $request->getInt('step');
     if ($request->isFormPost()) {
       $content_type = $request->getStr('content_type');
       if (empty($content_type_map[$content_type])) {
         $errors[] = pht('You must choose a content type for this rule.');
         $e_type = pht('Required');
         $step = 0;
       }
 
       if (!$errors && $step > 1) {
         $rule_type = $request->getStr('rule_type');
         if (empty($rule_type_map[$rule_type])) {
           $errors[] = pht('You must choose a rule type for this rule.');
           $e_rule = pht('Required');
           $step = 1;
         }
       }
 
       if (!$errors && $step >= 2) {
         $target_phid = null;
         $object_name = $request->getStr('objectName');
         $done = false;
         if ($rule_type != HeraldRuleTypeConfig::RULE_TYPE_OBJECT) {
           $done = true;
         } else if (strlen($object_name)) {
           $target_object = id(new PhabricatorObjectQuery())
             ->setViewer($viewer)
             ->withNames(array($object_name))
             ->executeOne();
           if ($target_object) {
             $can_edit = PhabricatorPolicyFilter::hasCapability(
               $viewer,
               $target_object,
               PhabricatorPolicyCapability::CAN_EDIT);
             if (!$can_edit) {
               $errors[] = pht(
                 'You can not create a rule for that object, because you do '.
                 'not have permission to edit it. You can only create rules '.
                 'for objects you can edit.');
               $e_object = pht('Not Editable');
               $step = 2;
             } else {
               $adapter = HeraldAdapter::getAdapterForContentType($content_type);
               if (!$adapter->canTriggerOnObject($target_object)) {
                 $errors[] = pht(
                   'This object is not of an allowed type for the rule. '.
                   'Rules can only trigger on certain objects.');
                 $e_object = pht('Invalid');
                 $step = 2;
               } else {
                 $target_phid = $target_object->getPHID();
                 $done = true;
               }
             }
           } else {
             $errors[] = pht('No object exists by that name.');
             $e_object = pht('Invalid');
             $step = 2;
           }
         } else if ($step > 2) {
           $errors[] = pht(
             'You must choose an object to associate this rule with.');
           $e_object = pht('Required');
           $step = 2;
         }
 
         if (!$errors && $done) {
-          $uri = id(new PhutilURI('edit/'))
-            ->setQueryParams(
-              array(
-                'content_type' => $content_type,
-                'rule_type' => $rule_type,
-                'targetPHID' => $target_phid,
-              ));
+          $params = array(
+            'content_type' => $content_type,
+            'rule_type' => $rule_type,
+            'targetPHID' => $target_phid,
+          );
+
+          $uri = new PhutilURI('edit/', $params);
           $uri = $this->getApplicationURI($uri);
           return id(new AphrontRedirectResponse())->setURI($uri);
         }
       }
     }
 
     $content_type = $request->getStr('content_type');
     $rule_type = $request->getStr('rule_type');
 
     $form = id(new AphrontFormView())
       ->setUser($viewer)
       ->setAction($this->getApplicationURI('new/'));
 
     switch ($step) {
       case 0:
       default:
         $content_types = $this->renderContentTypeControl(
           $content_type_map,
           $e_type);
 
         $form
           ->addHiddenInput('step', 1)
           ->appendChild($content_types);
 
         $cancel_text = null;
         $cancel_uri = $this->getApplicationURI();
         $title = pht('Create Herald Rule');
         break;
       case 1:
         $rule_types = $this->renderRuleTypeControl(
           $rule_type_map,
           $e_rule);
 
         $form
           ->addHiddenInput('content_type', $content_type)
           ->addHiddenInput('step', 2)
           ->appendChild($rule_types);
 
+        $params = array(
+          'content_type' => $content_type,
+          'step' => '0',
+        );
+
         $cancel_text = pht('Back');
-        $cancel_uri = id(new PhutilURI('new/'))
-          ->setQueryParams(
-            array(
-              'content_type' => $content_type,
-              'step' => 0,
-            ));
+        $cancel_uri = new PhutilURI('new/', $params);
         $cancel_uri = $this->getApplicationURI($cancel_uri);
         $title = pht('Create Herald Rule: %s',
           idx($content_type_map, $content_type));
         break;
       case 2:
         $adapter = HeraldAdapter::getAdapterForContentType($content_type);
         $form
           ->addHiddenInput('content_type', $content_type)
           ->addHiddenInput('rule_type', $rule_type)
           ->addHiddenInput('step', 3)
           ->appendChild(
             id(new AphrontFormStaticControl())
               ->setLabel(pht('Rule for'))
               ->setValue(
                 phutil_tag(
                   'strong',
                   array(),
                   idx($content_type_map, $content_type))))
           ->appendChild(
             id(new AphrontFormStaticControl())
               ->setLabel(pht('Rule Type'))
               ->setValue(
                 phutil_tag(
                   'strong',
                   array(),
                   idx($rule_type_map, $rule_type))))
           ->appendRemarkupInstructions(
             pht(
               'Choose the object this rule will act on (for example, enter '.
               '`rX` to act on the `rX` repository, or `#project` to act on '.
               'a project).'))
           ->appendRemarkupInstructions(
             $adapter->explainValidTriggerObjects())
           ->appendChild(
             id(new AphrontFormTextControl())
               ->setName('objectName')
               ->setError($e_object)
               ->setValue($request->getStr('objectName'))
               ->setLabel(pht('Object')));
 
+        $params = array(
+          'content_type' => $content_type,
+          'rule_type' => $rule_type,
+          'step' => 1,
+        );
+
         $cancel_text = pht('Back');
-        $cancel_uri = id(new PhutilURI('new/'))
-          ->setQueryParams(
-            array(
-              'content_type' => $content_type,
-              'rule_type' => $rule_type,
-              'step' => 1,
-            ));
+        $cancel_uri = new PhutilURI('new/', $params);
         $cancel_uri = $this->getApplicationURI($cancel_uri);
         $title = pht('Create Herald Rule: %s',
           idx($content_type_map, $content_type));
         break;
     }
 
     $form
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue(pht('Continue'))
           ->addCancelButton($cancel_uri, $cancel_text));
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->setFormErrors($errors)
       ->setBackground(PHUIObjectBoxView::WHITE_CONFIG)
       ->setForm($form);
 
     $crumbs = $this
       ->buildApplicationCrumbs()
       ->addTextCrumb(pht('Create Rule'))
       ->setBorder(true);
 
     $view = id(new PHUITwoColumnView())
       ->setFooter($form_box);
 
     return $this->newPage()
       ->setTitle($title)
       ->setCrumbs($crumbs)
       ->appendChild(
         array(
           $view,
       ));
   }
 
   private function renderContentTypeControl(array $content_type_map, $e_type) {
     $request = $this->getRequest();
 
     $radio = id(new AphrontFormRadioButtonControl())
       ->setLabel(pht('New Rule for'))
       ->setName('content_type')
       ->setValue($request->getStr('content_type'))
       ->setError($e_type);
 
     foreach ($content_type_map as $value => $name) {
       $adapter = HeraldAdapter::getAdapterForContentType($value);
       $radio->addButton(
         $value,
         $name,
         phutil_escape_html_newlines($adapter->getAdapterContentDescription()));
     }
 
     return $radio;
   }
 
 
   private function renderRuleTypeControl(array $rule_type_map, $e_rule) {
     $request = $this->getRequest();
 
     // Reorder array to put less powerful rules first.
     $rule_type_map = array_select_keys(
       $rule_type_map,
       array(
         HeraldRuleTypeConfig::RULE_TYPE_PERSONAL,
         HeraldRuleTypeConfig::RULE_TYPE_OBJECT,
         HeraldRuleTypeConfig::RULE_TYPE_GLOBAL,
       )) + $rule_type_map;
 
     list($can_global, $global_link) = $this->explainApplicationCapability(
       HeraldManageGlobalRulesCapability::CAPABILITY,
       pht('You have permission to create and manage global rules.'),
       pht('You do not have permission to create or manage global rules.'));
 
     $captions = array(
       HeraldRuleTypeConfig::RULE_TYPE_PERSONAL =>
         pht(
           'Personal rules notify you about events. You own them, but they can '.
           'only affect you. Personal rules only trigger for objects you have '.
           'permission to see.'),
       HeraldRuleTypeConfig::RULE_TYPE_OBJECT =>
         pht(
           'Object rules notify anyone about events. They are bound to an '.
           'object (like a repository) and can only act on that object. You '.
           'must be able to edit an object to create object rules for it. '.
           'Other users who can edit the object can edit its rules.'),
       HeraldRuleTypeConfig::RULE_TYPE_GLOBAL =>
         array(
           pht(
             'Global rules notify anyone about events. Global rules can '.
             'bypass access control policies and act on any object.'),
           $global_link,
         ),
     );
 
     $radio = id(new AphrontFormRadioButtonControl())
       ->setLabel(pht('Rule Type'))
       ->setName('rule_type')
       ->setValue($request->getStr('rule_type'))
       ->setError($e_rule);
 
     $adapter = HeraldAdapter::getAdapterForContentType(
       $request->getStr('content_type'));
 
     foreach ($rule_type_map as $value => $name) {
       $caption = idx($captions, $value);
       $disabled = ($value == HeraldRuleTypeConfig::RULE_TYPE_GLOBAL) &&
                   (!$can_global);
 
       if (!$adapter->supportsRuleType($value)) {
         $disabled = true;
         $caption = array(
           $caption,
           "\n\n",
           phutil_tag(
             'em',
             array(),
             pht(
               'This rule type is not supported by the selected content type.')),
         );
       }
 
       $radio->addButton(
         $value,
         $name,
         phutil_escape_html_newlines($caption),
         $disabled ? 'disabled' : null,
         $disabled);
     }
 
     return $radio;
   }
 
 }
diff --git a/src/applications/owners/controller/PhabricatorOwnersDetailController.php b/src/applications/owners/controller/PhabricatorOwnersDetailController.php
index e28ae2b3bb..c458e4dbd1 100644
--- a/src/applications/owners/controller/PhabricatorOwnersDetailController.php
+++ b/src/applications/owners/controller/PhabricatorOwnersDetailController.php
@@ -1,348 +1,348 @@
 <?php
 
 final class PhabricatorOwnersDetailController
   extends PhabricatorOwnersController {
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $this->getViewer();
 
     $package = id(new PhabricatorOwnersPackageQuery())
       ->setViewer($viewer)
       ->withIDs(array($request->getURIData('id')))
       ->needPaths(true)
       ->executeOne();
     if (!$package) {
       return new Aphront404Response();
     }
 
     $paths = $package->getPaths();
 
     $repository_phids = array();
     foreach ($paths as $path) {
       $repository_phids[$path->getRepositoryPHID()] = true;
     }
 
     if ($repository_phids) {
       $repositories = id(new PhabricatorRepositoryQuery())
         ->setViewer($viewer)
         ->withPHIDs(array_keys($repository_phids))
         ->execute();
       $repositories = mpull($repositories, null, 'getPHID');
     } else {
       $repositories = array();
     }
 
     $field_list = PhabricatorCustomField::getObjectFields(
       $package,
       PhabricatorCustomField::ROLE_VIEW);
     $field_list
       ->setViewer($viewer)
       ->readFieldsFromStorage($package);
 
     $curtain = $this->buildCurtain($package);
     $details = $this->buildPackageDetailView($package, $field_list);
 
     if ($package->isArchived()) {
       $header_icon = 'fa-ban';
       $header_name = pht('Archived');
       $header_color = 'dark';
     } else {
       $header_icon = 'fa-check';
       $header_name = pht('Active');
       $header_color = 'bluegrey';
     }
 
     $header = id(new PHUIHeaderView())
       ->setUser($viewer)
       ->setHeader($package->getName())
       ->setStatus($header_icon, $header_color, $header_name)
       ->setPolicyObject($package)
       ->setHeaderIcon('fa-gift');
 
     $commit_views = array();
 
-    $commit_uri = id(new PhutilURI('/diffusion/commit/'))
-      ->setQueryParams(
-        array(
-          'package' => $package->getPHID(),
-        ));
+    $params = array(
+      'package' => $package->getPHID(),
+    );
+
+    $commit_uri = new PhutilURI('/diffusion/commit/', $params);
 
     $status_concern = DiffusionCommitAuditStatus::CONCERN_RAISED;
 
     $attention_commits = id(new DiffusionCommitQuery())
       ->setViewer($request->getUser())
       ->withPackagePHIDs(array($package->getPHID()))
       ->withStatuses(
         array(
           $status_concern,
         ))
       ->needCommitData(true)
       ->needAuditRequests(true)
       ->setLimit(10)
       ->execute();
     $view = id(new PhabricatorAuditListView())
       ->setUser($viewer)
       ->setNoDataString(pht('This package has no open problem commits.'))
       ->setCommits($attention_commits);
 
     $commit_views[] = array(
       'view'    => $view,
       'header'  => pht('Needs Attention'),
       'icon'    => 'fa-warning',
       'button'  => id(new PHUIButtonView())
         ->setTag('a')
         ->setHref($commit_uri->alter('status', $status_concern))
         ->setIcon('fa-list-ul')
         ->setText(pht('View All')),
     );
 
     $all_commits = id(new DiffusionCommitQuery())
       ->setViewer($request->getUser())
       ->withPackagePHIDs(array($package->getPHID()))
       ->needCommitData(true)
       ->needAuditRequests(true)
       ->setLimit(25)
       ->execute();
 
     $view = id(new PhabricatorAuditListView())
       ->setUser($viewer)
       ->setCommits($all_commits)
       ->setNoDataString(pht('No commits in this package.'));
 
     $commit_views[] = array(
       'view'    => $view,
       'header'  => pht('Recent Commits'),
       'icon'    => 'fa-code',
       'button'  => id(new PHUIButtonView())
         ->setTag('a')
         ->setHref($commit_uri)
         ->setIcon('fa-list-ul')
         ->setText(pht('View All')),
     );
 
     $commit_panels = array();
     foreach ($commit_views as $commit_view) {
       $commit_panel = id(new PHUIObjectBoxView())
         ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);
       $commit_header = id(new PHUIHeaderView())
         ->setHeader($commit_view['header'])
         ->setHeaderIcon($commit_view['icon']);
       if (isset($commit_view['button'])) {
         $commit_header->addActionLink($commit_view['button']);
       }
       $commit_panel->setHeader($commit_header);
       $commit_panel->appendChild($commit_view['view']);
 
       $commit_panels[] = $commit_panel;
     }
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb($package->getMonogram());
     $crumbs->setBorder(true);
 
     $timeline = $this->buildTransactionTimeline(
       $package,
       new PhabricatorOwnersPackageTransactionQuery());
     $timeline->setShouldTerminate(true);
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setCurtain($curtain)
       ->setMainColumn(array(
         $this->renderPathsTable($paths, $repositories),
         $commit_panels,
         $timeline,
       ))
       ->addPropertySection(pht('Details'), $details);
 
     return $this->newPage()
       ->setTitle($package->getName())
       ->setCrumbs($crumbs)
       ->appendChild($view);
   }
 
   private function buildPackageDetailView(
     PhabricatorOwnersPackage $package,
     PhabricatorCustomFieldList $field_list) {
 
     $viewer = $this->getViewer();
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer);
 
     $owners = $package->getOwners();
     if ($owners) {
       $owner_list = $viewer->renderHandleList(mpull($owners, 'getUserPHID'));
     } else {
       $owner_list = phutil_tag('em', array(), pht('None'));
     }
     $view->addProperty(pht('Owners'), $owner_list);
 
 
     $dominion = $package->getDominion();
     $dominion_map = PhabricatorOwnersPackage::getDominionOptionsMap();
     $spec = idx($dominion_map, $dominion, array());
     $name = idx($spec, 'short', $dominion);
     $view->addProperty(pht('Dominion'), $name);
 
     $auto = $package->getAutoReview();
     $autoreview_map = PhabricatorOwnersPackage::getAutoreviewOptionsMap();
     $spec = idx($autoreview_map, $auto, array());
     $name = idx($spec, 'name', $auto);
     $view->addProperty(pht('Auto Review'), $name);
 
     $rule = $package->newAuditingRule();
     $view->addProperty(pht('Auditing'), $rule->getDisplayName());
 
     $ignored = $package->getIgnoredPathAttributes();
     $ignored = array_keys($ignored);
     if ($ignored) {
       $ignored = implode(', ', $ignored);
     } else {
       $ignored = phutil_tag('em', array(), pht('None'));
     }
 
     $view->addProperty(pht('Ignored Attributes'), $ignored);
 
     $description = $package->getDescription();
     if (strlen($description)) {
       $description = new PHUIRemarkupView($viewer, $description);
       $view->addSectionHeader(pht('Description'));
       $view->addTextContent($description);
     }
 
     $field_list->appendFieldsToPropertyList(
       $package,
       $viewer,
       $view);
 
     return $view;
   }
 
   private function buildCurtain(PhabricatorOwnersPackage $package) {
     $viewer = $this->getViewer();
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $package,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $id = $package->getID();
     $edit_uri = $this->getApplicationURI("/edit/{$id}/");
     $paths_uri = $this->getApplicationURI("/paths/{$id}/");
 
     $curtain = $this->newCurtainView($package);
 
     $curtain->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Edit Package'))
         ->setIcon('fa-pencil')
         ->setDisabled(!$can_edit)
         ->setWorkflow(!$can_edit)
         ->setHref($edit_uri));
 
     if ($package->isArchived()) {
       $curtain->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Activate Package'))
           ->setIcon('fa-check')
           ->setDisabled(!$can_edit)
           ->setWorkflow($can_edit)
           ->setHref($this->getApplicationURI("/archive/{$id}/")));
     } else {
       $curtain->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Archive Package'))
           ->setIcon('fa-ban')
           ->setDisabled(!$can_edit)
           ->setWorkflow($can_edit)
           ->setHref($this->getApplicationURI("/archive/{$id}/")));
     }
 
     $curtain->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Edit Paths'))
         ->setIcon('fa-folder-open')
         ->setDisabled(!$can_edit)
         ->setWorkflow(!$can_edit)
         ->setHref($paths_uri));
 
     return $curtain;
   }
 
   private function renderPathsTable(array $paths, array $repositories) {
     $viewer = $this->getViewer();
 
     $rows = array();
     foreach ($paths as $path) {
       $repo = idx($repositories, $path->getRepositoryPHID());
       if (!$repo) {
         continue;
       }
       $href = $repo->generateURI(
         array(
           'branch'   => $repo->getDefaultBranch(),
           'path'     => $path->getPathDisplay(),
           'action'   => 'browse',
         ));
 
       $path_link = phutil_tag(
         'a',
         array(
           'href' => (string)$href,
         ),
         $path->getPathDisplay());
 
       $rows[] = array(
         ($path->getExcluded() ? '-' : '+'),
         $repo->getName(),
         $path_link,
       );
     }
 
     $info = null;
     if (!$paths) {
       $info = id(new PHUIInfoView())
         ->setSeverity(PHUIInfoView::SEVERITY_WARNING)
         ->setErrors(
           array(
             pht(
               'This package does not contain any paths yet. Use '.
               '"Edit Paths" to add some.'),
           ));
     }
 
     $table = id(new AphrontTableView($rows))
       ->setHeaders(
         array(
           null,
           pht('Repository'),
           pht('Path'),
         ))
       ->setColumnClasses(
         array(
           null,
           null,
           'wide',
         ));
 
     if ($info) {
       $table->setNotice($info);
     }
 
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('Paths'))
       ->setHeaderIcon('fa-folder-open');
 
     $box = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->setTable($table);
 
     return $box;
   }
 
 }
diff --git a/src/applications/phortune/controller/cart/PhortuneCartCheckoutController.php b/src/applications/phortune/controller/cart/PhortuneCartCheckoutController.php
index dd611ecb7b..874ecf63aa 100644
--- a/src/applications/phortune/controller/cart/PhortuneCartCheckoutController.php
+++ b/src/applications/phortune/controller/cart/PhortuneCartCheckoutController.php
@@ -1,233 +1,233 @@
 <?php
 
 final class PhortuneCartCheckoutController
   extends PhortuneCartController {
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $request->getViewer();
     $id = $request->getURIData('id');
 
     $cart = id(new PhortuneCartQuery())
       ->setViewer($viewer)
       ->withIDs(array($id))
       ->needPurchases(true)
       ->executeOne();
     if (!$cart) {
       return new Aphront404Response();
     }
 
     $cancel_uri = $cart->getCancelURI();
     $merchant = $cart->getMerchant();
 
     switch ($cart->getStatus()) {
       case PhortuneCart::STATUS_BUILDING:
         return $this->newDialog()
           ->setTitle(pht('Incomplete Cart'))
           ->appendParagraph(
             pht(
               'The application that created this cart did not finish putting '.
               'products in it. You can not checkout with an incomplete '.
               'cart.'))
           ->addCancelButton($cancel_uri);
       case PhortuneCart::STATUS_READY:
         // This is the expected, normal state for a cart that's ready for
         // checkout.
         break;
       case PhortuneCart::STATUS_CHARGED:
       case PhortuneCart::STATUS_PURCHASING:
       case PhortuneCart::STATUS_HOLD:
       case PhortuneCart::STATUS_REVIEW:
       case PhortuneCart::STATUS_PURCHASED:
         // For these states, kick the user to the order page to give them
         // information and options.
         return id(new AphrontRedirectResponse())->setURI($cart->getDetailURI());
       default:
         throw new Exception(
           pht(
             'Unknown cart status "%s"!',
             $cart->getStatus()));
     }
 
     $account = $cart->getAccount();
     $account_uri = $this->getApplicationURI($account->getID().'/');
 
     $methods = id(new PhortunePaymentMethodQuery())
       ->setViewer($viewer)
       ->withAccountPHIDs(array($account->getPHID()))
       ->withMerchantPHIDs(array($merchant->getPHID()))
       ->withStatuses(array(PhortunePaymentMethod::STATUS_ACTIVE))
       ->execute();
 
     $e_method = null;
     $errors = array();
 
     if ($request->isFormPost()) {
 
       // Require CAN_EDIT on the cart to actually make purchases.
 
       PhabricatorPolicyFilter::requireCapability(
         $viewer,
         $cart,
         PhabricatorPolicyCapability::CAN_EDIT);
 
       $method_id = $request->getInt('paymentMethodID');
       $method = idx($methods, $method_id);
       if (!$method) {
         $e_method = pht('Required');
         $errors[] = pht('You must choose a payment method.');
       }
 
       if (!$errors) {
         $provider = $method->buildPaymentProvider();
 
         $charge = $cart->willApplyCharge($viewer, $provider, $method);
 
         try {
           $provider->applyCharge($method, $charge);
         } catch (Exception $ex) {
           $cart->didFailCharge($charge);
           return $this->newDialog()
             ->setTitle(pht('Charge Failed'))
             ->appendParagraph(
               pht(
                 'Unable to make payment: %s',
                 $ex->getMessage()))
             ->addCancelButton($cart->getCheckoutURI(), pht('Continue'));
         }
 
         $cart->didApplyCharge($charge);
 
         $done_uri = $cart->getCheckoutURI();
         return id(new AphrontRedirectResponse())->setURI($done_uri);
       }
     }
 
     $cart_table = $this->buildCartContentTable($cart);
 
     $cart_box = id(new PHUIObjectBoxView())
       ->setFormErrors($errors)
       ->setHeaderText(pht('Cart Contents'))
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->setTable($cart_table);
 
     $title = $cart->getName();
 
     if (!$methods) {
       $method_control = id(new AphrontFormStaticControl())
         ->setLabel(pht('Payment Method'))
         ->setValue(
           phutil_tag('em', array(), pht('No payment methods configured.')));
     } else {
       $method_control = id(new AphrontFormRadioButtonControl())
         ->setLabel(pht('Payment Method'))
         ->setName('paymentMethodID')
         ->setValue($request->getInt('paymentMethodID'));
       foreach ($methods as $method) {
         $method_control->addButton(
           $method->getID(),
           $method->getFullDisplayName(),
           $method->getDescription());
       }
     }
 
     $method_control->setError($e_method);
 
     $account_id = $account->getID();
 
+    $params = array(
+      'merchantID' => $merchant->getID(),
+      'cartID' => $cart->getID(),
+    );
+
     $payment_method_uri = $this->getApplicationURI("{$account_id}/card/new/");
-    $payment_method_uri = new PhutilURI($payment_method_uri);
-    $payment_method_uri->setQueryParams(
-      array(
-        'merchantID' => $merchant->getID(),
-        'cartID' => $cart->getID(),
-      ));
+    $payment_method_uri = new PhutilURI($payment_method_uri, $params);
 
     $form = id(new AphrontFormView())
       ->setUser($viewer)
       ->appendChild($method_control);
 
     $add_providers = $this->loadCreatePaymentMethodProvidersForMerchant(
       $merchant);
     if ($add_providers) {
       $new_method = javelin_tag(
         'a',
         array(
           'class' => 'button button-grey',
           'href'  => $payment_method_uri,
         ),
         pht('Add New Payment Method'));
       $form->appendChild(
         id(new AphrontFormMarkupControl())
           ->setValue($new_method));
     }
 
     if ($methods || $add_providers) {
       $submit = id(new AphrontFormSubmitControl())
         ->setValue(pht('Submit Payment'))
         ->setDisabled(!$methods);
 
       if ($cart->getCancelURI() !== null) {
         $submit->addCancelButton($cart->getCancelURI());
       }
 
       $form->appendChild($submit);
     }
 
     $provider_form = null;
 
     $pay_providers = $this->loadOneTimePaymentProvidersForMerchant($merchant);
     if ($pay_providers) {
       $one_time_options = array();
       foreach ($pay_providers as $provider) {
         $one_time_options[] = $provider->renderOneTimePaymentButton(
           $account,
           $cart,
           $viewer);
       }
 
       $one_time_options = phutil_tag(
         'div',
         array(
           'class' => 'phortune-payment-onetime-list',
         ),
         $one_time_options);
 
       $provider_form = new PHUIFormLayoutView();
       $provider_form->appendChild(
         id(new AphrontFormMarkupControl())
           ->setLabel(pht('Pay With'))
           ->setValue($one_time_options));
     }
 
     $payment_box = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Choose Payment Method'))
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->appendChild($form)
       ->appendChild($provider_form);
 
     $description_box = $this->renderCartDescription($cart);
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb(pht('Checkout'));
     $crumbs->addTextCrumb($title);
     $crumbs->setBorder(true);
 
     $header = id(new PHUIHeaderView())
       ->setHeader($title)
       ->setHeaderIcon('fa-shopping-cart');
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setFooter(array(
         $cart_box,
         $description_box,
         $payment_box,
       ));
 
     return $this->newPage()
       ->setTitle($title)
       ->setCrumbs($crumbs)
       ->appendChild($view);
 
   }
 }
diff --git a/src/applications/phortune/provider/PhortunePayPalPaymentProvider.php b/src/applications/phortune/provider/PhortunePayPalPaymentProvider.php
index 078141f8a1..262606ca62 100644
--- a/src/applications/phortune/provider/PhortunePayPalPaymentProvider.php
+++ b/src/applications/phortune/provider/PhortunePayPalPaymentProvider.php
@@ -1,505 +1,507 @@
 <?php
 
 final class PhortunePayPalPaymentProvider extends PhortunePaymentProvider {
 
   const PAYPAL_API_USERNAME   = 'paypal.api-username';
   const PAYPAL_API_PASSWORD   = 'paypal.api-password';
   const PAYPAL_API_SIGNATURE  = 'paypal.api-signature';
   const PAYPAL_MODE           = 'paypal.mode';
 
   public function isAcceptingLivePayments() {
     $mode = $this->getProviderConfig()->getMetadataValue(self::PAYPAL_MODE);
     return ($mode === 'live');
   }
 
   public function getName() {
     return pht('PayPal');
   }
 
   public function getConfigureName() {
     return pht('Add PayPal Payments Account');
   }
 
   public function getConfigureDescription() {
     return pht(
       'Allows you to accept various payment instruments with a paypal.com '.
       'account.');
   }
 
   public function getConfigureProvidesDescription() {
     return pht('This merchant accepts payments via PayPal.');
   }
 
   public function getConfigureInstructions() {
     return pht(
       "To configure PayPal, register or log into an existing account on ".
       "[[https://paypal.com | paypal.com]] (for live payments) or ".
       "[[https://sandbox.paypal.com | sandbox.paypal.com]] (for test ".
       "payments). Once logged in:\n\n".
       "  - Navigate to {nav Tools > API Access}.\n".
       "  - Choose **View API Signature**.\n".
       "  - Copy the **API Username**, **API Password** and **Signature** ".
       "    into the fields above.\n\n".
       "You can select whether the provider operates in test mode or ".
       "accepts live payments using the **Mode** dropdown above.\n\n".
       "You can either use `sandbox.paypal.com` to retrieve live credentials, ".
       "or `paypal.com` to retrieve live credentials.");
   }
 
   public function getAllConfigurableProperties() {
     return array(
       self::PAYPAL_API_USERNAME,
       self::PAYPAL_API_PASSWORD,
       self::PAYPAL_API_SIGNATURE,
       self::PAYPAL_MODE,
     );
   }
 
   public function getAllConfigurableSecretProperties() {
     return array(
       self::PAYPAL_API_PASSWORD,
       self::PAYPAL_API_SIGNATURE,
     );
   }
 
   public function processEditForm(
     AphrontRequest $request,
     array $values) {
 
     $errors = array();
     $issues = array();
 
     if (!strlen($values[self::PAYPAL_API_USERNAME])) {
       $errors[] = pht('PayPal API Username is required.');
       $issues[self::PAYPAL_API_USERNAME] = pht('Required');
     }
 
     if (!strlen($values[self::PAYPAL_API_PASSWORD])) {
       $errors[] = pht('PayPal API Password is required.');
       $issues[self::PAYPAL_API_PASSWORD] = pht('Required');
     }
 
     if (!strlen($values[self::PAYPAL_API_SIGNATURE])) {
       $errors[] = pht('PayPal API Signature is required.');
       $issues[self::PAYPAL_API_SIGNATURE] = pht('Required');
     }
 
     if (!strlen($values[self::PAYPAL_MODE])) {
       $errors[] = pht('Mode is required.');
       $issues[self::PAYPAL_MODE] = pht('Required');
     }
 
     return array($errors, $issues, $values);
   }
 
   public function extendEditForm(
     AphrontRequest $request,
     AphrontFormView $form,
     array $values,
     array $issues) {
 
     $form
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setName(self::PAYPAL_API_USERNAME)
           ->setValue($values[self::PAYPAL_API_USERNAME])
           ->setError(idx($issues, self::PAYPAL_API_USERNAME, true))
           ->setLabel(pht('Paypal API Username')))
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setName(self::PAYPAL_API_PASSWORD)
           ->setValue($values[self::PAYPAL_API_PASSWORD])
           ->setError(idx($issues, self::PAYPAL_API_PASSWORD, true))
           ->setLabel(pht('Paypal API Password')))
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setName(self::PAYPAL_API_SIGNATURE)
           ->setValue($values[self::PAYPAL_API_SIGNATURE])
           ->setError(idx($issues, self::PAYPAL_API_SIGNATURE, true))
           ->setLabel(pht('Paypal API Signature')))
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setName(self::PAYPAL_MODE)
           ->setValue($values[self::PAYPAL_MODE])
           ->setError(idx($issues, self::PAYPAL_MODE))
           ->setLabel(pht('Mode'))
           ->setOptions(
             array(
               'test' => pht('Test Mode'),
               'live' => pht('Live Mode'),
             )));
 
     return;
   }
 
   public function canRunConfigurationTest() {
     return true;
   }
 
   public function runConfigurationTest() {
     $result = $this
       ->newPaypalAPICall()
       ->setRawPayPalQuery('GetBalance', array())
       ->resolve();
   }
 
   public function getPaymentMethodDescription() {
     return pht('Credit Card or PayPal Account');
   }
 
   public function getPaymentMethodIcon() {
     return 'PayPal';
   }
 
   public function getPaymentMethodProviderDescription() {
     return 'PayPal';
   }
 
   protected function executeCharge(
     PhortunePaymentMethod $payment_method,
     PhortuneCharge $charge) {
     throw new Exception('!');
   }
 
   protected function executeRefund(
     PhortuneCharge $charge,
     PhortuneCharge $refund) {
 
     $transaction_id = $charge->getMetadataValue('paypal.transactionID');
     if (!$transaction_id) {
       throw new Exception(pht('Charge has no transaction ID!'));
     }
 
     $refund_amount = $refund->getAmountAsCurrency()->negate();
     $refund_currency = $refund_amount->getCurrency();
     $refund_value = $refund_amount->formatBareValue();
 
     $params = array(
       'TRANSACTIONID' => $transaction_id,
       'REFUNDTYPE' => 'Partial',
       'AMT' => $refund_value,
       'CURRENCYCODE' => $refund_currency,
     );
 
     $result = $this
       ->newPaypalAPICall()
       ->setRawPayPalQuery('RefundTransaction', $params)
       ->resolve();
 
     $charge->setMetadataValue(
       'paypal.refundID',
       $result['REFUNDTRANSACTIONID']);
   }
 
   public function updateCharge(PhortuneCharge $charge) {
     $transaction_id = $charge->getMetadataValue('paypal.transactionID');
     if (!$transaction_id) {
       throw new Exception(pht('Charge has no transaction ID!'));
     }
 
     $params = array(
       'TRANSACTIONID' => $transaction_id,
     );
 
     $result = $this
       ->newPaypalAPICall()
       ->setRawPayPalQuery('GetTransactionDetails', $params)
       ->resolve();
 
     $is_charge = false;
     $is_fail = false;
     switch ($result['PAYMENTSTATUS']) {
       case 'Processed':
       case 'Completed':
       case 'Completed-Funds-Held':
         $is_charge = true;
         break;
       case 'Partially-Refunded':
       case 'Refunded':
       case 'Reversed':
       case 'Canceled-Reversal':
         // TODO: Handle these.
         return;
       case 'In-Progress':
       case 'Pending':
         // TODO: Also handle these better?
         return;
       case 'Denied':
       case 'Expired':
       case 'Failed':
       case 'None':
       case 'Voided':
       default:
         $is_fail = true;
         break;
     }
 
     if ($charge->getStatus() == PhortuneCharge::STATUS_HOLD) {
       $cart = $charge->getCart();
 
       $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
         if ($is_charge) {
           $cart->didApplyCharge($charge);
         } else if ($is_fail) {
           $cart->didFailCharge($charge);
         }
       unset($unguarded);
     }
   }
 
   private function getPaypalAPIUsername() {
     return $this
       ->getProviderConfig()
       ->getMetadataValue(self::PAYPAL_API_USERNAME);
   }
 
   private function getPaypalAPIPassword() {
     return $this
       ->getProviderConfig()
       ->getMetadataValue(self::PAYPAL_API_PASSWORD);
   }
 
   private function getPaypalAPISignature() {
     return $this
       ->getProviderConfig()
       ->getMetadataValue(self::PAYPAL_API_SIGNATURE);
   }
 
 /* -(  One-Time Payments  )-------------------------------------------------- */
 
   public function canProcessOneTimePayments() {
     return true;
   }
 
 /* -(  Controllers  )-------------------------------------------------------- */
 
 
   public function canRespondToControllerAction($action) {
     switch ($action) {
       case 'checkout':
       case 'charge':
       case 'cancel':
         return true;
     }
     return parent::canRespondToControllerAction();
   }
 
   public function processControllerRequest(
     PhortuneProviderActionController $controller,
     AphrontRequest $request) {
 
     $viewer = $request->getUser();
 
     $cart = $controller->loadCart($request->getInt('cartID'));
     if (!$cart) {
       return new Aphront404Response();
     }
 
     $charge = $controller->loadActiveCharge($cart);
     switch ($controller->getAction()) {
       case 'checkout':
         if ($charge) {
           throw new Exception(pht('Cart is already charging!'));
         }
         break;
       case 'charge':
       case 'cancel':
         if (!$charge) {
           throw new Exception(pht('Cart is not charging yet!'));
         }
         break;
     }
 
     switch ($controller->getAction()) {
       case 'checkout':
         $return_uri = $this->getControllerURI(
           'charge',
           array(
             'cartID' => $cart->getID(),
           ));
 
         $cancel_uri = $this->getControllerURI(
           'cancel',
           array(
             'cartID' => $cart->getID(),
           ));
 
         $price = $cart->getTotalPriceAsCurrency();
 
         $charge = $cart->willApplyCharge($viewer, $this);
 
         $params = array(
           'PAYMENTREQUEST_0_AMT'            => $price->formatBareValue(),
           'PAYMENTREQUEST_0_CURRENCYCODE'   => $price->getCurrency(),
           'PAYMENTREQUEST_0_PAYMENTACTION'  => 'Sale',
           'PAYMENTREQUEST_0_CUSTOM'         => $charge->getPHID(),
           'PAYMENTREQUEST_0_DESC'           => $cart->getName(),
 
           'RETURNURL'                       => $return_uri,
           'CANCELURL'                       => $cancel_uri,
 
           // TODO: This should be cart-dependent if we eventually support
           // physical goods.
           'NOSHIPPING'                      => '1',
         );
 
         $result = $this
           ->newPaypalAPICall()
           ->setRawPayPalQuery('SetExpressCheckout', $params)
           ->resolve();
 
-        $uri = new PhutilURI('https://www.sandbox.paypal.com/cgi-bin/webscr');
-        $uri->setQueryParams(
-          array(
-            'cmd'   => '_express-checkout',
-            'token' => $result['TOKEN'],
-          ));
+        $params = array(
+          'cmd'   => '_express-checkout',
+          'token' => $result['TOKEN'],
+        );
+
+        $uri = new PhutilURI(
+          'https://www.sandbox.paypal.com/cgi-bin/webscr',
+          $params);
 
         $cart->setMetadataValue('provider.checkoutURI', (string)$uri);
         $cart->save();
 
         $charge->setMetadataValue('paypal.token', $result['TOKEN']);
         $charge->save();
 
         return id(new AphrontRedirectResponse())
           ->setIsExternal(true)
           ->setURI($uri);
       case 'charge':
         if ($cart->getStatus() !== PhortuneCart::STATUS_PURCHASING) {
           return id(new AphrontRedirectResponse())
             ->setURI($cart->getCheckoutURI());
         }
 
         $token = $request->getStr('token');
 
         $params = array(
           'TOKEN' => $token,
         );
 
         $result = $this
           ->newPaypalAPICall()
           ->setRawPayPalQuery('GetExpressCheckoutDetails', $params)
           ->resolve();
 
         if ($result['CUSTOM'] !== $charge->getPHID()) {
           throw new Exception(
             pht('Paypal checkout does not match Phortune charge!'));
         }
 
         if ($result['CHECKOUTSTATUS'] !== 'PaymentActionNotInitiated') {
           return $controller->newDialog()
             ->setTitle(pht('Payment Already Processed'))
             ->appendParagraph(
               pht(
                 'The payment response for this charge attempt has already '.
                 'been processed.'))
             ->addCancelButton($cart->getCheckoutURI(), pht('Continue'));
         }
 
         $price = $cart->getTotalPriceAsCurrency();
 
         $params = array(
           'TOKEN' => $token,
           'PAYERID' => $result['PAYERID'],
 
           'PAYMENTREQUEST_0_AMT'            => $price->formatBareValue(),
           'PAYMENTREQUEST_0_CURRENCYCODE'   => $price->getCurrency(),
           'PAYMENTREQUEST_0_PAYMENTACTION'  => 'Sale',
         );
 
         $result = $this
           ->newPaypalAPICall()
           ->setRawPayPalQuery('DoExpressCheckoutPayment', $params)
           ->resolve();
 
         $transaction_id = $result['PAYMENTINFO_0_TRANSACTIONID'];
 
         $success = false;
         $hold = false;
         switch ($result['PAYMENTINFO_0_PAYMENTSTATUS']) {
           case 'Processed':
           case 'Completed':
           case 'Completed-Funds-Held':
             $success = true;
             break;
           case 'In-Progress':
           case 'Pending':
             // TODO: We can capture more information about this stuff.
             $hold = true;
             break;
           case 'Denied':
           case 'Expired':
           case 'Failed':
           case 'Partially-Refunded':
           case 'Canceled-Reversal':
           case 'None':
           case 'Refunded':
           case 'Reversed':
           case 'Voided':
           default:
             // These are all failure states.
             break;
         }
 
         $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
 
           $charge->setMetadataValue('paypal.transactionID', $transaction_id);
           $charge->save();
 
           if ($success) {
             $cart->didApplyCharge($charge);
             $response = id(new AphrontRedirectResponse())->setURI(
               $cart->getCheckoutURI());
           } else if ($hold) {
             $cart->didHoldCharge($charge);
 
             $response = $controller
               ->newDialog()
               ->setTitle(pht('Charge On Hold'))
               ->appendParagraph(
                 pht('Your charge is on hold, for reasons?'))
               ->addCancelButton($cart->getCheckoutURI(), pht('Continue'));
           } else {
             $cart->didFailCharge($charge);
 
             $response = $controller
               ->newDialog()
               ->setTitle(pht('Charge Failed'))
               ->addCancelButton($cart->getCheckoutURI(), pht('Continue'));
           }
         unset($unguarded);
 
         return $response;
       case 'cancel':
         if ($cart->getStatus() === PhortuneCart::STATUS_PURCHASING) {
           $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
             // TODO: Since the user cancelled this, we could conceivably just
             // throw it away or make it more clear that it's a user cancel.
             $cart->didFailCharge($charge);
           unset($unguarded);
         }
 
         return id(new AphrontRedirectResponse())
           ->setURI($cart->getCheckoutURI());
     }
 
     throw new Exception(
       pht('Unsupported action "%s".', $controller->getAction()));
   }
 
   private function newPaypalAPICall() {
     if ($this->isAcceptingLivePayments()) {
       $host = 'https://api-3t.paypal.com/nvp';
     } else {
       $host = 'https://api-3t.sandbox.paypal.com/nvp';
     }
 
     return id(new PhutilPayPalAPIFuture())
       ->setHost($host)
       ->setAPIUsername($this->getPaypalAPIUsername())
       ->setAPIPassword($this->getPaypalAPIPassword())
       ->setAPISignature($this->getPaypalAPISignature());
   }
 
 
 }
diff --git a/src/applications/phortune/provider/PhortunePaymentProvider.php b/src/applications/phortune/provider/PhortunePaymentProvider.php
index 90e354c5dc..57b2956ecb 100644
--- a/src/applications/phortune/provider/PhortunePaymentProvider.php
+++ b/src/applications/phortune/provider/PhortunePaymentProvider.php
@@ -1,296 +1,295 @@
 <?php
 
 /**
  * @task addmethod  Adding Payment Methods
  */
 abstract class PhortunePaymentProvider extends Phobject {
 
   private $providerConfig;
 
   public function setProviderConfig(
     PhortunePaymentProviderConfig $provider_config) {
     $this->providerConfig = $provider_config;
     return $this;
   }
 
   public function getProviderConfig() {
     return $this->providerConfig;
   }
 
   /**
    * Return a short name which identifies this provider.
    */
   abstract public function getName();
 
 
 /* -(  Configuring Providers  )---------------------------------------------- */
 
 
   /**
    * Return a human-readable provider name for use on the merchant workflow
    * where a merchant owner adds providers.
    */
   abstract public function getConfigureName();
 
 
   /**
    * Return a human-readable provider description for use on the merchant
    * workflow where a merchant owner adds providers.
    */
   abstract public function getConfigureDescription();
 
   abstract public function getConfigureInstructions();
 
   abstract public function getConfigureProvidesDescription();
 
   abstract public function getAllConfigurableProperties();
 
   abstract public function getAllConfigurableSecretProperties();
   /**
    * Read a dictionary of properties from the provider's configuration for
    * use when editing the provider.
    */
   public function readEditFormValuesFromProviderConfig() {
     $properties = $this->getAllConfigurableProperties();
     $config = $this->getProviderConfig();
 
     $secrets = $this->getAllConfigurableSecretProperties();
     $secrets = array_fuse($secrets);
 
     $map = array();
     foreach ($properties as $property) {
       $map[$property] = $config->getMetadataValue($property);
       if (isset($secrets[$property])) {
         $map[$property] = $this->renderConfigurationSecret($map[$property]);
       }
     }
 
     return $map;
   }
 
 
   /**
    * Read a dictionary of properties from a request for use when editing the
    * provider.
    */
   public function readEditFormValuesFromRequest(AphrontRequest $request) {
     $properties = $this->getAllConfigurableProperties();
 
     $map = array();
     foreach ($properties as $property) {
       $map[$property] = $request->getStr($property);
     }
 
     return $map;
   }
 
 
   abstract public function processEditForm(
     AphrontRequest $request,
     array $values);
 
   abstract public function extendEditForm(
     AphrontRequest $request,
     AphrontFormView $form,
     array $values,
     array $issues);
 
   protected function renderConfigurationSecret($value) {
     if (strlen($value)) {
       return str_repeat('*', strlen($value));
     }
     return '';
   }
 
   public function isConfigurationSecret($value) {
     return preg_match('/^\*+\z/', trim($value));
   }
 
   abstract public function canRunConfigurationTest();
 
   public function runConfigurationTest() {
     throw new PhutilMethodNotImplementedException();
   }
 
 
 /* -(  Selecting Providers  )------------------------------------------------ */
 
 
   public static function getAllProviders() {
     return id(new PhutilClassMapQuery())
       ->setAncestorClass(__CLASS__)
       ->execute();
   }
 
   public function isEnabled() {
     return $this->getProviderConfig()->getIsEnabled();
   }
 
   abstract public function isAcceptingLivePayments();
   abstract public function getPaymentMethodDescription();
   abstract public function getPaymentMethodIcon();
   abstract public function getPaymentMethodProviderDescription();
 
   final public function applyCharge(
     PhortunePaymentMethod $payment_method,
     PhortuneCharge $charge) {
     $this->executeCharge($payment_method, $charge);
   }
 
   final public function refundCharge(
     PhortuneCharge $charge,
     PhortuneCharge $refund) {
     $this->executeRefund($charge, $refund);
   }
 
   abstract protected function executeCharge(
     PhortunePaymentMethod $payment_method,
     PhortuneCharge $charge);
 
   abstract protected function executeRefund(
     PhortuneCharge $charge,
     PhortuneCharge $refund);
 
   abstract public function updateCharge(PhortuneCharge $charge);
 
 
 /* -(  Adding Payment Methods  )--------------------------------------------- */
 
 
   /**
    * @task addmethod
    */
   public function canCreatePaymentMethods() {
     return false;
   }
 
 
   /**
    * @task addmethod
    */
   public function translateCreatePaymentMethodErrorCode($error_code) {
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * @task addmethod
    */
   public function getCreatePaymentMethodErrorMessage($error_code) {
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * @task addmethod
    */
   public function validateCreatePaymentMethodToken(array $token) {
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * @task addmethod
    */
   public function createPaymentMethodFromRequest(
     AphrontRequest $request,
     PhortunePaymentMethod $method,
     array $token) {
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * @task addmethod
    */
   public function renderCreatePaymentMethodForm(
     AphrontRequest $request,
     array $errors) {
     throw new PhutilMethodNotImplementedException();
   }
 
   public function getDefaultPaymentMethodDisplayName(
     PhortunePaymentMethod $method) {
     throw new PhutilMethodNotImplementedException();
   }
 
 
 /* -(  One-Time Payments  )-------------------------------------------------- */
 
 
   public function canProcessOneTimePayments() {
     return false;
   }
 
   public function renderOneTimePaymentButton(
     PhortuneAccount $account,
     PhortuneCart $cart,
     PhabricatorUser $user) {
 
     require_celerity_resource('phortune-css');
 
     $description = $this->getPaymentMethodProviderDescription();
     $details = $this->getPaymentMethodDescription();
 
     $icon = id(new PHUIIconView())
       ->setSpriteSheet(PHUIIconView::SPRITE_LOGIN)
       ->setSpriteIcon($this->getPaymentMethodIcon());
 
     $button = id(new PHUIButtonView())
       ->setSize(PHUIButtonView::BIG)
       ->setColor(PHUIButtonView::GREY)
       ->setIcon($icon)
       ->setText($description)
       ->setSubtext($details);
 
     // NOTE: We generate a local URI to make sure the form picks up CSRF tokens.
     $uri = $this->getControllerURI(
       'checkout',
       array(
         'cartID' => $cart->getID(),
       ),
       $local = true);
 
     return phabricator_form(
       $user,
       array(
         'action' => $uri,
         'method' => 'POST',
       ),
       $button);
   }
 
 
 /* -(  Controllers  )-------------------------------------------------------- */
 
 
   final public function getControllerURI(
     $action,
     array $params = array(),
     $local = false) {
 
     $id = $this->getProviderConfig()->getID();
     $app = PhabricatorApplication::getByClass('PhabricatorPhortuneApplication');
     $path = $app->getBaseURI().'provider/'.$id.'/'.$action.'/';
 
-    $uri = new PhutilURI($path);
-    $uri->setQueryParams($params);
+    $uri = new PhutilURI($path, $params);
 
     if ($local) {
       return $uri;
     } else {
       return PhabricatorEnv::getURI((string)$uri);
     }
   }
 
   public function canRespondToControllerAction($action) {
     return false;
   }
 
   public function processControllerRequest(
     PhortuneProviderActionController $controller,
     AphrontRequest $request) {
     throw new PhutilMethodNotImplementedException();
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepository.php b/src/applications/repository/storage/PhabricatorRepository.php
index e66fb78afa..d5ad83b6d6 100644
--- a/src/applications/repository/storage/PhabricatorRepository.php
+++ b/src/applications/repository/storage/PhabricatorRepository.php
@@ -1,2849 +1,2843 @@
 <?php
 
 /**
  * @task uri        Repository URI Management
  * @task autoclose  Autoclose
  * @task sync       Cluster Synchronization
  */
 final class PhabricatorRepository extends PhabricatorRepositoryDAO
   implements
     PhabricatorApplicationTransactionInterface,
     PhabricatorPolicyInterface,
     PhabricatorFlaggableInterface,
     PhabricatorMarkupInterface,
     PhabricatorDestructibleInterface,
     PhabricatorDestructibleCodexInterface,
     PhabricatorProjectInterface,
     PhabricatorSpacesInterface,
     PhabricatorConduitResultInterface,
     PhabricatorFulltextInterface,
     PhabricatorFerretInterface {
 
   /**
    * 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;
 
   /**
    * Minimum number of commits to an empty repository to trigger "import" mode.
    */
   const IMPORT_THRESHOLD = 7;
 
   const TABLE_PATH = 'repository_path';
   const TABLE_PATHCHANGE = 'repository_pathchange';
   const TABLE_FILESYSTEM = 'repository_filesystem';
   const TABLE_SUMMARY = 'repository_summary';
   const TABLE_LINTMESSAGE = 'repository_lintmessage';
   const TABLE_PARENTS = 'repository_parents';
   const TABLE_COVERAGE = 'repository_coverage';
 
   const BECAUSE_REPOSITORY_IMPORTING = 'auto/importing';
   const BECAUSE_AUTOCLOSE_DISABLED = 'auto/disabled';
   const BECAUSE_NOT_ON_AUTOCLOSE_BRANCH = 'auto/nobranch';
   const BECAUSE_BRANCH_UNTRACKED = 'auto/notrack';
   const BECAUSE_BRANCH_NOT_AUTOCLOSE = 'auto/noclose';
   const BECAUSE_AUTOCLOSE_FORCED = 'auto/forced';
 
   const STATUS_ACTIVE = 'active';
   const STATUS_INACTIVE = 'inactive';
 
   protected $name;
   protected $callsign;
   protected $repositorySlug;
   protected $uuid;
   protected $viewPolicy;
   protected $editPolicy;
   protected $pushPolicy;
   protected $profileImagePHID;
 
   protected $versionControlSystem;
   protected $details = array();
   protected $credentialPHID;
   protected $almanacServicePHID;
   protected $spacePHID;
   protected $localPath;
 
   private $commitCount = self::ATTACHABLE;
   private $mostRecentCommit = self::ATTACHABLE;
   private $projectPHIDs = self::ATTACHABLE;
   private $uris = self::ATTACHABLE;
   private $profileImageFile = self::ATTACHABLE;
 
 
   public static function initializeNewRepository(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorDiffusionApplication'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(DiffusionDefaultViewCapability::CAPABILITY);
     $edit_policy = $app->getPolicy(DiffusionDefaultEditCapability::CAPABILITY);
     $push_policy = $app->getPolicy(DiffusionDefaultPushCapability::CAPABILITY);
 
     $repository = id(new PhabricatorRepository())
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setPushPolicy($push_policy)
       ->setSpacePHID($actor->getDefaultSpacePHID());
 
     // Put the repository in "Importing" mode until we finish
     // parsing it.
     $repository->setDetail('importing', true);
 
     return $repository;
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'details' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'sort255',
         'callsign' => 'sort32?',
         'repositorySlug' => 'sort64?',
         'versionControlSystem' => 'text32',
         'uuid' => 'text64?',
         'pushPolicy' => 'policy',
         'credentialPHID' => 'phid?',
         'almanacServicePHID' => 'phid?',
         'localPath' => 'text128?',
         'profileImagePHID' => 'phid?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'callsign' => array(
           'columns' => array('callsign'),
           'unique' => true,
         ),
         'key_name' => array(
           'columns' => array('name(128)'),
         ),
         'key_vcs' => array(
           'columns' => array('versionControlSystem'),
         ),
         'key_slug' => array(
           'columns' => array('repositorySlug'),
           'unique' => true,
         ),
         'key_local' => array(
           'columns' => array('localPath'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorRepositoryRepositoryPHIDType::TYPECONST);
   }
 
   public static function getStatusMap() {
     return array(
       self::STATUS_ACTIVE => array(
         'name' => pht('Active'),
         'isTracked' => 1,
       ),
       self::STATUS_INACTIVE => array(
         'name' => pht('Inactive'),
         'isTracked' => 0,
       ),
     );
   }
 
   public static function getStatusNameMap() {
     return ipull(self::getStatusMap(), 'name');
   }
 
   public function getStatus() {
     if ($this->isTracked()) {
       return self::STATUS_ACTIVE;
     } else {
       return self::STATUS_INACTIVE;
     }
   }
 
   public function toDictionary() {
     return array(
       'id'          => $this->getID(),
       'name'        => $this->getName(),
       'phid'        => $this->getPHID(),
       'callsign'    => $this->getCallsign(),
       'monogram'    => $this->getMonogram(),
       'vcs'         => $this->getVersionControlSystem(),
       'uri'         => PhabricatorEnv::getProductionURI($this->getURI()),
       'remoteURI'   => (string)$this->getRemoteURI(),
       'description' => $this->getDetail('description'),
       'isActive'    => $this->isTracked(),
       'isHosted'    => $this->isHosted(),
       'isImporting' => $this->isImporting(),
       'encoding'    => $this->getDefaultTextEncoding(),
       'staging' => array(
         'supported' => $this->supportsStaging(),
         'prefix' => 'phabricator',
         'uri' => $this->getStagingURI(),
       ),
     );
   }
 
   public function getDefaultTextEncoding() {
     return $this->getDetail('encoding', 'UTF-8');
   }
 
   public function getMonogram() {
     $callsign = $this->getCallsign();
     if (strlen($callsign)) {
       return "r{$callsign}";
     }
 
     $id = $this->getID();
     return "R{$id}";
   }
 
   public function getDisplayName() {
     $slug = $this->getRepositorySlug();
     if (strlen($slug)) {
       return $slug;
     }
 
     return $this->getMonogram();
   }
 
   public function getAllMonograms() {
     $monograms = array();
 
     $monograms[] = 'R'.$this->getID();
 
     $callsign = $this->getCallsign();
     if (strlen($callsign)) {
       $monograms[] = 'r'.$callsign;
     }
 
     return $monograms;
   }
 
   public function setLocalPath($path) {
     // Convert any extra slashes ("//") in the path to a single slash ("/").
     $path = preg_replace('(//+)', '/', $path);
 
     return parent::setLocalPath($path);
   }
 
   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 attachCommitCount($count) {
     $this->commitCount = $count;
     return $this;
   }
 
   public function getCommitCount() {
     return $this->assertAttached($this->commitCount);
   }
 
   public function attachMostRecentCommit(
     PhabricatorRepositoryCommit $commit = null) {
     $this->mostRecentCommit = $commit;
     return $this;
   }
 
   public function getMostRecentCommit() {
     return $this->assertAttached($this->mostRecentCommit);
   }
 
   public function getDiffusionBrowseURIForPath(
     PhabricatorUser $user,
     $path,
     $line = null,
     $branch = null) {
 
     $drequest = DiffusionRequest::newFromDictionary(
       array(
         'user' => $user,
         'repository' => $this,
         'path' => $path,
         'branch' => $branch,
       ));
 
     return $drequest->generateURI(
       array(
         'action' => 'browse',
         'line'   => $line,
       ));
   }
 
   public function getSubversionBaseURI($commit = null) {
     $subpath = $this->getDetail('svn-subpath');
     if (!strlen($subpath)) {
       $subpath = null;
     }
     return $this->getSubversionPathURI($subpath, $commit);
   }
 
   public function getSubversionPathURI($path = null, $commit = null) {
     $vcs = $this->getVersionControlSystem();
     if ($vcs != PhabricatorRepositoryType::REPOSITORY_TYPE_SVN) {
       throw new Exception(pht('Not a subversion repository!'));
     }
 
     if ($this->isHosted()) {
       $uri = 'file://'.$this->getLocalPath();
     } else {
       $uri = $this->getDetail('remote-uri');
     }
 
     $uri = rtrim($uri, '/');
 
     if (strlen($path)) {
       $path = rawurlencode($path);
       $path = str_replace('%2F', '/', $path);
       $uri = $uri.'/'.ltrim($path, '/');
     }
 
     if ($path !== null || $commit !== null) {
       $uri .= '@';
     }
 
     if ($commit !== null) {
       $uri .= $commit;
     }
 
     return $uri;
   }
 
   public function attachProjectPHIDs(array $project_phids) {
     $this->projectPHIDs = $project_phids;
     return $this;
   }
 
   public function getProjectPHIDs() {
     return $this->assertAttached($this->projectPHIDs);
   }
 
 
   /**
    * Get the name of the directory this repository should clone or checkout
    * into. For example, if the repository name is "Example Repository", a
    * reasonable name might be "example-repository". This is used to help users
    * get reasonable results when cloning repositories, since they generally do
    * not want to clone into directories called "X/" or "Example Repository/".
    *
    * @return string
    */
   public function getCloneName() {
     $name = $this->getRepositorySlug();
 
     // Make some reasonable effort to produce reasonable default directory
     // names from repository names.
     if (!strlen($name)) {
       $name = $this->getName();
       $name = phutil_utf8_strtolower($name);
       $name = preg_replace('@[ -/:->]+@', '-', $name);
       $name = trim($name, '-');
       if (!strlen($name)) {
         $name = $this->getCallsign();
       }
     }
 
     return $name;
   }
 
   public static function isValidRepositorySlug($slug) {
     try {
       self::assertValidRepositorySlug($slug);
       return true;
     } catch (Exception $ex) {
       return false;
     }
   }
 
   public static function assertValidRepositorySlug($slug) {
     if (!strlen($slug)) {
       throw new Exception(
         pht(
           'The empty string is not a valid repository short name. '.
           'Repository short names must be at least one character long.'));
     }
 
     if (strlen($slug) > 64) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names must not be longer than 64 characters.',
           $slug));
     }
 
     if (preg_match('/[^a-zA-Z0-9._-]/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names may only contain letters, numbers, periods, hyphens '.
           'and underscores.',
           $slug));
     }
 
     if (!preg_match('/^[a-zA-Z0-9]/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names must begin with a letter or number.',
           $slug));
     }
 
     if (!preg_match('/[a-zA-Z0-9]\z/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names must end with a letter or number.',
           $slug));
     }
 
     if (preg_match('/__|--|\\.\\./', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names must not contain multiple consecutive underscores, '.
           'hyphens, or periods.',
           $slug));
     }
 
     if (preg_match('/^[A-Z]+\z/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names may not contain only uppercase letters.',
           $slug));
     }
 
     if (preg_match('/^\d+\z/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names may not contain only numbers.',
           $slug));
     }
 
     if (preg_match('/\\.git/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names must not end in ".git". This suffix will be added '.
           'automatically in appropriate contexts.',
           $slug));
     }
   }
 
   public static function assertValidCallsign($callsign) {
     if (!strlen($callsign)) {
       throw new Exception(
         pht(
           'A repository callsign must be at least one character long.'));
     }
 
     if (strlen($callsign) > 32) {
       throw new Exception(
         pht(
           'The callsign "%s" is not a valid repository callsign. Callsigns '.
           'must be no more than 32 bytes long.',
           $callsign));
     }
 
     if (!preg_match('/^[A-Z]+\z/', $callsign)) {
       throw new Exception(
         pht(
           'The callsign "%s" is not a valid repository callsign. Callsigns '.
           'may only contain UPPERCASE letters.',
           $callsign));
     }
   }
 
   public function getProfileImageURI() {
     return $this->getProfileImageFile()->getBestURI();
   }
 
   public function attachProfileImageFile(PhabricatorFile $file) {
     $this->profileImageFile = $file;
     return $this;
   }
 
   public function getProfileImageFile() {
     return $this->assertAttached($this->profileImageFile);
   }
 
 
 
 /* -(  Remote Command Execution  )------------------------------------------- */
 
 
   public function execRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandFuture($args)->resolve();
   }
 
   public function execxRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandFuture($args)->resolvex();
   }
 
   public function getRemoteCommandFuture($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandFuture($args);
   }
 
   public function passthruRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandPassthru($args)->execute();
   }
 
   private function newRemoteCommandFuture(array $argv) {
     return $this->newRemoteCommandEngine($argv)
       ->newFuture();
   }
 
   private function newRemoteCommandPassthru(array $argv) {
     return $this->newRemoteCommandEngine($argv)
       ->setPassthru(true)
       ->newFuture();
   }
 
   private function newRemoteCommandEngine(array $argv) {
     return DiffusionCommandEngine::newCommandEngine($this)
       ->setArgv($argv)
       ->setCredentialPHID($this->getCredentialPHID())
       ->setURI($this->getRemoteURIObject());
   }
 
 /* -(  Local Command Execution  )-------------------------------------------- */
 
 
   public function execLocalCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandFuture($args)->resolve();
   }
 
   public function execxLocalCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandFuture($args)->resolvex();
   }
 
   public function getLocalCommandFuture($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandFuture($args);
   }
 
   public function passthruLocalCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandPassthru($args)->execute();
   }
 
   private function newLocalCommandFuture(array $argv) {
     $this->assertLocalExists();
 
     $future = DiffusionCommandEngine::newCommandEngine($this)
       ->setArgv($argv)
       ->newFuture();
 
     if ($this->usesLocalWorkingCopy()) {
       $future->setCWD($this->getLocalPath());
     }
 
     return $future;
   }
 
   private function newLocalCommandPassthru(array $argv) {
     $this->assertLocalExists();
 
     $future = DiffusionCommandEngine::newCommandEngine($this)
       ->setArgv($argv)
       ->setPassthru(true)
       ->newFuture();
 
     if ($this->usesLocalWorkingCopy()) {
       $future->setCWD($this->getLocalPath());
     }
 
     return $future;
   }
 
   public function getURI() {
     $short_name = $this->getRepositorySlug();
     if (strlen($short_name)) {
       return "/source/{$short_name}/";
     }
 
     $callsign = $this->getCallsign();
     if (strlen($callsign)) {
       return "/diffusion/{$callsign}/";
     }
 
     $id = $this->getID();
     return "/diffusion/{$id}/";
   }
 
   public function getPathURI($path) {
     return $this->getURI().ltrim($path, '/');
   }
 
   public function getCommitURI($identifier) {
     $callsign = $this->getCallsign();
     if (strlen($callsign)) {
       return "/r{$callsign}{$identifier}";
     }
 
     $id = $this->getID();
     return "/R{$id}:{$identifier}";
   }
 
   public static function parseRepositoryServicePath($request_path, $vcs) {
     $is_git = ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
 
     $patterns = array(
       '(^'.
         '(?P<base>/?(?:diffusion|source)/(?P<identifier>[^/]+))'.
         '(?P<path>.*)'.
       '\z)',
     );
 
     $identifier = null;
     foreach ($patterns as $pattern) {
       $matches = null;
       if (!preg_match($pattern, $request_path, $matches)) {
         continue;
       }
 
       $identifier = $matches['identifier'];
       if ($is_git) {
         $identifier = preg_replace('/\\.git\z/', '', $identifier);
       }
 
       $base = $matches['base'];
       $path = $matches['path'];
       break;
     }
 
     if ($identifier === null) {
       return null;
     }
 
     return array(
       'identifier' => $identifier,
       'base' => $base,
       'path' => $path,
     );
   }
 
   public function getCanonicalPath($request_path) {
     $standard_pattern =
       '(^'.
         '(?P<prefix>/(?:diffusion|source)/)'.
         '(?P<identifier>[^/]+)'.
         '(?P<suffix>(?:/.*)?)'.
       '\z)';
 
     $matches = null;
     if (preg_match($standard_pattern, $request_path, $matches)) {
       $suffix = $matches['suffix'];
       return $this->getPathURI($suffix);
     }
 
     $commit_pattern =
       '(^'.
         '(?P<prefix>/)'.
         '(?P<monogram>'.
           '(?:'.
             'r(?P<repositoryCallsign>[A-Z]+)'.
             '|'.
             'R(?P<repositoryID>[1-9]\d*):'.
           ')'.
           '(?P<commit>[a-f0-9]+)'.
         ')'.
       '\z)';
 
     $matches = null;
     if (preg_match($commit_pattern, $request_path, $matches)) {
       $commit = $matches['commit'];
       return $this->getCommitURI($commit);
     }
 
     return null;
   }
 
   public function generateURI(array $params) {
     $req_branch = false;
     $req_commit = false;
 
     $action = idx($params, 'action');
     switch ($action) {
       case 'history':
       case 'graph':
       case 'clone':
       case 'blame':
       case 'browse':
       case 'document':
       case 'change':
       case 'lastmodified':
       case 'tags':
       case 'branches':
       case 'lint':
       case 'pathtree':
       case 'refs':
       case 'compare':
         break;
       case 'branch':
         // NOTE: This does not actually require a branch, and won't have one
         // in Subversion. Possibly this should be more clear.
         break;
       case 'commit':
       case 'rendering-ref':
         $req_commit = true;
         break;
       default:
         throw new Exception(
           pht(
             'Action "%s" is not a valid repository URI action.',
             $action));
     }
 
     $path     = idx($params, 'path');
     $branch   = idx($params, 'branch');
     $commit   = idx($params, 'commit');
     $line     = idx($params, 'line');
 
     $head = idx($params, 'head');
     $against = idx($params, 'against');
 
     if ($req_commit && !strlen($commit)) {
       throw new Exception(
         pht(
           'Diffusion URI action "%s" requires commit!',
           $action));
     }
 
     if ($req_branch && !strlen($branch)) {
       throw new Exception(
         pht(
           'Diffusion URI action "%s" requires branch!',
           $action));
     }
 
     if ($action === 'commit') {
       return $this->getCommitURI($commit);
     }
 
     if (strlen($path)) {
       $path = ltrim($path, '/');
       $path = str_replace(array(';', '$'), array(';;', '$$'), $path);
       $path = phutil_escape_uri($path);
     }
 
     $raw_branch = $branch;
     if (strlen($branch)) {
       $branch = phutil_escape_uri_path_component($branch);
       $path = "{$branch}/{$path}";
     }
 
     $raw_commit = $commit;
     if (strlen($commit)) {
       $commit = str_replace('$', '$$', $commit);
       $commit = ';'.phutil_escape_uri($commit);
     }
 
     if (strlen($line)) {
       $line = '$'.phutil_escape_uri($line);
     }
 
     $query = array();
     switch ($action) {
       case 'change':
       case 'history':
       case 'graph':
       case 'blame':
       case 'browse':
       case 'document':
       case 'lastmodified':
       case 'tags':
       case 'branches':
       case 'lint':
       case 'pathtree':
       case 'refs':
         $uri = $this->getPathURI("/{$action}/{$path}{$commit}{$line}");
         break;
       case 'compare':
         $uri = $this->getPathURI("/{$action}/");
         if (strlen($head)) {
           $query['head'] = $head;
         } else if (strlen($raw_commit)) {
           $query['commit'] = $raw_commit;
         } else if (strlen($raw_branch)) {
           $query['head'] = $raw_branch;
         }
 
         if (strlen($against)) {
           $query['against'] = $against;
         }
         break;
       case 'branch':
         if (strlen($path)) {
           $uri = $this->getPathURI("/repository/{$path}");
         } else {
           $uri = $this->getPathURI('/');
         }
         break;
       case 'external':
         $commit = ltrim($commit, ';');
         $uri = "/diffusion/external/{$commit}/";
         break;
       case 'rendering-ref':
         // This isn't a real URI per se, it's passed as a query parameter to
         // the ajax changeset stuff but then we parse it back out as though
         // it came from a URI.
         $uri = rawurldecode("{$path}{$commit}");
         break;
       case 'clone':
         $uri = $this->getPathURI("/{$action}/");
       break;
     }
 
     if ($action == 'rendering-ref') {
       return $uri;
     }
 
-    $uri = new PhutilURI($uri);
-
     if (isset($params['lint'])) {
       $params['params'] = idx($params, 'params', array()) + array(
         'lint' => $params['lint'],
       );
     }
 
     $query = idx($params, 'params', array()) + $query;
 
-    if ($query) {
-      $uri->setQueryParams($query);
-    }
-
-    return $uri;
+    return new PhutilURI($uri, $query);
   }
 
   public function updateURIIndex() {
     $indexes = array();
 
     $uris = $this->getURIs();
     foreach ($uris as $uri) {
       if ($uri->getIsDisabled()) {
         continue;
       }
 
       $indexes[] = $uri->getNormalizedURI();
     }
 
     PhabricatorRepositoryURIIndex::updateRepositoryURIs(
       $this->getPHID(),
       $indexes);
 
     return $this;
   }
 
   public function isTracked() {
     $status = $this->getDetail('tracking-enabled');
     $map = self::getStatusMap();
     $spec = idx($map, $status);
 
     if (!$spec) {
       if ($status) {
         $status = self::STATUS_ACTIVE;
       } else {
         $status = self::STATUS_INACTIVE;
       }
       $spec = idx($map, $status);
     }
 
     return (bool)idx($spec, 'isTracked', 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) {
       // If this VCS doesn't use filters, pass everything through.
       return true;
     }
 
 
     $filter = $this->getDetail($filter_key, array());
 
     // If there's no filter set, let everything through.
     if (!$filter) {
       return true;
     }
 
     // If this branch isn't literally named `regexp(...)`, and it's in the
     // filter list, let it through.
     if (isset($filter[$branch])) {
       if (self::extractBranchRegexp($branch) === null) {
         return true;
       }
     }
 
     // If the branch matches a regexp, let it through.
     foreach ($filter as $pattern => $ignored) {
       $regexp = self::extractBranchRegexp($pattern);
       if ($regexp !== null) {
         if (preg_match($regexp, $branch)) {
           return true;
         }
       }
     }
 
     // Nothing matched, so filter this branch out.
     return false;
   }
 
   public static function extractBranchRegexp($pattern) {
     $matches = null;
     if (preg_match('/^regexp\\((.*)\\)\z/', $pattern, $matches)) {
       return $matches[1];
     }
     return null;
   }
 
   public function shouldTrackRef(DiffusionRepositoryRef $ref) {
     // At least for now, don't track the staging area tags.
     if ($ref->isTag()) {
       if (preg_match('(^phabricator/)', $ref->getShortName())) {
         return false;
       }
     }
 
     if (!$ref->isBranch()) {
       return true;
     }
 
     return $this->shouldTrackBranch($ref->getShortName());
   }
 
   public function shouldTrackBranch($branch) {
     return $this->isBranchInFilter($branch, 'branch-filter');
   }
 
   public function formatCommitName($commit_identifier, $local = false) {
     $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) {
       $name = substr($commit_identifier, 0, 12);
       $need_scope = false;
     } else {
       $name = $commit_identifier;
       $need_scope = true;
     }
 
     if (!$local) {
       $need_scope = true;
     }
 
     if ($need_scope) {
       $callsign = $this->getCallsign();
       if ($callsign) {
         $scope = "r{$callsign}";
       } else {
         $id = $this->getID();
         $scope = "R{$id}:";
       }
       $name = $scope.$name;
     }
 
     return $name;
   }
 
   public function isImporting() {
     return (bool)$this->getDetail('importing', false);
   }
 
   public function isNewlyInitialized() {
     return (bool)$this->getDetail('newly-initialized', false);
   }
 
   public function loadImportProgress() {
     $progress = queryfx_all(
       $this->establishConnection('r'),
       'SELECT importStatus, count(*) N FROM %T WHERE repositoryID = %d
         GROUP BY importStatus',
       id(new PhabricatorRepositoryCommit())->getTableName(),
       $this->getID());
 
     $done = 0;
     $total = 0;
     foreach ($progress as $row) {
       $total += $row['N'] * 4;
       $status = $row['importStatus'];
       if ($status & PhabricatorRepositoryCommit::IMPORTED_MESSAGE) {
         $done += $row['N'];
       }
       if ($status & PhabricatorRepositoryCommit::IMPORTED_CHANGE) {
         $done += $row['N'];
       }
       if ($status & PhabricatorRepositoryCommit::IMPORTED_OWNERS) {
         $done += $row['N'];
       }
       if ($status & PhabricatorRepositoryCommit::IMPORTED_HERALD) {
         $done += $row['N'];
       }
     }
 
     if ($total) {
       $ratio = ($done / $total);
     } else {
       $ratio = 0;
     }
 
     // Cap this at "99.99%", because it's confusing to users when the actual
     // fraction is "99.996%" and it rounds up to "100.00%".
     if ($ratio > 0.9999) {
       $ratio = 0.9999;
     }
 
     return $ratio;
   }
 
   /**
    * Should this repository publish feed, notifications, audits, and email?
    *
    * We do not publish information about repositories during initial import,
    * or if the repository has been set not to publish.
    */
   public function shouldPublish() {
     if ($this->isImporting()) {
       return false;
     }
 
     if ($this->getDetail('herald-disabled')) {
       return false;
     }
 
     return true;
   }
 
 
 /* -(  Autoclose  )---------------------------------------------------------- */
 
 
   public function shouldAutocloseRef(DiffusionRepositoryRef $ref) {
     if (!$ref->isBranch()) {
       return false;
     }
 
     return $this->shouldAutocloseBranch($ref->getShortName());
   }
 
   /**
    * Determine if autoclose is active for a branch.
    *
    * For more details about why, use @{method:shouldSkipAutocloseBranch}.
    *
    * @param string Branch name to check.
    * @return bool True if autoclose is active for the branch.
    * @task autoclose
    */
   public function shouldAutocloseBranch($branch) {
     return ($this->shouldSkipAutocloseBranch($branch) === null);
   }
 
   /**
    * Determine if autoclose is active for a commit.
    *
    * For more details about why, use @{method:shouldSkipAutocloseCommit}.
    *
    * @param PhabricatorRepositoryCommit Commit to check.
    * @return bool True if autoclose is active for the commit.
    * @task autoclose
    */
   public function shouldAutocloseCommit(PhabricatorRepositoryCommit $commit) {
     return ($this->shouldSkipAutocloseCommit($commit) === null);
   }
 
 
   /**
    * Determine why autoclose should be skipped for a branch.
    *
    * This method gives a detailed reason why autoclose will be skipped. To
    * perform a simple test, use @{method:shouldAutocloseBranch}.
    *
    * @param string Branch name to check.
    * @return const|null Constant identifying reason to skip this branch, or null
    *   if autoclose is active.
    * @task autoclose
    */
   public function shouldSkipAutocloseBranch($branch) {
     $all_reason = $this->shouldSkipAllAutoclose();
     if ($all_reason) {
       return $all_reason;
     }
 
     if (!$this->shouldTrackBranch($branch)) {
       return self::BECAUSE_BRANCH_UNTRACKED;
     }
 
     if (!$this->isBranchInFilter($branch, 'close-commits-filter')) {
       return self::BECAUSE_BRANCH_NOT_AUTOCLOSE;
     }
 
     return null;
   }
 
 
   /**
    * Determine why autoclose should be skipped for a commit.
    *
    * This method gives a detailed reason why autoclose will be skipped. To
    * perform a simple test, use @{method:shouldAutocloseCommit}.
    *
    * @param PhabricatorRepositoryCommit Commit to check.
    * @return const|null Constant identifying reason to skip this commit, or null
    *   if autoclose is active.
    * @task autoclose
    */
   public function shouldSkipAutocloseCommit(
     PhabricatorRepositoryCommit $commit) {
 
     $all_reason = $this->shouldSkipAllAutoclose();
     if ($all_reason) {
       return $all_reason;
     }
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return null;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         break;
       default:
         throw new Exception(pht('Unrecognized version control system.'));
     }
 
     $closeable_flag = PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE;
     if (!$commit->isPartiallyImported($closeable_flag)) {
       return self::BECAUSE_NOT_ON_AUTOCLOSE_BRANCH;
     }
 
     return null;
   }
 
 
   /**
    * Determine why all autoclose operations should be skipped for this
    * repository.
    *
    * @return const|null Constant identifying reason to skip all autoclose
    *   operations, or null if autoclose operations are not blocked at the
    *   repository level.
    * @task autoclose
    */
   private function shouldSkipAllAutoclose() {
     if ($this->isImporting()) {
       return self::BECAUSE_REPOSITORY_IMPORTING;
     }
 
     if ($this->getDetail('disable-autoclose', false)) {
       return self::BECAUSE_AUTOCLOSE_DISABLED;
     }
 
     return null;
   }
 
   public function getAutocloseOnlyRules() {
     return array_keys($this->getDetail('close-commits-filter', array()));
   }
 
   public function setAutocloseOnlyRules(array $rules) {
     $rules = array_fill_keys($rules, true);
     $this->setDetail('close-commits-filter', $rules);
     return $this;
   }
 
   public function getTrackOnlyRules() {
     return array_keys($this->getDetail('branch-filter', array()));
   }
 
   public function setTrackOnlyRules(array $rules) {
     $rules = array_fill_keys($rules, true);
     $this->setDetail('branch-filter', $rules);
     return $this;
   }
 
 
 /* -(  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, including credentials if they're
    * used by this repository.
    *
    * @return PhutilOpaqueEnvelope URI, possibly including credentials.
    * @task uri
    */
   public function getRemoteURIEnvelope() {
     $uri = $this->getRemoteURIObject();
 
     $remote_protocol = $this->getRemoteProtocol();
     if ($remote_protocol == 'http' || $remote_protocol == 'https') {
       // For SVN, we use `--username` and `--password` flags separately, so
       // don't add any credentials here.
       if (!$this->isSVN()) {
         $credential_phid = $this->getCredentialPHID();
         if ($credential_phid) {
           $key = PassphrasePasswordKey::loadFromPHID(
             $credential_phid,
             PhabricatorUser::getOmnipotentUser());
 
           $uri->setUser($key->getUsernameEnvelope()->openEnvelope());
           $uri->setPass($key->getPasswordEnvelope()->openEnvelope());
         }
       }
     }
 
     return new PhutilOpaqueEnvelope((string)$uri);
   }
 
 
   /**
    * Get the clone (or checkout) URI for this repository, without authentication
    * information.
    *
    * @return string Repository URI.
    * @task uri
    */
   public function getPublicCloneURI() {
     return (string)$this->getCloneURIObject();
   }
 
 
   /**
    * Get the protocol for the repository's remote.
    *
    * @return string Protocol, like "ssh" or "git".
    * @task uri
    */
   public function getRemoteProtocol() {
     $uri = $this->getRemoteURIObject();
     return $uri->getProtocol();
   }
 
 
   /**
    * Get a parsed object representation of the repository's remote URI..
    *
    * @return wild A @{class@libphutil:PhutilURI}.
    * @task uri
    */
   public function getRemoteURIObject() {
     $raw_uri = $this->getDetail('remote-uri');
     if (!strlen($raw_uri)) {
       return new PhutilURI('');
     }
 
     if (!strncmp($raw_uri, '/', 1)) {
       return new PhutilURI('file://'.$raw_uri);
     }
 
     return new PhutilURI($raw_uri);
   }
 
 
   /**
    * Get the "best" clone/checkout URI for this repository, on any protocol.
    */
   public function getCloneURIObject() {
     if (!$this->isHosted()) {
       if ($this->isSVN()) {
         // Make sure we pick up the "Import Only" path for Subversion, so
         // the user clones the repository starting at the correct path, not
         // from the root.
         $base_uri = $this->getSubversionBaseURI();
         $base_uri = new PhutilURI($base_uri);
         $path = $base_uri->getPath();
         if (!$path) {
           $path = '/';
         }
 
         // If the trailing "@" is not required to escape the URI, strip it for
         // readability.
         if (!preg_match('/@.*@/', $path)) {
           $path = rtrim($path, '@');
         }
 
         $base_uri->setPath($path);
         return $base_uri;
       } else {
         return $this->getRemoteURIObject();
       }
     }
 
     // TODO: This should be cleaned up to deal with all the new URI handling.
     $another_copy = id(new PhabricatorRepositoryQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs(array($this->getPHID()))
       ->needURIs(true)
       ->executeOne();
 
     $clone_uris = $another_copy->getCloneURIs();
     if (!$clone_uris) {
       return null;
     }
 
     return head($clone_uris)->getEffectiveURI();
   }
 
   private function getRawHTTPCloneURIObject() {
     $uri = PhabricatorEnv::getProductionURI($this->getURI());
     $uri = new PhutilURI($uri);
 
     if ($this->isGit()) {
       $uri->setPath($uri->getPath().$this->getCloneName().'.git');
     } else if ($this->isHg()) {
       $uri->setPath($uri->getPath().$this->getCloneName().'/');
     }
 
     return $uri;
   }
 
 
   /**
    * 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() {
     if ($this->isHosted()) {
       return false;
     }
 
     $protocol = $this->getRemoteProtocol();
     if ($this->isSSHProtocol($protocol)) {
       return true;
     }
 
     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() {
     if ($this->isHosted()) {
       return false;
     }
 
     $protocol = $this->getRemoteProtocol();
     return ($protocol == 'http' || $protocol == 'https');
   }
 
 
   /**
    * 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() {
     if ($this->isHosted()) {
       return false;
     }
 
     $protocol = $this->getRemoteProtocol();
     return ($protocol == 'svn');
   }
 
 
   /**
    * 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();
       }
 
       queryfx(
         $this->establishConnection('w'),
         'DELETE FROM %T WHERE repositoryPHID = %s',
         id(new PhabricatorRepositorySymbol())->getTableName(),
         $this->getPHID());
 
       $commits = id(new PhabricatorRepositoryCommit())
         ->loadAllWhere('repositoryID = %d', $this->getID());
       foreach ($commits as $commit) {
         // note PhabricatorRepositoryAuditRequests and
         // PhabricatorRepositoryCommitData are deleted here too.
         $commit->delete();
       }
 
       $uris = id(new PhabricatorRepositoryURI())
         ->loadAllWhere('repositoryPHID = %s', $this->getPHID());
       foreach ($uris as $uri) {
         $uri->delete();
       }
 
       $ref_cursors = id(new PhabricatorRepositoryRefCursor())
         ->loadAllWhere('repositoryPHID = %s', $this->getPHID());
       foreach ($ref_cursors as $cursor) {
         $cursor->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);
   }
 
   public function isHosted() {
     return (bool)$this->getDetail('hosting-enabled', false);
   }
 
   public function setHosted($enabled) {
     return $this->setDetail('hosting-enabled', $enabled);
   }
 
   public function canServeProtocol(
     $protocol,
     $write,
     $is_intracluster = false) {
 
     // See T13192. If a repository is inactive, don't serve it to users. We
     // still synchronize it within the cluster and serve it to other repository
     // nodes.
     if (!$is_intracluster) {
       if (!$this->isTracked()) {
         return false;
       }
     }
 
     $clone_uris = $this->getCloneURIs();
     foreach ($clone_uris as $uri) {
       if ($uri->getBuiltinProtocol() !== $protocol) {
         continue;
       }
 
       $io_type = $uri->getEffectiveIoType();
       if ($io_type == PhabricatorRepositoryURI::IO_READWRITE) {
         return true;
       }
 
       if (!$write) {
         if ($io_type == PhabricatorRepositoryURI::IO_READ) {
           return true;
         }
       }
     }
 
     return false;
   }
 
   public function hasLocalWorkingCopy() {
     try {
       self::assertLocalExists();
       return true;
     } catch (Exception $ex) {
       return false;
     }
   }
 
   /**
    * Raise more useful errors when there are basic filesystem problems.
    */
   private function assertLocalExists() {
     if (!$this->usesLocalWorkingCopy()) {
       return;
     }
 
     $local = $this->getLocalPath();
     Filesystem::assertExists($local);
     Filesystem::assertIsDirectory($local);
     Filesystem::assertReadable($local);
   }
 
   /**
    * Determine if the working copy is bare or not. In Git, this corresponds
    * to `--bare`. In Mercurial, `--noupdate`.
    */
   public function isWorkingCopyBare() {
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return false;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $local = $this->getLocalPath();
         if (Filesystem::pathExists($local.'/.git')) {
           return false;
         } else {
           return true;
         }
     }
   }
 
   public function usesLocalWorkingCopy() {
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         return $this->isHosted();
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return true;
     }
   }
 
   public function getHookDirectories() {
     $directories = array();
     if (!$this->isHosted()) {
       return $directories;
     }
 
     $root = $this->getLocalPath();
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         if ($this->isWorkingCopyBare()) {
           $directories[] = $root.'/hooks/pre-receive-phabricator.d/';
         } else {
           $directories[] = $root.'/.git/hooks/pre-receive-phabricator.d/';
         }
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $directories[] = $root.'/hooks/pre-commit-phabricator.d/';
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         // NOTE: We don't support custom Mercurial hooks for now because they're
         // messy and we can't easily just drop a `hooks.d/` directory next to
         // the hooks.
         break;
     }
 
     return $directories;
   }
 
   public function canDestroyWorkingCopy() {
     if ($this->isHosted()) {
       // Never destroy hosted working copies.
       return false;
     }
 
     $default_path = PhabricatorEnv::getEnvConfig(
       'repository.default-local-path');
     return Filesystem::isDescendant($this->getLocalPath(), $default_path);
   }
 
   public function canUsePathTree() {
     return !$this->isSVN();
   }
 
   public function canUseGitLFS() {
     if (!$this->isGit()) {
       return false;
     }
 
     if (!$this->isHosted()) {
       return false;
     }
 
     if (!PhabricatorEnv::getEnvConfig('diffusion.allow-git-lfs')) {
       return false;
     }
 
     return true;
   }
 
   public function getGitLFSURI($path = null) {
     if (!$this->canUseGitLFS()) {
       throw new Exception(
         pht(
           'This repository does not support Git LFS, so Git LFS URIs can '.
           'not be generated for it.'));
     }
 
     $uri = $this->getRawHTTPCloneURIObject();
     $uri = (string)$uri;
     $uri = $uri.'/'.$path;
 
     return $uri;
   }
 
   public function canMirror() {
     if ($this->isGit() || $this->isHg()) {
       return true;
     }
 
     return false;
   }
 
   public function canAllowDangerousChanges() {
     if (!$this->isHosted()) {
       return false;
     }
 
     // In Git and Mercurial, ref deletions and rewrites are dangerous.
     // In Subversion, editing revprops is dangerous.
 
     return true;
   }
 
   public function shouldAllowDangerousChanges() {
     return (bool)$this->getDetail('allow-dangerous-changes');
   }
 
   public function canAllowEnormousChanges() {
     if (!$this->isHosted()) {
       return false;
     }
 
     return true;
   }
 
   public function shouldAllowEnormousChanges() {
     return (bool)$this->getDetail('allow-enormous-changes');
   }
 
   public function writeStatusMessage(
     $status_type,
     $status_code,
     array $parameters = array()) {
 
     $table = new PhabricatorRepositoryStatusMessage();
     $conn_w = $table->establishConnection('w');
     $table_name = $table->getTableName();
 
     if ($status_code === null) {
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d AND statusType = %s',
         $table_name,
         $this->getID(),
         $status_type);
     } else {
       // If the existing message has the same code (e.g., we just hit an
       // error and also previously hit an error) we increment the message
       // count. This allows us to determine how many times in a row we've
       // run into an error.
 
       // NOTE: The assignments in "ON DUPLICATE KEY UPDATE" are evaluated
       // in order, so the "messageCount" assignment must occur before the
       // "statusCode" assignment. See T11705.
 
       queryfx(
         $conn_w,
         'INSERT INTO %T
           (repositoryID, statusType, statusCode, parameters, epoch,
             messageCount)
           VALUES (%d, %s, %s, %s, %d, %d)
           ON DUPLICATE KEY UPDATE
             messageCount =
               IF(
                 statusCode = VALUES(statusCode),
                 messageCount + VALUES(messageCount),
                 VALUES(messageCount)),
             statusCode = VALUES(statusCode),
             parameters = VALUES(parameters),
             epoch = VALUES(epoch)',
         $table_name,
         $this->getID(),
         $status_type,
         $status_code,
         json_encode($parameters),
         time(),
         1);
     }
 
     return $this;
   }
 
   public static function assertValidRemoteURI($uri) {
     if (trim($uri) != $uri) {
       throw new Exception(
         pht('The remote URI has leading or trailing whitespace.'));
     }
 
     $uri_object = new PhutilURI($uri);
     $protocol = $uri_object->getProtocol();
 
     // Catch confusion between Git/SCP-style URIs and normal URIs. See T3619
     // for discussion. This is usually a user adding "ssh://" to an implicit
     // SSH Git URI.
     if ($protocol == 'ssh') {
       if (preg_match('(^[^:@]+://[^/:]+:[^\d])', $uri)) {
         throw new Exception(
           pht(
             "The remote URI is not formatted correctly. Remote URIs ".
             "with an explicit protocol should be in the form ".
             "'%s', not '%s'. The '%s' syntax is only valid in SCP-style URIs.",
             'proto://domain/path',
             'proto://domain:/path',
             ':/path'));
       }
     }
 
     switch ($protocol) {
       case 'ssh':
       case 'http':
       case 'https':
       case 'git':
       case 'svn':
       case 'svn+ssh':
         break;
       default:
         // NOTE: We're explicitly rejecting 'file://' because it can be
         // used to clone from the working copy of another repository on disk
         // that you don't normally have permission to access.
 
         throw new Exception(
           pht(
             'The URI protocol is unrecognized. It should begin with '.
             '"%s", "%s", "%s", "%s", "%s", "%s", or be in the form "%s".',
             'ssh://',
             'http://',
             'https://',
             'git://',
             'svn://',
             'svn+ssh://',
             'git@domain.com:path'));
     }
 
     return true;
   }
 
 
   /**
    * Load the pull frequency for this repository, based on the time since the
    * last activity.
    *
    * We pull rarely used repositories less frequently. This finds the most
    * recent commit which is older than the current time (which prevents us from
    * spinning on repositories with a silly commit post-dated to some time in
    * 2037). We adjust the pull frequency based on when the most recent commit
    * occurred.
    *
    * @param   int   The minimum update interval to use, in seconds.
    * @return  int   Repository update interval, in seconds.
    */
   public function loadUpdateInterval($minimum = 15) {
     // First, check if we've hit errors recently. If we have, wait one period
     // for each consecutive error. Normally, this corresponds to a backoff of
     // 15s, 30s, 45s, etc.
 
     $message_table = new PhabricatorRepositoryStatusMessage();
     $conn = $message_table->establishConnection('r');
     $error_count = queryfx_one(
       $conn,
       'SELECT MAX(messageCount) error_count FROM %T
         WHERE repositoryID = %d
         AND statusType IN (%Ls)
         AND statusCode IN (%Ls)',
       $message_table->getTableName(),
       $this->getID(),
       array(
         PhabricatorRepositoryStatusMessage::TYPE_INIT,
         PhabricatorRepositoryStatusMessage::TYPE_FETCH,
       ),
       array(
         PhabricatorRepositoryStatusMessage::CODE_ERROR,
       ));
 
     $error_count = (int)$error_count['error_count'];
     if ($error_count > 0) {
       return (int)($minimum * $error_count);
     }
 
     // If a repository is still importing, always pull it as frequently as
     // possible. This prevents us from hanging for a long time at 99.9% when
     // importing an inactive repository.
     if ($this->isImporting()) {
       return $minimum;
     }
 
     $window_start = (PhabricatorTime::getNow() + $minimum);
 
     $table = id(new PhabricatorRepositoryCommit());
     $last_commit = queryfx_one(
       $table->establishConnection('r'),
       'SELECT epoch FROM %T
         WHERE repositoryID = %d AND epoch <= %d
         ORDER BY epoch DESC LIMIT 1',
       $table->getTableName(),
       $this->getID(),
       $window_start);
     if ($last_commit) {
       $time_since_commit = ($window_start - $last_commit['epoch']);
     } else {
       // If the repository has no commits, treat the creation date as
       // though it were the date of the last commit. This makes empty
       // repositories update quickly at first but slow down over time
       // if they don't see any activity.
       $time_since_commit = ($window_start - $this->getDateCreated());
     }
 
     $last_few_days = phutil_units('3 days in seconds');
 
     if ($time_since_commit <= $last_few_days) {
       // For repositories with activity in the recent past, we wait one
       // extra second for every 10 minutes since the last commit. This
       // shorter backoff is intended to handle weekends and other short
       // breaks from development.
       $smart_wait = ($time_since_commit / 600);
     } else {
       // For repositories without recent activity, we wait one extra second
       // for every 4 minutes since the last commit. This longer backoff
       // handles rarely used repositories, up to the maximum.
       $smart_wait = ($time_since_commit / 240);
     }
 
     // We'll never wait more than 6 hours to pull a repository.
     $longest_wait = phutil_units('6 hours in seconds');
     $smart_wait = min($smart_wait, $longest_wait);
     $smart_wait = max($minimum, $smart_wait);
 
     return (int)$smart_wait;
   }
 
 
   /**
    * Time limit for cloning or copying this repository.
    *
    * This limit is used to timeout operations like `git clone` or `git fetch`
    * when doing intracluster synchronization, building working copies, etc.
    *
    * @return int Maximum number of seconds to spend copying this repository.
    */
   public function getCopyTimeLimit() {
     return $this->getDetail('limit.copy');
   }
 
   public function setCopyTimeLimit($limit) {
     return $this->setDetail('limit.copy', $limit);
   }
 
   public function getDefaultCopyTimeLimit() {
     return phutil_units('15 minutes in seconds');
   }
 
   public function getEffectiveCopyTimeLimit() {
     $limit = $this->getCopyTimeLimit();
     if ($limit) {
       return $limit;
     }
 
     return $this->getDefaultCopyTimeLimit();
   }
 
   public function getFilesizeLimit() {
     return $this->getDetail('limit.filesize');
   }
 
   public function setFilesizeLimit($limit) {
     return $this->setDetail('limit.filesize', $limit);
   }
 
   public function getTouchLimit() {
     return $this->getDetail('limit.touch');
   }
 
   public function setTouchLimit($limit) {
     return $this->setDetail('limit.touch', $limit);
   }
 
   /**
    * Retrieve the service URI for the device hosting this repository.
    *
    * See @{method:newConduitClient} for a general discussion of interacting
    * with repository services. This method provides lower-level resolution of
    * services, returning raw URIs.
    *
    * @param PhabricatorUser Viewing user.
    * @param map<string, wild> Constraints on selectable services.
    * @return string|null URI, or `null` for local repositories.
    */
   public function getAlmanacServiceURI(
     PhabricatorUser $viewer,
     array $options) {
 
     PhutilTypeSpec::checkMap(
       $options,
       array(
         'neverProxy' => 'bool',
         'protocols' => 'list<string>',
         'writable' => 'optional bool',
       ));
 
     $never_proxy = $options['neverProxy'];
     $protocols = $options['protocols'];
     $writable = idx($options, 'writable', false);
 
     $cache_key = $this->getAlmanacServiceCacheKey();
     if (!$cache_key) {
       return null;
     }
 
     $cache = PhabricatorCaches::getMutableStructureCache();
     $uris = $cache->getKey($cache_key, false);
 
     // If we haven't built the cache yet, build it now.
     if ($uris === false) {
       $uris = $this->buildAlmanacServiceURIs();
       $cache->setKey($cache_key, $uris);
     }
 
     if ($uris === null) {
       return null;
     }
 
     $local_device = AlmanacKeys::getDeviceID();
     if ($never_proxy && !$local_device) {
       throw new Exception(
         pht(
           'Unable to handle proxied service request. This device is not '.
           'registered, so it can not identify local services. Register '.
           'this device before sending requests here.'));
     }
 
     $protocol_map = array_fuse($protocols);
 
     $results = array();
     foreach ($uris as $uri) {
       // If we're never proxying this and it's locally satisfiable, return
       // `null` to tell the caller to handle it locally. If we're allowed to
       // proxy, we skip this check and may proxy the request to ourselves.
       // (That proxied request will end up here with proxying forbidden,
       // return `null`, and then the request will actually run.)
 
       if ($local_device && $never_proxy) {
         if ($uri['device'] == $local_device) {
           return null;
         }
       }
 
       if (isset($protocol_map[$uri['protocol']])) {
         $results[] = $uri;
       }
     }
 
     if (!$results) {
       throw new Exception(
         pht(
           'The Almanac service for this repository is not bound to any '.
           'interfaces which support the required protocols (%s).',
           implode(', ', $protocols)));
     }
 
     if ($never_proxy) {
       // See PHI1030. This error can arise from various device name/address
       // mismatches which are hard to detect, so try to provide as much
       // information as we can.
 
       if ($writable) {
         $request_type = pht('(This is a write request.)');
       } else {
         $request_type = pht('(This is a read request.)');
       }
 
       throw new Exception(
         pht(
           'This repository request (for repository "%s") has been '.
           'incorrectly routed to a cluster host (with device name "%s", '.
           'and hostname "%s") which can not serve the request.'.
           "\n\n".
           'The Almanac device address for the correct device may improperly '.
           'point at this host, or the "device.id" configuration file on '.
           'this host may be incorrect.'.
           "\n\n".
           'Requests routed within the cluster by Phabricator are always '.
           'expected to be sent to a node which can serve the request. To '.
           'prevent loops, this request will not be proxied again.'.
           "\n\n".
           "%s",
           $this->getDisplayName(),
           $local_device,
           php_uname('n'),
           $request_type));
     }
 
     if (count($results) > 1) {
       if (!$this->supportsSynchronization()) {
         throw new Exception(
           pht(
             'Repository "%s" is bound to multiple active repository hosts, '.
             'but this repository does not support cluster synchronization. '.
             'Declusterize this repository or move it to a service with only '.
             'one host.',
             $this->getDisplayName()));
       }
     }
 
     // If we require a writable device, remove URIs which aren't writable.
     if ($writable) {
       foreach ($results as $key => $uri) {
         if (!$uri['writable']) {
           unset($results[$key]);
         }
       }
 
       if (!$results) {
         throw new Exception(
           pht(
             'This repository ("%s") is not writable with the given '.
             'protocols (%s). The Almanac service for this repository has no '.
             'writable bindings that support these protocols.',
             $this->getDisplayName(),
             implode(', ', $protocols)));
       }
     }
 
     if ($writable) {
       $results = $this->sortWritableAlmanacServiceURIs($results);
     } else {
       shuffle($results);
     }
 
     $result = head($results);
     return $result['uri'];
   }
 
   private function sortWritableAlmanacServiceURIs(array $results) {
     // See T13109 for discussion of how this method routes requests.
 
     // In the absence of other rules, we'll send traffic to devices randomly.
     // We also want to select randomly among nodes which are equally good
     // candidates to receive the write, and accomplish that by shuffling the
     // list up front.
     shuffle($results);
 
     $order = array();
 
     // If some device is currently holding the write lock, send all requests
     // to that device. We're trying to queue writes on a single device so they
     // do not need to wait for read synchronization after earlier writes
     // complete.
     $writer = PhabricatorRepositoryWorkingCopyVersion::loadWriter(
       $this->getPHID());
     if ($writer) {
       $device_phid = $writer->getWriteProperty('devicePHID');
       foreach ($results as $key => $result) {
         if ($result['devicePHID'] === $device_phid) {
           $order[] = $key;
         }
       }
     }
 
     // If no device is currently holding the write lock, try to send requests
     // to a device which is already up to date and will not need to synchronize
     // before it can accept the write.
     $versions = PhabricatorRepositoryWorkingCopyVersion::loadVersions(
       $this->getPHID());
     if ($versions) {
       $max_version = (int)max(mpull($versions, 'getRepositoryVersion'));
 
       $max_devices = array();
       foreach ($versions as $version) {
         if ($version->getRepositoryVersion() == $max_version) {
           $max_devices[] = $version->getDevicePHID();
         }
       }
       $max_devices = array_fuse($max_devices);
 
       foreach ($results as $key => $result) {
         if (isset($max_devices[$result['devicePHID']])) {
           $order[] = $key;
         }
       }
     }
 
     // Reorder the results, putting any we've selected as preferred targets for
     // the write at the head of the list.
     $results = array_select_keys($results, $order) + $results;
 
     return $results;
   }
 
   public function supportsSynchronization() {
     // TODO: For now, this is only supported for Git.
     if (!$this->isGit()) {
       return false;
     }
 
     return true;
   }
 
   public function getAlmanacServiceCacheKey() {
     $service_phid = $this->getAlmanacServicePHID();
     if (!$service_phid) {
       return null;
     }
 
     $repository_phid = $this->getPHID();
 
     $parts = array(
       "repo({$repository_phid})",
       "serv({$service_phid})",
       'v4',
     );
 
     return implode('.', $parts);
   }
 
   private function buildAlmanacServiceURIs() {
     $service = $this->loadAlmanacService();
     if (!$service) {
       return null;
     }
 
     $bindings = $service->getActiveBindings();
     if (!$bindings) {
       throw new Exception(
         pht(
           'The Almanac service for this repository is not bound to any '.
           'interfaces.'));
     }
 
     $uris = array();
     foreach ($bindings as $binding) {
       $iface = $binding->getInterface();
 
       $uri = $this->getClusterRepositoryURIFromBinding($binding);
       $protocol = $uri->getProtocol();
       $device_name = $iface->getDevice()->getName();
       $device_phid = $iface->getDevice()->getPHID();
 
       $uris[] = array(
         'protocol' => $protocol,
         'uri' => (string)$uri,
         'device' => $device_name,
         'writable' => (bool)$binding->getAlmanacPropertyValue('writable'),
         'devicePHID' => $device_phid,
       );
     }
 
     return $uris;
   }
 
   /**
    * Build a new Conduit client in order to make a service call to this
    * repository.
    *
    * If the repository is hosted locally, this method may return `null`. The
    * caller should use `ConduitCall` or other local logic to complete the
    * request.
    *
    * By default, we will return a @{class:ConduitClient} for any repository with
    * a service, even if that service is on the current device.
    *
    * We do this because this configuration does not make very much sense in a
    * production context, but is very common in a test/development context
    * (where the developer's machine is both the web host and the repository
    * service). By proxying in development, we get more consistent behavior
    * between development and production, and don't have a major untested
    * codepath.
    *
    * The `$never_proxy` parameter can be used to prevent this local proxying.
    * If the flag is passed:
    *
    *   - The method will return `null` (implying a local service call)
    *     if the repository service is hosted on the current device.
    *   - The method will throw if it would need to return a client.
    *
    * This is used to prevent loops in Conduit: the first request will proxy,
    * even in development, but the second request will be identified as a
    * cluster request and forced not to proxy.
    *
    * For lower-level service resolution, see @{method:getAlmanacServiceURI}.
    *
    * @param PhabricatorUser Viewing user.
    * @param bool `true` to throw if a client would be returned.
    * @return ConduitClient|null Client, or `null` for local repositories.
    */
   public function newConduitClient(
     PhabricatorUser $viewer,
     $never_proxy = false) {
 
     $uri = $this->getAlmanacServiceURI(
       $viewer,
       array(
         'neverProxy' => $never_proxy,
         'protocols' => array(
           'http',
           'https',
         ),
 
         // At least today, no Conduit call can ever write to a repository,
         // so it's fine to send anything to a read-only node.
         'writable' => false,
       ));
     if ($uri === null) {
       return null;
     }
 
     $domain = id(new PhutilURI(PhabricatorEnv::getURI('/')))->getDomain();
 
     $client = id(new ConduitClient($uri))
       ->setHost($domain);
 
     if ($viewer->isOmnipotent()) {
       // If the caller is the omnipotent user (normally, a daemon), we will
       // sign the request with this host's asymmetric keypair.
 
       $public_path = AlmanacKeys::getKeyPath('device.pub');
       try {
         $public_key = Filesystem::readFile($public_path);
       } catch (Exception $ex) {
         throw new PhutilAggregateException(
           pht(
             'Unable to read device public key while attempting to make '.
             'authenticated method call within the Phabricator cluster. '.
             'Use `%s` to register keys for this device. Exception: %s',
             'bin/almanac register',
             $ex->getMessage()),
           array($ex));
       }
 
       $private_path = AlmanacKeys::getKeyPath('device.key');
       try {
         $private_key = Filesystem::readFile($private_path);
         $private_key = new PhutilOpaqueEnvelope($private_key);
       } catch (Exception $ex) {
         throw new PhutilAggregateException(
           pht(
             'Unable to read device private key while attempting to make '.
             'authenticated method call within the Phabricator cluster. '.
             'Use `%s` to register keys for this device. Exception: %s',
             'bin/almanac register',
             $ex->getMessage()),
           array($ex));
       }
 
       $client->setSigningKeys($public_key, $private_key);
     } else {
       // If the caller is a normal user, we generate or retrieve a cluster
       // API token.
 
       $token = PhabricatorConduitToken::loadClusterTokenForUser($viewer);
       if ($token) {
         $client->setConduitToken($token->getToken());
       }
     }
 
     return $client;
   }
 
   public function getPassthroughEnvironmentalVariables() {
     $env = $_ENV;
 
     if ($this->isGit()) {
       // $_ENV does not populate in CLI contexts if "E" is missing from
       // "variables_order" in PHP config. Currently, we do not require this
       // to be configured. Since it may not be, explicitly bring expected Git
       // environmental variables into scope. This list is not exhaustive, but
       // only lists variables with a known impact on commit hook behavior.
 
       // This can be removed if we later require "E" in "variables_order".
 
       $git_env = array(
         'GIT_OBJECT_DIRECTORY',
         'GIT_ALTERNATE_OBJECT_DIRECTORIES',
         'GIT_QUARANTINE_PATH',
       );
       foreach ($git_env as $key) {
         $value = getenv($key);
         if (strlen($value)) {
           $env[$key] = $value;
         }
       }
 
       $key = 'GIT_PUSH_OPTION_COUNT';
       $git_count = getenv($key);
       if (strlen($git_count)) {
         $git_count = (int)$git_count;
         $env[$key] = $git_count;
         for ($ii = 0; $ii < $git_count; $ii++) {
           $key = 'GIT_PUSH_OPTION_'.$ii;
           $env[$key] = getenv($key);
         }
       }
     }
 
     $result = array();
     foreach ($env as $key => $value) {
       // In Git, pass anything matching "GIT_*" though. Some of these variables
       // need to be preserved to allow `git` operations to work properly when
       // running from commit hooks.
       if ($this->isGit()) {
         if (preg_match('/^GIT_/', $key)) {
           $result[$key] = $value;
         }
       }
     }
 
     return $result;
   }
 
   public function supportsBranchComparison() {
     return $this->isGit();
   }
 
 /* -(  Repository URIs  )---------------------------------------------------- */
 
 
   public function attachURIs(array $uris) {
     $custom_map = array();
     foreach ($uris as $key => $uri) {
       $builtin_key = $uri->getRepositoryURIBuiltinKey();
       if ($builtin_key !== null) {
         $custom_map[$builtin_key] = $key;
       }
     }
 
     $builtin_uris = $this->newBuiltinURIs();
     $seen_builtins = array();
     foreach ($builtin_uris as $builtin_uri) {
       $builtin_key = $builtin_uri->getRepositoryURIBuiltinKey();
       $seen_builtins[$builtin_key] = true;
 
       // If this builtin URI is disabled, don't attach it and remove the
       // persisted version if it exists.
       if ($builtin_uri->getIsDisabled()) {
         if (isset($custom_map[$builtin_key])) {
           unset($uris[$custom_map[$builtin_key]]);
         }
         continue;
       }
 
       // If the URI exists, make sure it's marked as not being disabled.
       if (isset($custom_map[$builtin_key])) {
         $uris[$custom_map[$builtin_key]]->setIsDisabled(false);
       }
     }
 
     // Remove any builtins which no longer exist.
     foreach ($custom_map as $builtin_key => $key) {
       if (empty($seen_builtins[$builtin_key])) {
         unset($uris[$key]);
       }
     }
 
     $this->uris = $uris;
 
     return $this;
   }
 
   public function getURIs() {
     return $this->assertAttached($this->uris);
   }
 
   public function getCloneURIs() {
     $uris = $this->getURIs();
 
     $clone = array();
     foreach ($uris as $uri) {
       if (!$uri->isBuiltin()) {
         continue;
       }
 
       if ($uri->getIsDisabled()) {
         continue;
       }
 
       $io_type = $uri->getEffectiveIoType();
       $is_clone =
         ($io_type == PhabricatorRepositoryURI::IO_READ) ||
         ($io_type == PhabricatorRepositoryURI::IO_READWRITE);
 
       if (!$is_clone) {
         continue;
       }
 
       $clone[] = $uri;
     }
 
     $clone = msort($clone, 'getURIScore');
     $clone = array_reverse($clone);
 
     return $clone;
   }
 
 
   public function newBuiltinURIs() {
     $has_callsign = ($this->getCallsign() !== null);
     $has_shortname = ($this->getRepositorySlug() !== null);
 
     $identifier_map = array(
       PhabricatorRepositoryURI::BUILTIN_IDENTIFIER_CALLSIGN => $has_callsign,
       PhabricatorRepositoryURI::BUILTIN_IDENTIFIER_SHORTNAME => $has_shortname,
       PhabricatorRepositoryURI::BUILTIN_IDENTIFIER_ID => true,
     );
 
     // If the view policy of the repository is public, support anonymous HTTP
     // even if authenticated HTTP is not supported.
     if ($this->getViewPolicy() === PhabricatorPolicies::POLICY_PUBLIC) {
       $allow_http = true;
     } else {
       $allow_http = PhabricatorEnv::getEnvConfig('diffusion.allow-http-auth');
     }
 
     $base_uri = PhabricatorEnv::getURI('/');
     $base_uri = new PhutilURI($base_uri);
     $has_https = ($base_uri->getProtocol() == 'https');
     $has_https = ($has_https && $allow_http);
 
     $has_http = !PhabricatorEnv::getEnvConfig('security.require-https');
     $has_http = ($has_http && $allow_http);
 
     // HTTP is not supported for Subversion.
     if ($this->isSVN()) {
       $has_http = false;
       $has_https = false;
     }
 
     $has_ssh = (bool)strlen(PhabricatorEnv::getEnvConfig('phd.user'));
 
     $protocol_map = array(
       PhabricatorRepositoryURI::BUILTIN_PROTOCOL_SSH => $has_ssh,
       PhabricatorRepositoryURI::BUILTIN_PROTOCOL_HTTPS => $has_https,
       PhabricatorRepositoryURI::BUILTIN_PROTOCOL_HTTP => $has_http,
     );
 
     $uris = array();
     foreach ($protocol_map as $protocol => $proto_supported) {
       foreach ($identifier_map as $identifier => $id_supported) {
         // This is just a dummy value because it can't be empty; we'll force
         // it to a proper value when using it in the UI.
         $builtin_uri = "{$protocol}://{$identifier}";
         $uris[] = PhabricatorRepositoryURI::initializeNewURI()
           ->setRepositoryPHID($this->getPHID())
           ->attachRepository($this)
           ->setBuiltinProtocol($protocol)
           ->setBuiltinIdentifier($identifier)
           ->setURI($builtin_uri)
           ->setIsDisabled((int)(!$proto_supported || !$id_supported));
       }
     }
 
     return $uris;
   }
 
 
   public function getClusterRepositoryURIFromBinding(
     AlmanacBinding $binding) {
     $protocol = $binding->getAlmanacPropertyValue('protocol');
     if ($protocol === null) {
       $protocol = 'https';
     }
 
     $iface = $binding->getInterface();
     $address = $iface->renderDisplayAddress();
 
     $path = $this->getURI();
 
     return id(new PhutilURI("{$protocol}://{$address}"))
       ->setPath($path);
   }
 
   public function loadAlmanacService() {
     $service_phid = $this->getAlmanacServicePHID();
     if (!$service_phid) {
       // No service, so this is a local repository.
       return null;
     }
 
     $service = id(new AlmanacServiceQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs(array($service_phid))
       ->needBindings(true)
       ->needProperties(true)
       ->executeOne();
     if (!$service) {
       throw new Exception(
         pht(
           'The Almanac service for this repository is invalid or could not '.
           'be loaded.'));
     }
 
     $service_type = $service->getServiceImplementation();
     if (!($service_type instanceof AlmanacClusterRepositoryServiceType)) {
       throw new Exception(
         pht(
           'The Almanac service for this repository does not have the correct '.
           'service type.'));
     }
 
     return $service;
   }
 
   public function markImporting() {
     $this->openTransaction();
       $this->beginReadLocking();
         $repository = $this->reload();
         $repository->setDetail('importing', true);
         $repository->save();
       $this->endReadLocking();
     $this->saveTransaction();
 
     return $repository;
   }
 
 
 /* -(  Symbols  )-------------------------------------------------------------*/
 
   public function getSymbolSources() {
     return $this->getDetail('symbol-sources', array());
   }
 
   public function getSymbolLanguages() {
     return $this->getDetail('symbol-languages', array());
   }
 
 
 /* -(  Staging  )------------------------------------------------------------ */
 
 
   public function supportsStaging() {
     return $this->isGit();
   }
 
 
   public function getStagingURI() {
     if (!$this->supportsStaging()) {
       return null;
     }
     return $this->getDetail('staging-uri', null);
   }
 
 
 /* -(  Automation  )--------------------------------------------------------- */
 
 
   public function supportsAutomation() {
     return $this->isGit();
   }
 
   public function canPerformAutomation() {
     if (!$this->supportsAutomation()) {
       return false;
     }
 
     if (!$this->getAutomationBlueprintPHIDs()) {
       return false;
     }
 
     return true;
   }
 
   public function getAutomationBlueprintPHIDs() {
     if (!$this->supportsAutomation()) {
       return array();
     }
     return $this->getDetail('automation.blueprintPHIDs', array());
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorRepositoryEditor();
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorRepositoryTransaction();
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
       DiffusionPushCapability::CAPABILITY,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
       case DiffusionPushCapability::CAPABILITY:
         return $this->getPushPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     return false;
   }
 
 
 /* -(  PhabricatorMarkupInterface  )----------------------------------------- */
 
 
   public function getMarkupFieldKey($field) {
     $hash = PhabricatorHash::digestForIndex($this->getMarkupText($field));
     return "repo:{$hash}";
   }
 
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newMarkupEngine(array());
   }
 
   public function getMarkupText($field) {
     return $this->getDetail('description');
   }
 
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     require_celerity_resource('phabricator-remarkup-css');
     return phutil_tag(
       'div',
       array(
         'class' => 'phabricator-remarkup',
       ),
       $output);
   }
 
   public function shouldUseMarkupCache($field) {
     return true;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $phid = $this->getPHID();
 
     $this->openTransaction();
 
       $this->delete();
 
       PhabricatorRepositoryURIIndex::updateRepositoryURIs($phid, array());
 
       $books = id(new DivinerBookQuery())
         ->setViewer($engine->getViewer())
         ->withRepositoryPHIDs(array($phid))
         ->execute();
       foreach ($books as $book) {
         $engine->destroyObject($book);
       }
 
       $atoms = id(new DivinerAtomQuery())
         ->setViewer($engine->getViewer())
         ->withRepositoryPHIDs(array($phid))
         ->execute();
       foreach ($atoms as $atom) {
         $engine->destroyObject($atom);
       }
 
       $lfs_refs = id(new PhabricatorRepositoryGitLFSRefQuery())
         ->setViewer($engine->getViewer())
         ->withRepositoryPHIDs(array($phid))
         ->execute();
       foreach ($lfs_refs as $ref) {
         $engine->destroyObject($ref);
       }
 
     $this->saveTransaction();
   }
 
 
 /* -(  PhabricatorDestructibleCodexInterface  )------------------------------ */
 
 
   public function newDestructibleCodex() {
     return new PhabricatorRepositoryDestructibleCodex();
   }
 
 
 /* -(  PhabricatorSpacesInterface  )----------------------------------------- */
 
 
   public function getSpacePHID() {
     return $this->spacePHID;
   }
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('name')
         ->setType('string')
         ->setDescription(pht('The repository name.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('vcs')
         ->setType('string')
         ->setDescription(
           pht('The VCS this repository uses ("git", "hg" or "svn").')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('callsign')
         ->setType('string')
         ->setDescription(pht('The repository callsign, if it has one.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('shortName')
         ->setType('string')
         ->setDescription(pht('Unique short name, if the repository has one.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('status')
         ->setType('string')
         ->setDescription(pht('Active or inactive status.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('isImporting')
         ->setType('bool')
         ->setDescription(
           pht(
             'True if the repository is importing initial commits.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('almanacServicePHID')
         ->setType('phid?')
         ->setDescription(
           pht(
             'The Almanac Service that hosts this repository, if the '.
             'repository is clustered.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     return array(
       'name' => $this->getName(),
       'vcs' => $this->getVersionControlSystem(),
       'callsign' => $this->getCallsign(),
       'shortName' => $this->getRepositorySlug(),
       'status' => $this->getStatus(),
       'isImporting' => (bool)$this->isImporting(),
       'almanacServicePHID' => $this->getAlmanacServicePHID(),
     );
   }
 
   public function getConduitSearchAttachments() {
     return array(
       id(new DiffusionRepositoryURIsSearchEngineAttachment())
         ->setAttachmentKey('uris'),
     );
   }
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new PhabricatorRepositoryFulltextEngine();
   }
 
 
 /* -(  PhabricatorFerretInterface  )----------------------------------------- */
 
 
   public function newFerretEngine() {
     return new PhabricatorRepositoryFerretEngine();
   }
 
 }
diff --git a/src/applications/transactions/editengine/PhabricatorEditEngine.php b/src/applications/transactions/editengine/PhabricatorEditEngine.php
index d1a2fb72b9..353d7ee385 100644
--- a/src/applications/transactions/editengine/PhabricatorEditEngine.php
+++ b/src/applications/transactions/editengine/PhabricatorEditEngine.php
@@ -1,2667 +1,2666 @@
 <?php
 
 
 /**
  * @task fields Managing Fields
  * @task text Display Text
  * @task config Edit Engine Configuration
  * @task uri Managing URIs
  * @task load Creating and Loading Objects
  * @task web Responding to Web Requests
  * @task edit Responding to Edit Requests
  * @task http Responding to HTTP Parameter Requests
  * @task conduit Responding to Conduit Requests
  */
 abstract class PhabricatorEditEngine
   extends Phobject
   implements PhabricatorPolicyInterface {
 
   const EDITENGINECONFIG_DEFAULT = 'default';
 
   const SUBTYPE_DEFAULT = 'default';
 
   private $viewer;
   private $controller;
   private $isCreate;
   private $editEngineConfiguration;
   private $contextParameters = array();
   private $targetObject;
   private $page;
   private $pages;
   private $navigation;
 
   final public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   final public function getViewer() {
     return $this->viewer;
   }
 
   final public function setController(PhabricatorController $controller) {
     $this->controller = $controller;
     $this->setViewer($controller->getViewer());
     return $this;
   }
 
   final public function getController() {
     return $this->controller;
   }
 
   final public function getEngineKey() {
     $key = $this->getPhobjectClassConstant('ENGINECONST', 64);
     if (strpos($key, '/') !== false) {
       throw new Exception(
         pht(
           'EditEngine ("%s") contains an invalid key character "/".',
           get_class($this)));
     }
     return $key;
   }
 
   final public function getApplication() {
     $app_class = $this->getEngineApplicationClass();
     return PhabricatorApplication::getByClass($app_class);
   }
 
   final public function addContextParameter($key) {
     $this->contextParameters[] = $key;
     return $this;
   }
 
   public function isEngineConfigurable() {
     return true;
   }
 
   public function isEngineExtensible() {
     return true;
   }
 
   public function isDefaultQuickCreateEngine() {
     return false;
   }
 
   public function getDefaultQuickCreateFormKeys() {
     $keys = array();
 
     if ($this->isDefaultQuickCreateEngine()) {
       $keys[] = self::EDITENGINECONFIG_DEFAULT;
     }
 
     foreach ($keys as $idx => $key) {
       $keys[$idx] = $this->getEngineKey().'/'.$key;
     }
 
     return $keys;
   }
 
   public static function splitFullKey($full_key) {
     return explode('/', $full_key, 2);
   }
 
   public function getQuickCreateOrderVector() {
     return id(new PhutilSortVector())
       ->addString($this->getObjectCreateShortText());
   }
 
   /**
    * Force the engine to edit a particular object.
    */
   public function setTargetObject($target_object) {
     $this->targetObject = $target_object;
     return $this;
   }
 
   public function getTargetObject() {
     return $this->targetObject;
   }
 
   public function setNavigation(AphrontSideNavFilterView $navigation) {
     $this->navigation = $navigation;
     return $this;
   }
 
   public function getNavigation() {
     return $this->navigation;
   }
 
 
 /* -(  Managing Fields  )---------------------------------------------------- */
 
 
   abstract public function getEngineApplicationClass();
   abstract protected function buildCustomEditFields($object);
 
   public function getFieldsForConfig(
     PhabricatorEditEngineConfiguration $config) {
 
     $object = $this->newEditableObject();
 
     $this->editEngineConfiguration = $config;
 
     // This is mostly making sure that we fill in default values.
     $this->setIsCreate(true);
 
     return $this->buildEditFields($object);
   }
 
   final protected function buildEditFields($object) {
     $viewer = $this->getViewer();
 
     $fields = $this->buildCustomEditFields($object);
 
     foreach ($fields as $field) {
       $field
         ->setViewer($viewer)
         ->setObject($object);
     }
 
     $fields = mpull($fields, null, 'getKey');
 
     if ($this->isEngineExtensible()) {
       $extensions = PhabricatorEditEngineExtension::getAllEnabledExtensions();
     } else {
       $extensions = array();
     }
 
     foreach ($extensions as $extension) {
       $extension->setViewer($viewer);
 
       if (!$extension->supportsObject($this, $object)) {
         continue;
       }
 
       $extension_fields = $extension->buildCustomEditFields($this, $object);
 
       // TODO: Validate this in more detail with a more tailored error.
       assert_instances_of($extension_fields, 'PhabricatorEditField');
 
       foreach ($extension_fields as $field) {
         $field
           ->setViewer($viewer)
           ->setObject($object);
 
         $group_key = $field->getBulkEditGroupKey();
         if ($group_key === null) {
           $field->setBulkEditGroupKey('extension');
         }
       }
 
       $extension_fields = mpull($extension_fields, null, 'getKey');
 
       foreach ($extension_fields as $key => $field) {
         $fields[$key] = $field;
       }
     }
 
     $config = $this->getEditEngineConfiguration();
     $fields = $this->willConfigureFields($object, $fields);
     $fields = $config->applyConfigurationToFields($this, $object, $fields);
 
     $fields = $this->applyPageToFields($object, $fields);
 
     return $fields;
   }
 
   protected function willConfigureFields($object, array $fields) {
     return $fields;
   }
 
   final public function supportsSubtypes() {
     try {
       $object = $this->newEditableObject();
     } catch (Exception $ex) {
       return false;
     }
 
     return ($object instanceof PhabricatorEditEngineSubtypeInterface);
   }
 
   final public function newSubtypeMap() {
     return $this->newEditableObject()->newEditEngineSubtypeMap();
   }
 
 
 /* -(  Display Text  )------------------------------------------------------- */
 
 
   /**
    * @task text
    */
   abstract public function getEngineName();
 
 
   /**
    * @task text
    */
   abstract protected function getObjectCreateTitleText($object);
 
   /**
    * @task text
    */
   protected function getFormHeaderText($object) {
     $config = $this->getEditEngineConfiguration();
     return $config->getName();
   }
 
   /**
    * @task text
    */
   abstract protected function getObjectEditTitleText($object);
 
 
   /**
    * @task text
    */
   abstract protected function getObjectCreateShortText();
 
 
   /**
    * @task text
    */
   abstract protected function getObjectName();
 
 
   /**
    * @task text
    */
   abstract protected function getObjectEditShortText($object);
 
 
   /**
    * @task text
    */
   protected function getObjectCreateButtonText($object) {
     return $this->getObjectCreateTitleText($object);
   }
 
 
   /**
    * @task text
    */
   protected function getObjectEditButtonText($object) {
     return pht('Save Changes');
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewSeriousHeaderText($object) {
     return pht('Take Action');
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewSeriousButtonText($object) {
     return pht('Submit');
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewHeaderText($object) {
     return $this->getCommentViewSeriousHeaderText($object);
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewButtonText($object) {
     return $this->getCommentViewSeriousButtonText($object);
   }
 
 
   /**
    * @task text
    */
   protected function getPageHeader($object) {
     return null;
   }
 
 
 
   /**
    * Return a human-readable header describing what this engine is used to do,
    * like "Configure Maniphest Task Forms".
    *
    * @return string Human-readable description of the engine.
    * @task text
    */
   abstract public function getSummaryHeader();
 
 
   /**
    * Return a human-readable summary of what this engine is used to do.
    *
    * @return string Human-readable description of the engine.
    * @task text
    */
   abstract public function getSummaryText();
 
 
 
 
 /* -(  Edit Engine Configuration  )------------------------------------------ */
 
 
   protected function supportsEditEngineConfiguration() {
     return true;
   }
 
   final protected function getEditEngineConfiguration() {
     return $this->editEngineConfiguration;
   }
 
   public function newConfigurationQuery() {
     return id(new PhabricatorEditEngineConfigurationQuery())
       ->setViewer($this->getViewer())
       ->withEngineKeys(array($this->getEngineKey()));
   }
 
   private function loadEditEngineConfigurationWithQuery(
     PhabricatorEditEngineConfigurationQuery $query,
     $sort_method) {
 
     if ($sort_method) {
       $results = $query->execute();
       $results = msort($results, $sort_method);
       $result = head($results);
     } else {
       $result = $query->executeOne();
     }
 
     if (!$result) {
       return null;
     }
 
     $this->editEngineConfiguration = $result;
     return $result;
   }
 
   private function loadEditEngineConfigurationWithIdentifier($identifier) {
     $query = $this->newConfigurationQuery()
       ->withIdentifiers(array($identifier));
 
     return $this->loadEditEngineConfigurationWithQuery($query, null);
   }
 
   private function loadDefaultConfiguration() {
     $query = $this->newConfigurationQuery()
       ->withIdentifiers(
         array(
           self::EDITENGINECONFIG_DEFAULT,
         ))
       ->withIgnoreDatabaseConfigurations(true);
 
     return $this->loadEditEngineConfigurationWithQuery($query, null);
   }
 
   private function loadDefaultCreateConfiguration() {
     $query = $this->newConfigurationQuery()
       ->withIsDefault(true)
       ->withIsDisabled(false);
 
     return $this->loadEditEngineConfigurationWithQuery(
       $query,
       'getCreateSortKey');
   }
 
   public function loadDefaultEditConfiguration($object) {
     $query = $this->newConfigurationQuery()
       ->withIsEdit(true)
       ->withIsDisabled(false);
 
     // If this object supports subtyping, we edit it with a form of the same
     // subtype: so "bug" tasks get edited with "bug" forms.
     if ($object instanceof PhabricatorEditEngineSubtypeInterface) {
       $query->withSubtypes(
         array(
           $object->getEditEngineSubtype(),
         ));
     }
 
     return $this->loadEditEngineConfigurationWithQuery(
       $query,
       'getEditSortKey');
   }
 
   final public function getBuiltinEngineConfigurations() {
     $configurations = $this->newBuiltinEngineConfigurations();
 
     if (!$configurations) {
       throw new Exception(
         pht(
           'EditEngine ("%s") returned no builtin engine configurations, but '.
           'an edit engine must have at least one configuration.',
           get_class($this)));
     }
 
     assert_instances_of($configurations, 'PhabricatorEditEngineConfiguration');
 
     $has_default = false;
     foreach ($configurations as $config) {
       if ($config->getBuiltinKey() == self::EDITENGINECONFIG_DEFAULT) {
         $has_default = true;
       }
     }
 
     if (!$has_default) {
       $first = head($configurations);
       if (!$first->getBuiltinKey()) {
         $first
           ->setBuiltinKey(self::EDITENGINECONFIG_DEFAULT)
           ->setIsDefault(true)
           ->setIsEdit(true);
 
         if (!strlen($first->getName())) {
           $first->setName($this->getObjectCreateShortText());
         }
     } else {
         throw new Exception(
           pht(
             'EditEngine ("%s") returned builtin engine configurations, '.
             'but none are marked as default and the first configuration has '.
             'a different builtin key already. Mark a builtin as default or '.
             'omit the key from the first configuration',
             get_class($this)));
       }
     }
 
     $builtins = array();
     foreach ($configurations as $key => $config) {
       $builtin_key = $config->getBuiltinKey();
 
       if ($builtin_key === null) {
         throw new Exception(
           pht(
             'EditEngine ("%s") returned builtin engine configurations, '.
             'but one (with key "%s") is missing a builtin key. Provide a '.
             'builtin key for each configuration (you can omit it from the '.
             'first configuration in the list to automatically assign the '.
             'default key).',
             get_class($this),
             $key));
       }
 
       if (isset($builtins[$builtin_key])) {
         throw new Exception(
           pht(
             'EditEngine ("%s") returned builtin engine configurations, '.
             'but at least two specify the same builtin key ("%s"). Engines '.
             'must have unique builtin keys.',
             get_class($this),
             $builtin_key));
       }
 
       $builtins[$builtin_key] = $config;
     }
 
 
     return $builtins;
   }
 
   protected function newBuiltinEngineConfigurations() {
     return array(
       $this->newConfiguration(),
     );
   }
 
   final protected function newConfiguration() {
     return PhabricatorEditEngineConfiguration::initializeNewConfiguration(
       $this->getViewer(),
       $this);
   }
 
 
 /* -(  Managing URIs  )------------------------------------------------------ */
 
 
   /**
    * @task uri
    */
   abstract protected function getObjectViewURI($object);
 
 
   /**
    * @task uri
    */
   protected function getObjectCreateCancelURI($object) {
     return $this->getApplication()->getApplicationURI();
   }
 
 
   /**
    * @task uri
    */
   protected function getEditorURI() {
     return $this->getApplication()->getApplicationURI('edit/');
   }
 
 
   /**
    * @task uri
    */
   protected function getObjectEditCancelURI($object) {
     return $this->getObjectViewURI($object);
   }
 
 
   /**
    * @task uri
    */
   public function getEditURI($object = null, $path = null) {
     $parts = array();
 
     $parts[] = $this->getEditorURI();
 
     if ($object && $object->getID()) {
       $parts[] = $object->getID().'/';
     }
 
     if ($path !== null) {
       $parts[] = $path;
     }
 
     return implode('', $parts);
   }
 
   public function getEffectiveObjectViewURI($object) {
     if ($this->getIsCreate()) {
       return $this->getObjectViewURI($object);
     }
 
     $page = $this->getSelectedPage();
     if ($page) {
       $view_uri = $page->getViewURI();
       if ($view_uri !== null) {
         return $view_uri;
       }
     }
 
     return $this->getObjectViewURI($object);
   }
 
   public function getEffectiveObjectEditDoneURI($object) {
     return $this->getEffectiveObjectViewURI($object);
   }
 
   public function getEffectiveObjectEditCancelURI($object) {
     $page = $this->getSelectedPage();
     if ($page) {
       $view_uri = $page->getViewURI();
       if ($view_uri !== null) {
         return $view_uri;
       }
     }
 
     return $this->getObjectEditCancelURI($object);
   }
 
 
 /* -(  Creating and Loading Objects  )--------------------------------------- */
 
 
   /**
    * Initialize a new object for creation.
    *
    * @return object Newly initialized object.
    * @task load
    */
   abstract protected function newEditableObject();
 
 
   /**
    * Build an empty query for objects.
    *
    * @return PhabricatorPolicyAwareQuery Query.
    * @task load
    */
   abstract protected function newObjectQuery();
 
 
   /**
    * Test if this workflow is creating a new object or editing an existing one.
    *
    * @return bool True if a new object is being created.
    * @task load
    */
   final public function getIsCreate() {
     return $this->isCreate;
   }
 
   /**
    * Initialize a new object for object creation via Conduit.
    *
    * @return object Newly initialized object.
    * @param list<wild> Raw transactions.
    * @task load
    */
   protected function newEditableObjectFromConduit(array $raw_xactions) {
     return $this->newEditableObject();
   }
 
   /**
    * Initialize a new object for documentation creation.
    *
    * @return object Newly initialized object.
    * @task load
    */
   protected function newEditableObjectForDocumentation() {
     return $this->newEditableObject();
   }
 
   /**
    * Flag this workflow as a create or edit.
    *
    * @param bool True if this is a create workflow.
    * @return this
    * @task load
    */
   private function setIsCreate($is_create) {
     $this->isCreate = $is_create;
     return $this;
   }
 
 
   /**
    * Try to load an object by ID, PHID, or monogram. This is done primarily
    * to make Conduit a little easier to use.
    *
    * @param wild ID, PHID, or monogram.
    * @param list<const> List of required capability constants, or omit for
    *   defaults.
    * @return object Corresponding editable object.
    * @task load
    */
   private function newObjectFromIdentifier(
     $identifier,
     array $capabilities = array()) {
     if (is_int($identifier) || ctype_digit($identifier)) {
       $object = $this->newObjectFromID($identifier, $capabilities);
 
       if (!$object) {
         throw new Exception(
           pht(
             'No object exists with ID "%s".',
             $identifier));
       }
 
       return $object;
     }
 
     $type_unknown = PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN;
     if (phid_get_type($identifier) != $type_unknown) {
       $object = $this->newObjectFromPHID($identifier, $capabilities);
 
       if (!$object) {
         throw new Exception(
           pht(
             'No object exists with PHID "%s".',
             $identifier));
       }
 
       return $object;
     }
 
     $target = id(new PhabricatorObjectQuery())
       ->setViewer($this->getViewer())
       ->withNames(array($identifier))
       ->executeOne();
     if (!$target) {
       throw new Exception(
         pht(
           'Monogram "%s" does not identify a valid object.',
           $identifier));
     }
 
     $expect = $this->newEditableObject();
     $expect_class = get_class($expect);
     $target_class = get_class($target);
     if ($expect_class !== $target_class) {
       throw new Exception(
         pht(
           'Monogram "%s" identifies an object of the wrong type. Loaded '.
           'object has class "%s", but this editor operates on objects of '.
           'type "%s".',
           $identifier,
           $target_class,
           $expect_class));
     }
 
     // Load the object by PHID using this engine's standard query. This makes
     // sure it's really valid, goes through standard policy check logic, and
     // picks up any `need...()` clauses we want it to load with.
 
     $object = $this->newObjectFromPHID($target->getPHID(), $capabilities);
     if (!$object) {
       throw new Exception(
         pht(
           'Failed to reload object identified by monogram "%s" when '.
           'querying by PHID.',
           $identifier));
     }
 
     return $object;
   }
 
   /**
    * Load an object by ID.
    *
    * @param int Object ID.
    * @param list<const> List of required capability constants, or omit for
    *   defaults.
    * @return object|null Object, or null if no such object exists.
    * @task load
    */
   private function newObjectFromID($id, array $capabilities = array()) {
     $query = $this->newObjectQuery()
       ->withIDs(array($id));
 
     return $this->newObjectFromQuery($query, $capabilities);
   }
 
 
   /**
    * Load an object by PHID.
    *
    * @param phid Object PHID.
    * @param list<const> List of required capability constants, or omit for
    *   defaults.
    * @return object|null Object, or null if no such object exists.
    * @task load
    */
   private function newObjectFromPHID($phid, array $capabilities = array()) {
     $query = $this->newObjectQuery()
       ->withPHIDs(array($phid));
 
     return $this->newObjectFromQuery($query, $capabilities);
   }
 
 
   /**
    * Load an object given a configured query.
    *
    * @param PhabricatorPolicyAwareQuery Configured query.
    * @param list<const> List of required capability constants, or omit for
    *  defaults.
    * @return object|null Object, or null if no such object exists.
    * @task load
    */
   private function newObjectFromQuery(
     PhabricatorPolicyAwareQuery $query,
     array $capabilities = array()) {
 
     $viewer = $this->getViewer();
 
     if (!$capabilities) {
       $capabilities = array(
         PhabricatorPolicyCapability::CAN_VIEW,
         PhabricatorPolicyCapability::CAN_EDIT,
       );
     }
 
     $object = $query
       ->setViewer($viewer)
       ->requireCapabilities($capabilities)
       ->executeOne();
     if (!$object) {
       return null;
     }
 
     return $object;
   }
 
 
   /**
    * Verify that an object is appropriate for editing.
    *
    * @param wild Loaded value.
    * @return void
    * @task load
    */
   private function validateObject($object) {
     if (!$object || !is_object($object)) {
       throw new Exception(
         pht(
           'EditEngine "%s" created or loaded an invalid object: object must '.
           'actually be an object, but is of some other type ("%s").',
           get_class($this),
           gettype($object)));
     }
 
     if (!($object instanceof PhabricatorApplicationTransactionInterface)) {
       throw new Exception(
         pht(
           'EditEngine "%s" created or loaded an invalid object: object (of '.
           'class "%s") must implement "%s", but does not.',
           get_class($this),
           get_class($object),
           'PhabricatorApplicationTransactionInterface'));
     }
   }
 
 
 /* -(  Responding to Web Requests  )----------------------------------------- */
 
 
   final public function buildResponse() {
     $viewer = $this->getViewer();
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     $action = $this->getEditAction();
 
     $capabilities = array();
     $use_default = false;
     $require_create = true;
     switch ($action) {
       case 'comment':
         $capabilities = array(
           PhabricatorPolicyCapability::CAN_VIEW,
         );
         $use_default = true;
         break;
       case 'parameters':
         $use_default = true;
         break;
       case 'nodefault':
       case 'nocreate':
       case 'nomanage':
         $require_create = false;
         break;
       default:
         break;
     }
 
     $object = $this->getTargetObject();
     if (!$object) {
       $id = $request->getURIData('id');
 
       if ($id) {
         $this->setIsCreate(false);
         $object = $this->newObjectFromID($id, $capabilities);
         if (!$object) {
           return new Aphront404Response();
         }
       } else {
         // Make sure the viewer has permission to create new objects of
         // this type if we're going to create a new object.
         if ($require_create) {
           $this->requireCreateCapability();
         }
 
         $this->setIsCreate(true);
         $object = $this->newEditableObject();
       }
     } else {
       $id = $object->getID();
     }
 
     $this->validateObject($object);
 
     if ($use_default) {
       $config = $this->loadDefaultConfiguration();
       if (!$config) {
         return new Aphront404Response();
       }
     } else {
       $form_key = $request->getURIData('formKey');
       if (strlen($form_key)) {
         $config = $this->loadEditEngineConfigurationWithIdentifier($form_key);
 
         if (!$config) {
           return new Aphront404Response();
         }
 
         if ($id && !$config->getIsEdit()) {
           return $this->buildNotEditFormRespose($object, $config);
         }
       } else {
         if ($id) {
           $config = $this->loadDefaultEditConfiguration($object);
           if (!$config) {
             return $this->buildNoEditResponse($object);
           }
         } else {
           $config = $this->loadDefaultCreateConfiguration();
           if (!$config) {
             return $this->buildNoCreateResponse($object);
           }
         }
       }
     }
 
     if ($config->getIsDisabled()) {
       return $this->buildDisabledFormResponse($object, $config);
     }
 
     $page_key = $request->getURIData('pageKey');
     if (!strlen($page_key)) {
       $pages = $this->getPages($object);
       if ($pages) {
         $page_key = head_key($pages);
       }
     }
 
     if (strlen($page_key)) {
       $page = $this->selectPage($object, $page_key);
       if (!$page) {
         return new Aphront404Response();
       }
     }
 
     switch ($action) {
       case 'parameters':
         return $this->buildParametersResponse($object);
       case 'nodefault':
         return $this->buildNoDefaultResponse($object);
       case 'nocreate':
         return $this->buildNoCreateResponse($object);
       case 'nomanage':
         return $this->buildNoManageResponse($object);
       case 'comment':
         return $this->buildCommentResponse($object);
       default:
         return $this->buildEditResponse($object);
     }
   }
 
   private function buildCrumbs($object, $final = false) {
     $controller = $this->getController();
 
     $crumbs = $controller->buildApplicationCrumbsForEditEngine();
     if ($this->getIsCreate()) {
       $create_text = $this->getObjectCreateShortText();
       if ($final) {
         $crumbs->addTextCrumb($create_text);
       } else {
         $edit_uri = $this->getEditURI($object);
         $crumbs->addTextCrumb($create_text, $edit_uri);
       }
     } else {
       $crumbs->addTextCrumb(
         $this->getObjectEditShortText($object),
         $this->getEffectiveObjectViewURI($object));
 
       $edit_text = pht('Edit');
       if ($final) {
         $crumbs->addTextCrumb($edit_text);
       } else {
         $edit_uri = $this->getEditURI($object);
         $crumbs->addTextCrumb($edit_text, $edit_uri);
       }
     }
 
     return $crumbs;
   }
 
   private function buildEditResponse($object) {
     $viewer = $this->getViewer();
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     $fields = $this->buildEditFields($object);
     $template = $object->getApplicationTransactionTemplate();
 
     if ($this->getIsCreate()) {
       $cancel_uri = $this->getObjectCreateCancelURI($object);
       $submit_button = $this->getObjectCreateButtonText($object);
     } else {
       $cancel_uri = $this->getEffectiveObjectEditCancelURI($object);
       $submit_button = $this->getObjectEditButtonText($object);
     }
 
     $config = $this->getEditEngineConfiguration()
       ->attachEngine($this);
 
     // NOTE: Don't prompt users to override locks when creating objects,
     // even if the default settings would create a locked object.
 
     $can_interact = PhabricatorPolicyFilter::canInteract($viewer, $object);
     if (!$can_interact &&
         !$this->getIsCreate() &&
         !$request->getBool('editEngine') &&
         !$request->getBool('overrideLock')) {
 
       $lock = PhabricatorEditEngineLock::newForObject($viewer, $object);
 
       $dialog = $this->getController()
         ->newDialog()
         ->addHiddenInput('overrideLock', true)
         ->setDisableWorkflowOnSubmit(true)
         ->addCancelButton($cancel_uri);
 
       return $lock->willPromptUserForLockOverrideWithDialog($dialog);
     }
 
     $validation_exception = null;
     if ($request->isFormOrHisecPost() && $request->getBool('editEngine')) {
       $submit_fields = $fields;
 
       foreach ($submit_fields as $key => $field) {
         if (!$field->shouldGenerateTransactionsFromSubmit()) {
           unset($submit_fields[$key]);
           continue;
         }
       }
 
       // Before we read the submitted values, store a copy of what we would
       // use if the form was empty so we can figure out which transactions are
       // just setting things to their default values for the current form.
       $defaults = array();
       foreach ($submit_fields as $key => $field) {
         $defaults[$key] = $field->getValueForTransaction();
       }
 
       foreach ($submit_fields as $key => $field) {
         $field->setIsSubmittedForm(true);
 
         if (!$field->shouldReadValueFromSubmit()) {
           continue;
         }
 
         $field->readValueFromSubmit($request);
       }
 
       $xactions = array();
 
       if ($this->getIsCreate()) {
         $xactions[] = id(clone $template)
           ->setTransactionType(PhabricatorTransactions::TYPE_CREATE);
 
         if ($this->supportsSubtypes()) {
           $xactions[] = id(clone $template)
             ->setTransactionType(PhabricatorTransactions::TYPE_SUBTYPE)
             ->setNewValue($config->getSubtype());
         }
       }
 
       foreach ($submit_fields as $key => $field) {
         $field_value = $field->getValueForTransaction();
 
         $type_xactions = $field->generateTransactions(
           clone $template,
           array(
             'value' => $field_value,
           ));
 
         foreach ($type_xactions as $type_xaction) {
           $default = $defaults[$key];
 
           if ($default === $field->getValueForTransaction()) {
             $type_xaction->setIsDefaultTransaction(true);
           }
 
           $xactions[] = $type_xaction;
         }
       }
 
       $editor = $object->getApplicationTransactionEditor()
         ->setActor($viewer)
         ->setContentSourceFromRequest($request)
         ->setCancelURI($cancel_uri)
         ->setContinueOnNoEffect(true);
 
       try {
         $xactions = $this->willApplyTransactions($object, $xactions);
 
         $editor->applyTransactions($object, $xactions);
 
         $this->didApplyTransactions($object, $xactions);
 
         return $this->newEditResponse($request, $object, $xactions);
       } catch (PhabricatorApplicationTransactionValidationException $ex) {
         $validation_exception = $ex;
 
         foreach ($fields as $field) {
           $message = $this->getValidationExceptionShortMessage($ex, $field);
           if ($message === null) {
             continue;
           }
 
           $field->setControlError($message);
         }
       }
     } else {
       if ($this->getIsCreate()) {
         $template = $request->getStr('template');
 
         if (strlen($template)) {
           $template_object = $this->newObjectFromIdentifier(
             $template,
             array(
               PhabricatorPolicyCapability::CAN_VIEW,
             ));
           if (!$template_object) {
             return new Aphront404Response();
           }
         } else {
           $template_object = null;
         }
 
         if ($template_object) {
           $copy_fields = $this->buildEditFields($template_object);
           $copy_fields = mpull($copy_fields, null, 'getKey');
           foreach ($copy_fields as $copy_key => $copy_field) {
             if (!$copy_field->getIsCopyable()) {
               unset($copy_fields[$copy_key]);
             }
           }
         } else {
           $copy_fields = array();
         }
 
         foreach ($fields as $field) {
           if (!$field->shouldReadValueFromRequest()) {
             continue;
           }
 
           $field_key = $field->getKey();
           if (isset($copy_fields[$field_key])) {
             $field->readValueFromField($copy_fields[$field_key]);
           }
 
           $field->readValueFromRequest($request);
         }
       }
     }
 
     $action_button = $this->buildEditFormActionButton($object);
 
     if ($this->getIsCreate()) {
       $header_text = $this->getFormHeaderText($object);
     } else {
       $header_text = $this->getObjectEditTitleText($object);
     }
 
     $show_preview = !$request->isAjax();
 
     if ($show_preview) {
       $previews = array();
       foreach ($fields as $field) {
         $preview = $field->getPreviewPanel();
         if (!$preview) {
           continue;
         }
 
         $control_id = $field->getControlID();
 
         $preview
           ->setControlID($control_id)
           ->setPreviewURI('/transactions/remarkuppreview/');
 
         $previews[] = $preview;
       }
     } else {
       $previews = array();
     }
 
     $form = $this->buildEditForm($object, $fields);
 
     $crumbs = $this->buildCrumbs($object, $final = true);
     $crumbs->setBorder(true);
 
     if ($request->isAjax()) {
       return $this->getController()
         ->newDialog()
         ->setWidth(AphrontDialogView::WIDTH_FULL)
         ->setTitle($header_text)
         ->setValidationException($validation_exception)
         ->appendForm($form)
         ->addCancelButton($cancel_uri)
         ->addSubmitButton($submit_button);
     }
 
     $box_header = id(new PHUIHeaderView())
       ->setHeader($header_text);
 
     if ($action_button) {
       $box_header->addActionLink($action_button);
     }
 
     $box = id(new PHUIObjectBoxView())
       ->setUser($viewer)
       ->setHeader($box_header)
       ->setValidationException($validation_exception)
       ->setBackground(PHUIObjectBoxView::WHITE_CONFIG)
       ->appendChild($form);
 
     // This is fairly questionable, but in use by Settings.
     if ($request->getURIData('formSaved')) {
       $box->setFormSaved(true);
     }
 
     $content = array(
       $box,
       $previews,
     );
 
     $view = new PHUITwoColumnView();
 
     $page_header = $this->getPageHeader($object);
     if ($page_header) {
       $view->setHeader($page_header);
     }
 
     $view->setFooter($content);
 
     $page = $controller->newPage()
       ->setTitle($header_text)
       ->setCrumbs($crumbs)
       ->appendChild($view);
 
     $navigation = $this->getNavigation();
     if ($navigation) {
       $page->setNavigation($navigation);
     }
 
     return $page;
   }
 
   protected function newEditResponse(
     AphrontRequest $request,
     $object,
     array $xactions) {
     return id(new AphrontRedirectResponse())
       ->setURI($this->getEffectiveObjectEditDoneURI($object));
   }
 
   private function buildEditForm($object, array $fields) {
     $viewer = $this->getViewer();
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     $fields = $this->willBuildEditForm($object, $fields);
 
     $request_path = $request->getPath();
 
     $form = id(new AphrontFormView())
       ->setUser($viewer)
       ->setAction($request_path)
       ->addHiddenInput('editEngine', 'true');
 
     foreach ($this->contextParameters as $param) {
       $form->addHiddenInput($param, $request->getStr($param));
     }
 
     $requires_mfa = false;
     if ($object instanceof PhabricatorEditEngineMFAInterface) {
       $mfa_engine = PhabricatorEditEngineMFAEngine::newEngineForObject($object)
         ->setViewer($viewer);
       $requires_mfa = $mfa_engine->shouldRequireMFA();
     }
 
     if ($requires_mfa) {
       $message = pht(
         'You will be required to provide multi-factor credentials to make '.
         'changes.');
       $form->appendChild(
         id(new PHUIInfoView())
           ->setSeverity(PHUIInfoView::SEVERITY_MFA)
           ->setErrors(array($message)));
 
       // TODO: This should also set workflow on the form, so the user doesn't
       // lose any form data if they "Cancel". However, Maniphest currently
       // overrides "newEditResponse()" if the request is Ajax and returns a
       // bag of view data. This can reasonably be cleaned up when workboards
       // get their next iteration.
     }
 
     foreach ($fields as $field) {
       if (!$field->getIsFormField()) {
         continue;
       }
 
       $field->appendToForm($form);
     }
 
     if ($this->getIsCreate()) {
       $cancel_uri = $this->getObjectCreateCancelURI($object);
       $submit_button = $this->getObjectCreateButtonText($object);
     } else {
       $cancel_uri = $this->getEffectiveObjectEditCancelURI($object);
       $submit_button = $this->getObjectEditButtonText($object);
     }
 
     if (!$request->isAjax()) {
       $buttons = id(new AphrontFormSubmitControl())
         ->setValue($submit_button);
 
       if ($cancel_uri) {
         $buttons->addCancelButton($cancel_uri);
       }
 
       $form->appendControl($buttons);
     }
 
     return $form;
   }
 
   protected function willBuildEditForm($object, array $fields) {
     return $fields;
   }
 
   private function buildEditFormActionButton($object) {
     if (!$this->isEngineConfigurable()) {
       return null;
     }
 
     $viewer = $this->getViewer();
 
     $action_view = id(new PhabricatorActionListView())
       ->setUser($viewer);
 
     foreach ($this->buildEditFormActions($object) as $action) {
       $action_view->addAction($action);
     }
 
     $action_button = id(new PHUIButtonView())
       ->setTag('a')
       ->setText(pht('Configure Form'))
       ->setHref('#')
       ->setIcon('fa-gear')
       ->setDropdownMenu($action_view);
 
     return $action_button;
   }
 
   private function buildEditFormActions($object) {
     $actions = array();
 
     if ($this->supportsEditEngineConfiguration()) {
       $engine_key = $this->getEngineKey();
       $config = $this->getEditEngineConfiguration();
 
       $can_manage = PhabricatorPolicyFilter::hasCapability(
         $this->getViewer(),
         $config,
         PhabricatorPolicyCapability::CAN_EDIT);
 
       if ($can_manage) {
         $manage_uri = $config->getURI();
       } else {
         $manage_uri = $this->getEditURI(null, 'nomanage/');
       }
 
       $view_uri = "/transactions/editengine/{$engine_key}/";
 
       $actions[] = id(new PhabricatorActionView())
         ->setLabel(true)
         ->setName(pht('Configuration'));
 
       $actions[] = id(new PhabricatorActionView())
         ->setName(pht('View Form Configurations'))
         ->setIcon('fa-list-ul')
         ->setHref($view_uri);
 
       $actions[] = id(new PhabricatorActionView())
         ->setName(pht('Edit Form Configuration'))
         ->setIcon('fa-pencil')
         ->setHref($manage_uri)
         ->setDisabled(!$can_manage)
         ->setWorkflow(!$can_manage);
     }
 
     $actions[] = id(new PhabricatorActionView())
       ->setLabel(true)
       ->setName(pht('Documentation'));
 
     $actions[] = id(new PhabricatorActionView())
       ->setName(pht('Using HTTP Parameters'))
       ->setIcon('fa-book')
       ->setHref($this->getEditURI($object, 'parameters/'));
 
     $doc_href = PhabricatorEnv::getDoclink('User Guide: Customizing Forms');
     $actions[] = id(new PhabricatorActionView())
       ->setName(pht('User Guide: Customizing Forms'))
       ->setIcon('fa-book')
       ->setHref($doc_href);
 
     return $actions;
   }
 
 
   public function newNUXButton($text) {
     $specs = $this->newCreateActionSpecifications(array());
     $head = head($specs);
 
     return id(new PHUIButtonView())
       ->setTag('a')
       ->setText($text)
       ->setHref($head['uri'])
       ->setDisabled($head['disabled'])
       ->setWorkflow($head['workflow'])
       ->setColor(PHUIButtonView::GREEN);
   }
 
 
   final public function addActionToCrumbs(
     PHUICrumbsView $crumbs,
     array $parameters = array()) {
     $viewer = $this->getViewer();
 
     $specs = $this->newCreateActionSpecifications($parameters);
 
     $head = head($specs);
     $menu_uri = $head['uri'];
 
     $dropdown = null;
     if (count($specs) > 1) {
       $menu_icon = 'fa-caret-square-o-down';
       $menu_name = $this->getObjectCreateShortText();
       $workflow = false;
       $disabled = false;
 
       $dropdown = id(new PhabricatorActionListView())
         ->setUser($viewer);
 
       foreach ($specs as $spec) {
         $dropdown->addAction(
           id(new PhabricatorActionView())
             ->setName($spec['name'])
             ->setIcon($spec['icon'])
             ->setHref($spec['uri'])
             ->setDisabled($head['disabled'])
             ->setWorkflow($head['workflow']));
       }
 
     } else {
       $menu_icon = $head['icon'];
       $menu_name = $head['name'];
 
       $workflow = $head['workflow'];
       $disabled = $head['disabled'];
     }
 
     $action = id(new PHUIListItemView())
       ->setName($menu_name)
       ->setHref($menu_uri)
       ->setIcon($menu_icon)
       ->setWorkflow($workflow)
       ->setDisabled($disabled);
 
     if ($dropdown) {
       $action->setDropdownMenu($dropdown);
     }
 
     $crumbs->addAction($action);
   }
 
 
   /**
    * Build a raw description of available "Create New Object" UI options so
    * other methods can build menus or buttons.
    */
   public function newCreateActionSpecifications(array $parameters) {
     $viewer = $this->getViewer();
 
     $can_create = $this->hasCreateCapability();
     if ($can_create) {
       $configs = $this->loadUsableConfigurationsForCreate();
     } else {
       $configs = array();
     }
 
     $disabled = false;
     $workflow = false;
 
     $menu_icon = 'fa-plus-square';
     $specs = array();
     if (!$configs) {
       if ($viewer->isLoggedIn()) {
         $disabled = true;
       } else {
         // If the viewer isn't logged in, assume they'll get hit with a login
         // dialog and are likely able to create objects after they log in.
         $disabled = false;
       }
       $workflow = true;
 
       if ($can_create) {
         $create_uri = $this->getEditURI(null, 'nodefault/');
       } else {
         $create_uri = $this->getEditURI(null, 'nocreate/');
       }
 
       $specs[] = array(
         'name' => $this->getObjectCreateShortText(),
         'uri' => $create_uri,
         'icon' => $menu_icon,
         'disabled' => $disabled,
         'workflow' => $workflow,
       );
     } else {
       foreach ($configs as $config) {
         $config_uri = $config->getCreateURI();
 
         if ($parameters) {
-          $config_uri = (string)id(new PhutilURI($config_uri))
-            ->setQueryParams($parameters);
+          $config_uri = (string)new PhutilURI($config_uri, $parameters);
         }
 
         $specs[] = array(
           'name' => $config->getDisplayName(),
           'uri' => $config_uri,
           'icon' => 'fa-plus',
           'disabled' => false,
           'workflow' => false,
         );
       }
     }
 
     return $specs;
   }
 
   final public function buildEditEngineCommentView($object) {
     $config = $this->loadDefaultEditConfiguration($object);
 
     if (!$config) {
       // TODO: This just nukes the entire comment form if you don't have access
       // to any edit forms. We might want to tailor this UX a bit.
       return id(new PhabricatorApplicationTransactionCommentView())
         ->setNoPermission(true);
     }
 
     $viewer = $this->getViewer();
 
     $can_interact = PhabricatorPolicyFilter::canInteract($viewer, $object);
     if (!$can_interact) {
       $lock = PhabricatorEditEngineLock::newForObject($viewer, $object);
 
       return id(new PhabricatorApplicationTransactionCommentView())
         ->setEditEngineLock($lock);
     }
 
     $object_phid = $object->getPHID();
     $is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');
 
     if ($is_serious) {
       $header_text = $this->getCommentViewSeriousHeaderText($object);
       $button_text = $this->getCommentViewSeriousButtonText($object);
     } else {
       $header_text = $this->getCommentViewHeaderText($object);
       $button_text = $this->getCommentViewButtonText($object);
     }
 
     $comment_uri = $this->getEditURI($object, 'comment/');
 
     $requires_mfa = false;
     if ($object instanceof PhabricatorEditEngineMFAInterface) {
       $mfa_engine = PhabricatorEditEngineMFAEngine::newEngineForObject($object)
         ->setViewer($viewer);
       $requires_mfa = $mfa_engine->shouldRequireMFA();
     }
 
     $view = id(new PhabricatorApplicationTransactionCommentView())
       ->setUser($viewer)
       ->setObjectPHID($object_phid)
       ->setHeaderText($header_text)
       ->setAction($comment_uri)
       ->setRequiresMFA($requires_mfa)
       ->setSubmitButtonName($button_text);
 
     $draft = PhabricatorVersionedDraft::loadDraft(
       $object_phid,
       $viewer->getPHID());
     if ($draft) {
       $view->setVersionedDraft($draft);
     }
 
     $view->setCurrentVersion($this->loadDraftVersion($object));
 
     $fields = $this->buildEditFields($object);
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $object,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $comment_actions = array();
     foreach ($fields as $field) {
       if (!$field->shouldGenerateTransactionsFromComment()) {
         continue;
       }
 
       if (!$can_edit) {
         if (!$field->getCanApplyWithoutEditCapability()) {
           continue;
         }
       }
 
       $comment_action = $field->getCommentAction();
       if (!$comment_action) {
         continue;
       }
 
       $key = $comment_action->getKey();
 
       // TODO: Validate these better.
 
       $comment_actions[$key] = $comment_action;
     }
 
     $comment_actions = msortv($comment_actions, 'getSortVector');
 
     $view->setCommentActions($comment_actions);
 
     $comment_groups = $this->newCommentActionGroups();
     $view->setCommentActionGroups($comment_groups);
 
     return $view;
   }
 
   protected function loadDraftVersion($object) {
     $viewer = $this->getViewer();
 
     if (!$viewer->isLoggedIn()) {
       return null;
     }
 
     $template = $object->getApplicationTransactionTemplate();
     $conn_r = $template->establishConnection('r');
 
     // Find the most recent transaction the user has written. We'll use this
     // as a version number to make sure that out-of-date drafts get discarded.
     $result = queryfx_one(
       $conn_r,
       'SELECT id AS version FROM %T
         WHERE objectPHID = %s AND authorPHID = %s
         ORDER BY id DESC LIMIT 1',
       $template->getTableName(),
       $object->getPHID(),
       $viewer->getPHID());
 
     if ($result) {
       return (int)$result['version'];
     } else {
       return null;
     }
   }
 
 
 /* -(  Responding to HTTP Parameter Requests  )------------------------------ */
 
 
   /**
    * Respond to a request for documentation on HTTP parameters.
    *
    * @param object Editable object.
    * @return AphrontResponse Response object.
    * @task http
    */
   private function buildParametersResponse($object) {
     $controller = $this->getController();
     $viewer = $this->getViewer();
     $request = $controller->getRequest();
     $fields = $this->buildEditFields($object);
 
     $crumbs = $this->buildCrumbs($object);
     $crumbs->addTextCrumb(pht('HTTP Parameters'));
     $crumbs->setBorder(true);
 
     $header_text = pht(
       'HTTP Parameters: %s',
       $this->getObjectCreateShortText());
 
     $header = id(new PHUIHeaderView())
       ->setHeader($header_text);
 
     $help_view = id(new PhabricatorApplicationEditHTTPParameterHelpView())
       ->setUser($viewer)
       ->setFields($fields);
 
     $document = id(new PHUIDocumentView())
       ->setUser($viewer)
       ->setHeader($header)
       ->appendChild($help_view);
 
     return $controller->newPage()
       ->setTitle(pht('HTTP Parameters'))
       ->setCrumbs($crumbs)
       ->appendChild($document);
   }
 
 
   private function buildError($object, $title, $body) {
     $cancel_uri = $this->getObjectCreateCancelURI($object);
 
     $dialog = $this->getController()
       ->newDialog()
       ->addCancelButton($cancel_uri);
 
     if ($title !== null) {
       $dialog->setTitle($title);
     }
 
     if ($body !== null) {
       $dialog->appendParagraph($body);
     }
 
     return $dialog;
   }
 
 
   private function buildNoDefaultResponse($object) {
     return $this->buildError(
       $object,
       pht('No Default Create Forms'),
       pht(
         'This application is not configured with any forms for creating '.
         'objects that are visible to you and enabled.'));
   }
 
   private function buildNoCreateResponse($object) {
     return $this->buildError(
       $object,
       pht('No Create Permission'),
       pht('You do not have permission to create these objects.'));
   }
 
   private function buildNoManageResponse($object) {
     return $this->buildError(
       $object,
       pht('No Manage Permission'),
       pht(
         'You do not have permission to configure forms for this '.
         'application.'));
   }
 
   private function buildNoEditResponse($object) {
     return $this->buildError(
       $object,
       pht('No Edit Forms'),
       pht(
         'You do not have access to any forms which are enabled and marked '.
         'as edit forms.'));
   }
 
   private function buildNotEditFormRespose($object, $config) {
     return $this->buildError(
       $object,
       pht('Not an Edit Form'),
       pht(
         'This form ("%s") is not marked as an edit form, so '.
         'it can not be used to edit objects.',
         $config->getName()));
   }
 
   private function buildDisabledFormResponse($object, $config) {
     return $this->buildError(
       $object,
       pht('Form Disabled'),
       pht(
         'This form ("%s") has been disabled, so it can not be used.',
         $config->getName()));
   }
 
   private function buildLockedObjectResponse($object) {
     $dialog = $this->buildError($object, null, null);
     $viewer = $this->getViewer();
 
     $lock = PhabricatorEditEngineLock::newForObject($viewer, $object);
     return $lock->willBlockUserInteractionWithDialog($dialog);
   }
 
   private function buildCommentResponse($object) {
     $viewer = $this->getViewer();
 
     if ($this->getIsCreate()) {
       return new Aphront404Response();
     }
 
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     // NOTE: We handle hisec inside the transaction editor with "Sign With MFA"
     // comment actions.
     if (!$request->isFormOrHisecPost()) {
       return new Aphront400Response();
     }
 
     $can_interact = PhabricatorPolicyFilter::canInteract($viewer, $object);
     if (!$can_interact) {
       return $this->buildLockedObjectResponse($object);
     }
 
     $config = $this->loadDefaultEditConfiguration($object);
     if (!$config) {
       return new Aphront404Response();
     }
 
     $fields = $this->buildEditFields($object);
 
     $is_preview = $request->isPreviewRequest();
     $view_uri = $this->getEffectiveObjectViewURI($object);
 
     $template = $object->getApplicationTransactionTemplate();
     $comment_template = $template->getApplicationTransactionCommentObject();
 
     $comment_text = $request->getStr('comment');
 
     $actions = $request->getStr('editengine.actions');
     if ($actions) {
       $actions = phutil_json_decode($actions);
     }
 
     if ($is_preview) {
       $version_key = PhabricatorVersionedDraft::KEY_VERSION;
       $request_version = $request->getInt($version_key);
       $current_version = $this->loadDraftVersion($object);
       if ($request_version >= $current_version) {
         $draft = PhabricatorVersionedDraft::loadOrCreateDraft(
           $object->getPHID(),
           $viewer->getPHID(),
           $current_version);
 
         $is_empty = (!strlen($comment_text) && !$actions);
 
         $draft
           ->setProperty('comment', $comment_text)
           ->setProperty('actions', $actions)
           ->save();
 
         $draft_engine = $this->newDraftEngine($object);
         if ($draft_engine) {
           $draft_engine
             ->setVersionedDraft($draft)
             ->synchronize();
         }
       }
     }
 
     $xactions = array();
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $object,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     if ($actions) {
       $action_map = array();
       foreach ($actions as $action) {
         $type = idx($action, 'type');
         if (!$type) {
           continue;
         }
 
         if (empty($fields[$type])) {
           continue;
         }
 
         $action_map[$type] = $action;
       }
 
       foreach ($action_map as $type => $action) {
         $field = $fields[$type];
 
         if (!$field->shouldGenerateTransactionsFromComment()) {
           continue;
         }
 
         // If you don't have edit permission on the object, you're limited in
         // which actions you can take via the comment form. Most actions
         // need edit permission, but some actions (like "Accept Revision")
         // can be applied by anyone with view permission.
         if (!$can_edit) {
           if (!$field->getCanApplyWithoutEditCapability()) {
             // We know the user doesn't have the capability, so this will
             // raise a policy exception.
             PhabricatorPolicyFilter::requireCapability(
               $viewer,
               $object,
               PhabricatorPolicyCapability::CAN_EDIT);
           }
         }
 
         if (array_key_exists('initialValue', $action)) {
           $field->setInitialValue($action['initialValue']);
         }
 
         $field->readValueFromComment(idx($action, 'value'));
 
         $type_xactions = $field->generateTransactions(
           clone $template,
           array(
             'value' => $field->getValueForTransaction(),
           ));
         foreach ($type_xactions as $type_xaction) {
           $xactions[] = $type_xaction;
         }
       }
     }
 
     $auto_xactions = $this->newAutomaticCommentTransactions($object);
     foreach ($auto_xactions as $xaction) {
       $xactions[] = $xaction;
     }
 
     if (strlen($comment_text) || !$xactions) {
       $xactions[] = id(clone $template)
         ->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
         ->attachComment(
           id(clone $comment_template)
             ->setContent($comment_text));
     }
 
     $editor = $object->getApplicationTransactionEditor()
       ->setActor($viewer)
       ->setContinueOnNoEffect($request->isContinueRequest())
       ->setContinueOnMissingFields(true)
       ->setContentSourceFromRequest($request)
       ->setCancelURI($view_uri)
       ->setRaiseWarnings(!$request->getBool('editEngine.warnings'))
       ->setIsPreview($is_preview);
 
     try {
       $xactions = $editor->applyTransactions($object, $xactions);
     } catch (PhabricatorApplicationTransactionValidationException $ex) {
       return id(new PhabricatorApplicationTransactionValidationResponse())
         ->setCancelURI($view_uri)
         ->setException($ex);
     } catch (PhabricatorApplicationTransactionNoEffectException $ex) {
       return id(new PhabricatorApplicationTransactionNoEffectResponse())
         ->setCancelURI($view_uri)
         ->setException($ex);
     } catch (PhabricatorApplicationTransactionWarningException $ex) {
       return id(new PhabricatorApplicationTransactionWarningResponse())
         ->setCancelURI($view_uri)
         ->setException($ex);
     }
 
     if (!$is_preview) {
       PhabricatorVersionedDraft::purgeDrafts(
         $object->getPHID(),
         $viewer->getPHID());
 
       $draft_engine = $this->newDraftEngine($object);
       if ($draft_engine) {
         $draft_engine
           ->setVersionedDraft(null)
           ->synchronize();
       }
     }
 
     if ($request->isAjax() && $is_preview) {
       $preview_content = $this->newCommentPreviewContent($object, $xactions);
 
       $raw_view_data = $request->getStr('viewData');
       try {
         $view_data = phutil_json_decode($raw_view_data);
       } catch (Exception $ex) {
         $view_data = array();
       }
 
       return id(new PhabricatorApplicationTransactionResponse())
         ->setObject($object)
         ->setViewer($viewer)
         ->setTransactions($xactions)
         ->setIsPreview($is_preview)
         ->setViewData($view_data)
         ->setPreviewContent($preview_content);
     } else {
       return id(new AphrontRedirectResponse())
         ->setURI($view_uri);
     }
   }
 
   protected function newDraftEngine($object) {
     $viewer = $this->getViewer();
 
     if ($object instanceof PhabricatorDraftInterface) {
       $engine = $object->newDraftEngine();
     } else {
       $engine = new PhabricatorBuiltinDraftEngine();
     }
 
     return $engine
       ->setObject($object)
       ->setViewer($viewer);
   }
 
 
 /* -(  Conduit  )------------------------------------------------------------ */
 
 
   /**
    * Respond to a Conduit edit request.
    *
    * This method accepts a list of transactions to apply to an object, and
    * either edits an existing object or creates a new one.
    *
    * @task conduit
    */
   final public function buildConduitResponse(ConduitAPIRequest $request) {
     $viewer = $this->getViewer();
 
     $config = $this->loadDefaultConfiguration();
     if (!$config) {
       throw new Exception(
         pht(
           'Unable to load configuration for this EditEngine ("%s").',
           get_class($this)));
     }
 
     $raw_xactions = $this->getRawConduitTransactions($request);
 
     $identifier = $request->getValue('objectIdentifier');
     if ($identifier) {
       $this->setIsCreate(false);
 
       // After T13186, each transaction can individually weaken or replace the
       // capabilities required to apply it, so we no longer need CAN_EDIT to
       // attempt to apply transactions to objects. In practice, almost all
       // transactions require CAN_EDIT so we won't get very far if we don't
       // have it.
       $capabilities = array(
         PhabricatorPolicyCapability::CAN_VIEW,
       );
 
       $object = $this->newObjectFromIdentifier(
         $identifier,
         $capabilities);
     } else {
       $this->requireCreateCapability();
 
       $this->setIsCreate(true);
       $object = $this->newEditableObjectFromConduit($raw_xactions);
     }
 
     $this->validateObject($object);
 
     $fields = $this->buildEditFields($object);
 
     $types = $this->getConduitEditTypesFromFields($fields);
     $template = $object->getApplicationTransactionTemplate();
 
     $xactions = $this->getConduitTransactions(
       $request,
       $raw_xactions,
       $types,
       $template);
 
     $editor = $object->getApplicationTransactionEditor()
       ->setActor($viewer)
       ->setContentSource($request->newContentSource())
       ->setContinueOnNoEffect(true);
 
     if (!$this->getIsCreate()) {
       $editor->setContinueOnMissingFields(true);
     }
 
     $xactions = $editor->applyTransactions($object, $xactions);
 
     $xactions_struct = array();
     foreach ($xactions as $xaction) {
       $xactions_struct[] = array(
         'phid' => $xaction->getPHID(),
       );
     }
 
     return array(
       'object' => array(
         'id' => (int)$object->getID(),
         'phid' => $object->getPHID(),
       ),
       'transactions' => $xactions_struct,
     );
   }
 
   private function getRawConduitTransactions(ConduitAPIRequest $request) {
     $transactions_key = 'transactions';
 
     $xactions = $request->getValue($transactions_key);
     if (!is_array($xactions)) {
       throw new Exception(
         pht(
           'Parameter "%s" is not a list of transactions.',
           $transactions_key));
     }
 
     foreach ($xactions as $key => $xaction) {
       if (!is_array($xaction)) {
         throw new Exception(
           pht(
             'Parameter "%s" must contain a list of transaction descriptions, '.
             'but item with key "%s" is not a dictionary.',
             $transactions_key,
             $key));
       }
 
       if (!array_key_exists('type', $xaction)) {
         throw new Exception(
           pht(
             'Parameter "%s" must contain a list of transaction descriptions, '.
             'but item with key "%s" is missing a "type" field. Each '.
             'transaction must have a type field.',
             $transactions_key,
             $key));
       }
     }
 
     return $xactions;
   }
 
 
   /**
    * Generate transactions which can be applied from edit actions in a Conduit
    * request.
    *
    * @param ConduitAPIRequest The request.
    * @param list<wild> Raw conduit transactions.
    * @param list<PhabricatorEditType> Supported edit types.
    * @param PhabricatorApplicationTransaction Template transaction.
    * @return list<PhabricatorApplicationTransaction> Generated transactions.
    * @task conduit
    */
   private function getConduitTransactions(
     ConduitAPIRequest $request,
     array $xactions,
     array $types,
     PhabricatorApplicationTransaction $template) {
 
     $viewer = $request->getUser();
     $results = array();
 
     foreach ($xactions as $key => $xaction) {
       $type = $xaction['type'];
       if (empty($types[$type])) {
         throw new Exception(
           pht(
             'Transaction with key "%s" has invalid type "%s". This type is '.
             'not recognized. Valid types are: %s.',
             $key,
             $type,
             implode(', ', array_keys($types))));
       }
     }
 
     if ($this->getIsCreate()) {
       $results[] = id(clone $template)
         ->setTransactionType(PhabricatorTransactions::TYPE_CREATE);
     }
 
     $is_strict = $request->getIsStrictlyTyped();
 
     foreach ($xactions as $xaction) {
       $type = $types[$xaction['type']];
 
       // Let the parameter type interpret the value. This allows you to
       // use usernames in list<user> fields, for example.
       $parameter_type = $type->getConduitParameterType();
 
       $parameter_type->setViewer($viewer);
 
       try {
         $value = $xaction['value'];
         $value = $parameter_type->getValue($xaction, 'value', $is_strict);
         $value = $type->getTransactionValueFromConduit($value);
         $xaction['value'] = $value;
       } catch (Exception $ex) {
         throw new PhutilProxyException(
           pht(
             'Exception when processing transaction of type "%s": %s',
             $xaction['type'],
             $ex->getMessage()),
           $ex);
       }
 
       $type_xactions = $type->generateTransactions(
         clone $template,
         $xaction);
 
       foreach ($type_xactions as $type_xaction) {
         $results[] = $type_xaction;
       }
     }
 
     return $results;
   }
 
 
   /**
    * @return map<string, PhabricatorEditType>
    * @task conduit
    */
   private function getConduitEditTypesFromFields(array $fields) {
     $types = array();
     foreach ($fields as $field) {
       $field_types = $field->getConduitEditTypes();
 
       if ($field_types === null) {
         continue;
       }
 
       foreach ($field_types as $field_type) {
         $types[$field_type->getEditType()] = $field_type;
       }
     }
     return $types;
   }
 
   public function getConduitEditTypes() {
     $config = $this->loadDefaultConfiguration();
     if (!$config) {
       return array();
     }
 
     $object = $this->newEditableObjectForDocumentation();
     $fields = $this->buildEditFields($object);
     return $this->getConduitEditTypesFromFields($fields);
   }
 
   final public static function getAllEditEngines() {
     return id(new PhutilClassMapQuery())
       ->setAncestorClass(__CLASS__)
       ->setUniqueMethod('getEngineKey')
       ->execute();
   }
 
   final public static function getByKey(PhabricatorUser $viewer, $key) {
     return id(new PhabricatorEditEngineQuery())
       ->setViewer($viewer)
       ->withEngineKeys(array($key))
       ->executeOne();
   }
 
   public function getIcon() {
     $application = $this->getApplication();
     return $application->getIcon();
   }
 
   private function loadUsableConfigurationsForCreate() {
     $viewer = $this->getViewer();
 
     $configs = id(new PhabricatorEditEngineConfigurationQuery())
       ->setViewer($viewer)
       ->withEngineKeys(array($this->getEngineKey()))
       ->withIsDefault(true)
       ->withIsDisabled(false)
       ->execute();
 
     $configs = msort($configs, 'getCreateSortKey');
 
     // Attach this specific engine to configurations we load so they can access
     // any runtime configuration. For example, this allows us to generate the
     // correct "Create Form" buttons when editing forms, see T12301.
     foreach ($configs as $config) {
       $config->attachEngine($this);
     }
 
     return $configs;
   }
 
   protected function getValidationExceptionShortMessage(
     PhabricatorApplicationTransactionValidationException $ex,
     PhabricatorEditField $field) {
 
     $xaction_type = $field->getTransactionType();
     if ($xaction_type === null) {
       return null;
     }
 
     return $ex->getShortMessage($xaction_type);
   }
 
   protected function getCreateNewObjectPolicy() {
     return PhabricatorPolicies::POLICY_USER;
   }
 
   private function requireCreateCapability() {
     PhabricatorPolicyFilter::requireCapability(
       $this->getViewer(),
       $this,
       PhabricatorPolicyCapability::CAN_EDIT);
   }
 
   private function hasCreateCapability() {
     return PhabricatorPolicyFilter::hasCapability(
       $this->getViewer(),
       $this,
       PhabricatorPolicyCapability::CAN_EDIT);
   }
 
   public function isCommentAction() {
     return ($this->getEditAction() == 'comment');
   }
 
   public function getEditAction() {
     $controller = $this->getController();
     $request = $controller->getRequest();
     return $request->getURIData('editAction');
   }
 
   protected function newCommentActionGroups() {
     return array();
   }
 
   protected function newAutomaticCommentTransactions($object) {
     return array();
   }
 
   protected function newCommentPreviewContent($object, array $xactions) {
     return null;
   }
 
 
 /* -(  Form Pages  )--------------------------------------------------------- */
 
 
   public function getSelectedPage() {
     return $this->page;
   }
 
 
   private function selectPage($object, $page_key) {
     $pages = $this->getPages($object);
 
     if (empty($pages[$page_key])) {
       return null;
     }
 
     $this->page = $pages[$page_key];
     return $this->page;
   }
 
 
   protected function newPages($object) {
     return array();
   }
 
 
   protected function getPages($object) {
     if ($this->pages === null) {
       $pages = $this->newPages($object);
 
       assert_instances_of($pages, 'PhabricatorEditPage');
       $pages = mpull($pages, null, 'getKey');
 
       $this->pages = $pages;
     }
 
     return $this->pages;
   }
 
   private function applyPageToFields($object, array $fields) {
     $pages = $this->getPages($object);
     if (!$pages) {
       return $fields;
     }
 
     if (!$this->getSelectedPage()) {
       return $fields;
     }
 
     $page_picks = array();
     $default_key = head($pages)->getKey();
     foreach ($pages as $page_key => $page) {
       foreach ($page->getFieldKeys() as $field_key) {
         $page_picks[$field_key] = $page_key;
       }
       if ($page->getIsDefault()) {
         $default_key = $page_key;
       }
     }
 
     $page_map = array_fill_keys(array_keys($pages), array());
     foreach ($fields as $field_key => $field) {
       if (isset($page_picks[$field_key])) {
         $page_map[$page_picks[$field_key]][$field_key] = $field;
         continue;
       }
 
       // TODO: Maybe let the field pick a page to associate itself with so
       // extensions can force themselves onto a particular page?
 
       $page_map[$default_key][$field_key] = $field;
     }
 
     $page = $this->getSelectedPage();
     if (!$page) {
       $page = head($pages);
     }
 
     $selected_key = $page->getKey();
     return $page_map[$selected_key];
   }
 
   protected function willApplyTransactions($object, array $xactions) {
     return $xactions;
   }
 
   protected function didApplyTransactions($object, array $xactions) {
     return;
   }
 
 
 /* -(  Bulk Edits  )--------------------------------------------------------- */
 
   final public function newBulkEditGroupMap() {
     $groups = $this->newBulkEditGroups();
 
     $map = array();
     foreach ($groups as $group) {
       $key = $group->getKey();
 
       if (isset($map[$key])) {
         throw new Exception(
           pht(
             'Two bulk edit groups have the same key ("%s"). Each bulk edit '.
             'group must have a unique key.',
             $key));
       }
 
       $map[$key] = $group;
     }
 
     if ($this->isEngineExtensible()) {
       $extensions = PhabricatorEditEngineExtension::getAllEnabledExtensions();
     } else {
       $extensions = array();
     }
 
     foreach ($extensions as $extension) {
       $extension_groups = $extension->newBulkEditGroups($this);
       foreach ($extension_groups as $group) {
         $key = $group->getKey();
 
         if (isset($map[$key])) {
           throw new Exception(
             pht(
               'Extension "%s" defines a bulk edit group with the same key '.
               '("%s") as the main editor or another extension. Each bulk '.
               'edit group must have a unique key.'));
         }
 
         $map[$key] = $group;
       }
     }
 
     return $map;
   }
 
   protected function newBulkEditGroups() {
     return array(
       id(new PhabricatorBulkEditGroup())
         ->setKey('default')
         ->setLabel(pht('Primary Fields')),
       id(new PhabricatorBulkEditGroup())
         ->setKey('extension')
         ->setLabel(pht('Support Applications')),
     );
   }
 
   final public function newBulkEditMap() {
     $config = $this->loadDefaultConfiguration();
     if (!$config) {
       throw new Exception(
         pht('No default edit engine configuration for bulk edit.'));
     }
 
     $object = $this->newEditableObject();
     $fields = $this->buildEditFields($object);
     $groups = $this->newBulkEditGroupMap();
 
     $edit_types = $this->getBulkEditTypesFromFields($fields);
 
     $map = array();
     foreach ($edit_types as $key => $type) {
       $bulk_type = $type->getBulkParameterType();
       if ($bulk_type === null) {
         continue;
       }
 
       $bulk_label = $type->getBulkEditLabel();
       if ($bulk_label === null) {
         continue;
       }
 
       $group_key = $type->getBulkEditGroupKey();
       if (!$group_key) {
         $group_key = 'default';
       }
 
       if (!isset($groups[$group_key])) {
         throw new Exception(
           pht(
             'Field "%s" has a bulk edit group key ("%s") with no '.
             'corresponding bulk edit group.',
             $key,
             $group_key));
       }
 
       $map[] = array(
         'label' => $bulk_label,
         'xaction' => $key,
         'group' => $group_key,
         'control' => array(
           'type' => $bulk_type->getPHUIXControlType(),
           'spec' => (object)$bulk_type->getPHUIXControlSpecification(),
         ),
       );
     }
 
     return $map;
   }
 
 
   final public function newRawBulkTransactions(array $xactions) {
     $config = $this->loadDefaultConfiguration();
     if (!$config) {
       throw new Exception(
         pht('No default edit engine configuration for bulk edit.'));
     }
 
     $object = $this->newEditableObject();
     $fields = $this->buildEditFields($object);
 
     $edit_types = $this->getBulkEditTypesFromFields($fields);
     $template = $object->getApplicationTransactionTemplate();
 
     $raw_xactions = array();
     foreach ($xactions as $key => $xaction) {
       PhutilTypeSpec::checkMap(
         $xaction,
         array(
           'type' => 'string',
           'value' => 'optional wild',
         ));
 
       $type = $xaction['type'];
       if (!isset($edit_types[$type])) {
         throw new Exception(
           pht(
             'Unsupported bulk edit type "%s".',
             $type));
       }
 
       $edit_type = $edit_types[$type];
 
       // Replace the edit type with the underlying transaction type. Usually
       // these are 1:1 and the transaction type just has more internal noise,
       // but it's possible that this isn't the case.
       $xaction['type'] = $edit_type->getTransactionType();
 
       $value = $xaction['value'];
       $value = $edit_type->getTransactionValueFromBulkEdit($value);
       $xaction['value'] = $value;
 
       $xaction_objects = $edit_type->generateTransactions(
         clone $template,
         $xaction);
 
       foreach ($xaction_objects as $xaction_object) {
         $raw_xaction = array(
           'type' => $xaction_object->getTransactionType(),
           'metadata' => $xaction_object->getMetadata(),
           'new' => $xaction_object->getNewValue(),
         );
 
         if ($xaction_object->hasOldValue()) {
           $raw_xaction['old'] = $xaction_object->getOldValue();
         }
 
         if ($xaction_object->hasComment()) {
           $comment = $xaction_object->getComment();
           $raw_xaction['comment'] = $comment->getContent();
         }
 
         $raw_xactions[] = $raw_xaction;
       }
     }
 
     return $raw_xactions;
   }
 
   private function getBulkEditTypesFromFields(array $fields) {
     $types = array();
 
     foreach ($fields as $field) {
       $field_types = $field->getBulkEditTypes();
 
       if ($field_types === null) {
         continue;
       }
 
       foreach ($field_types as $field_type) {
         $types[$field_type->getEditType()] = $field_type;
       }
     }
 
     return $types;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getPHID() {
     return get_class($this);
   }
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return PhabricatorPolicies::getMostOpenPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getCreateNewObjectPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
 }
diff --git a/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php b/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
index 43cc72eaaa..e077d7a7ec 100644
--- a/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
+++ b/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
@@ -1,607 +1,607 @@
 <?php
 
 /**
  * @task functions Token Functions
  */
 abstract class PhabricatorTypeaheadDatasource extends Phobject {
 
   private $viewer;
   private $query;
   private $rawQuery;
   private $offset;
   private $limit;
   private $parameters = array();
   private $functionStack = array();
   private $isBrowse;
   private $phase = self::PHASE_CONTENT;
 
   const PHASE_PREFIX = 'prefix';
   const PHASE_CONTENT = 'content';
 
   public function setLimit($limit) {
     $this->limit = $limit;
     return $this;
   }
 
   public function getLimit() {
     return $this->limit;
   }
 
   public function setOffset($offset) {
     $this->offset = $offset;
     return $this;
   }
 
   public function getOffset() {
     return $this->offset;
   }
 
   public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   public function getViewer() {
     return $this->viewer;
   }
 
   public function setRawQuery($raw_query) {
     $this->rawQuery = $raw_query;
     return $this;
   }
 
   public function getPrefixQuery() {
     return phutil_utf8_strtolower($this->getRawQuery());
   }
 
   public function getRawQuery() {
     return $this->rawQuery;
   }
 
   public function setQuery($query) {
     $this->query = $query;
     return $this;
   }
 
   public function getQuery() {
     return $this->query;
   }
 
   public function setParameters(array $params) {
     $this->parameters = $params;
     return $this;
   }
 
   public function getParameters() {
     return $this->parameters;
   }
 
   public function getParameter($name, $default = null) {
     return idx($this->parameters, $name, $default);
   }
 
   public function setIsBrowse($is_browse) {
     $this->isBrowse = $is_browse;
     return $this;
   }
 
   public function getIsBrowse() {
     return $this->isBrowse;
   }
 
   public function setPhase($phase) {
     $this->phase = $phase;
     return $this;
   }
 
   public function getPhase() {
     return $this->phase;
   }
 
   public function getDatasourceURI() {
-    $uri = new PhutilURI('/typeahead/class/'.get_class($this).'/');
-    $uri->setQueryParams($this->newURIParameters());
+    $params = $this->newURIParameters();
+    $uri = new PhutilURI('/typeahead/class/'.get_class($this).'/', $params);
     return phutil_string_cast($uri);
   }
 
   public function getBrowseURI() {
     if (!$this->isBrowsable()) {
       return null;
     }
 
-    $uri = new PhutilURI('/typeahead/browse/'.get_class($this).'/');
-    $uri->setQueryParams($this->newURIParameters());
+    $params = $this->newURIParameters();
+    $uri = new PhutilURI('/typeahead/browse/'.get_class($this).'/', $params);
     return phutil_string_cast($uri);
   }
 
   private function newURIParameters() {
     if (!$this->parameters) {
       return array();
     }
 
     $map = array(
       'parameters' => phutil_json_encode($this->parameters),
     );
 
     return $map;
   }
 
   abstract public function getPlaceholderText();
 
   public function getBrowseTitle() {
     return get_class($this);
   }
 
   abstract public function getDatasourceApplicationClass();
   abstract public function loadResults();
 
   protected function loadResultsForPhase($phase, $limit) {
     // By default, sources just load all of their results in every phase and
     // rely on filtering at a higher level to sequence phases correctly.
     $this->setLimit($limit);
     return $this->loadResults();
   }
 
   protected function didLoadResults(array $results) {
     return $results;
   }
 
   public static function tokenizeString($string) {
     $string = phutil_utf8_strtolower($string);
     $string = trim($string);
     if (!strlen($string)) {
       return array();
     }
 
     // NOTE: Splitting on "(" and ")" is important for milestones.
 
     $tokens = preg_split('/[\s\[\]\(\)-]+/u', $string);
     $tokens = array_unique($tokens);
 
     // Make sure we don't return the empty token, as this will boil down to a
     // JOIN against every token.
     foreach ($tokens as $key => $value) {
       if (!strlen($value)) {
         unset($tokens[$key]);
       }
     }
 
     return array_values($tokens);
   }
 
   public function getTokens() {
     return self::tokenizeString($this->getRawQuery());
   }
 
   protected function executeQuery(
     PhabricatorCursorPagedPolicyAwareQuery $query) {
 
     return $query
       ->setViewer($this->getViewer())
       ->setOffset($this->getOffset())
       ->setLimit($this->getLimit())
       ->execute();
   }
 
 
   /**
    * Can the user browse through results from this datasource?
    *
    * Browsable datasources allow the user to switch from typeahead mode to
    * a browse mode where they can scroll through all results.
    *
    * By default, datasources are browsable, but some datasources can not
    * generate a meaningful result set or can't filter results on the server.
    *
    * @return bool
    */
   public function isBrowsable() {
     return true;
   }
 
 
   /**
    * Filter a list of results, removing items which don't match the query
    * tokens.
    *
    * This is useful for datasources which return a static list of hard-coded
    * or configured results and can't easily do query filtering in a real
    * query class. Instead, they can just build the entire result set and use
    * this method to filter it.
    *
    * For datasources backed by database objects, this is often much less
    * efficient than filtering at the query level.
    *
    * @param list<PhabricatorTypeaheadResult> List of typeahead results.
    * @return list<PhabricatorTypeaheadResult> Filtered results.
    */
   protected function filterResultsAgainstTokens(array $results) {
     $tokens = $this->getTokens();
     if (!$tokens) {
       return $results;
     }
 
     $map = array();
     foreach ($tokens as $token) {
       $map[$token] = strlen($token);
     }
 
     foreach ($results as $key => $result) {
       $rtokens = self::tokenizeString($result->getName());
 
       // For each token in the query, we need to find a match somewhere
       // in the result name.
       foreach ($map as $token => $length) {
         // Look for a match.
         $match = false;
         foreach ($rtokens as $rtoken) {
           if (!strncmp($rtoken, $token, $length)) {
             // This part of the result name has the query token as a prefix.
             $match = true;
             break;
           }
         }
 
         if (!$match) {
           // We didn't find a match for this query token, so throw the result
           // away. Try with the next result.
           unset($results[$key]);
           break;
         }
       }
     }
 
     return $results;
   }
 
   protected function newFunctionResult() {
     return id(new PhabricatorTypeaheadResult())
       ->setTokenType(PhabricatorTypeaheadTokenView::TYPE_FUNCTION)
       ->setIcon('fa-asterisk')
       ->addAttribute(pht('Function'));
   }
 
   public function newInvalidToken($name) {
     return id(new PhabricatorTypeaheadTokenView())
       ->setValue($name)
       ->setIcon('fa-exclamation-circle')
       ->setTokenType(PhabricatorTypeaheadTokenView::TYPE_INVALID);
   }
 
   public function renderTokens(array $values) {
     $phids = array();
     $setup = array();
     $tokens = array();
 
     foreach ($values as $key => $value) {
       if (!self::isFunctionToken($value)) {
         $phids[$key] = $value;
       } else {
         $function = $this->parseFunction($value);
         if ($function) {
           $setup[$function['name']][$key] = $function;
         } else {
           $name = pht('Invalid Function: %s', $value);
           $tokens[$key] = $this->newInvalidToken($name)
             ->setKey($value);
         }
       }
     }
 
     // Give special non-function tokens which are also not PHIDs (like statuses
     // and priorities) an opportunity to render.
     $type_unknown = PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN;
     $special = array();
     foreach ($values as $key => $value) {
       if (phid_get_type($value) == $type_unknown) {
         $special[$key] = $value;
       }
     }
 
     if ($special) {
       $special_tokens = $this->renderSpecialTokens($special);
       foreach ($special_tokens as $key => $token) {
         $tokens[$key] = $token;
         unset($phids[$key]);
       }
     }
 
     if ($phids) {
       $handles = $this->getViewer()->loadHandles($phids);
       foreach ($phids as $key => $phid) {
         $handle = $handles[$phid];
         $tokens[$key] = PhabricatorTypeaheadTokenView::newFromHandle($handle);
       }
     }
 
     if ($setup) {
       foreach ($setup as $function_name => $argv_list) {
         // Render the function tokens.
         $function_tokens = $this->renderFunctionTokens(
           $function_name,
           ipull($argv_list, 'argv'));
 
         // Rekey the function tokens using the original array keys.
         $function_tokens = array_combine(
           array_keys($argv_list),
           $function_tokens);
 
         // For any functions which were invalid, set their value to the
         // original input value before it was parsed.
         foreach ($function_tokens as $key => $token) {
           $type = $token->getTokenType();
           if ($type == PhabricatorTypeaheadTokenView::TYPE_INVALID) {
             $token->setKey($values[$key]);
           }
         }
 
         $tokens += $function_tokens;
       }
     }
 
     return array_select_keys($tokens, array_keys($values));
   }
 
   protected function renderSpecialTokens(array $values) {
     return array();
   }
 
 /* -(  Token Functions  )---------------------------------------------------- */
 
 
   /**
    * @task functions
    */
   public function getDatasourceFunctions() {
     return array();
   }
 
 
   /**
    * @task functions
    */
   public function getAllDatasourceFunctions() {
     return $this->getDatasourceFunctions();
   }
 
 
   /**
    * @task functions
    */
   protected function canEvaluateFunction($function) {
     return $this->shouldStripFunction($function);
   }
 
 
   /**
    * @task functions
    */
   protected function shouldStripFunction($function) {
     $functions = $this->getDatasourceFunctions();
     return isset($functions[$function]);
   }
 
 
   /**
    * @task functions
    */
   protected function evaluateFunction($function, array $argv_list) {
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * @task functions
    */
   protected function evaluateValues(array $values) {
     return $values;
   }
 
 
   /**
    * @task functions
    */
   public function evaluateTokens(array $tokens) {
     $results = array();
     $evaluate = array();
     foreach ($tokens as $token) {
       if (!self::isFunctionToken($token)) {
         $results[] = $token;
       } else {
         // Put a placeholder in the result list so that we retain token order
         // when possible. We'll overwrite this below.
         $results[] = null;
         $evaluate[last_key($results)] = $token;
       }
     }
 
     $results = $this->evaluateValues($results);
 
     foreach ($evaluate as $result_key => $function) {
       $function = $this->parseFunction($function);
       if (!$function) {
         throw new PhabricatorTypeaheadInvalidTokenException();
       }
 
       $name = $function['name'];
       $argv = $function['argv'];
 
       $evaluated_tokens = $this->evaluateFunction($name, array($argv));
       if (!$evaluated_tokens) {
         unset($results[$result_key]);
       } else {
         $is_first = true;
         foreach ($evaluated_tokens as $phid) {
           if ($is_first) {
             $results[$result_key] = $phid;
             $is_first = false;
           } else {
             $results[] = $phid;
           }
         }
       }
     }
 
     $results = array_values($results);
     $results = $this->didEvaluateTokens($results);
 
     return $results;
   }
 
 
   /**
    * @task functions
    */
   protected function didEvaluateTokens(array $results) {
     return $results;
   }
 
 
   /**
    * @task functions
    */
   public static function isFunctionToken($token) {
     // We're looking for a "(" so that a string like "members(q" is identified
     // and parsed as a function call. This allows us to start generating
     // results immediately, before the user fully types out "members(quack)".
     return (strpos($token, '(') !== false);
   }
 
 
   /**
    * @task functions
    */
   protected function parseFunction($token, $allow_partial = false) {
     $matches = null;
 
     if ($allow_partial) {
       $ok = preg_match('/^([^(]+)\((.*?)\)?\z/', $token, $matches);
     } else {
       $ok = preg_match('/^([^(]+)\((.*)\)\z/', $token, $matches);
     }
 
     if (!$ok) {
       if (!$allow_partial) {
         throw new PhabricatorTypeaheadInvalidTokenException(
           pht(
             'Unable to parse function and arguments for token "%s".',
             $token));
       }
       return null;
     }
 
     $function = trim($matches[1]);
 
     if (!$this->canEvaluateFunction($function)) {
       if (!$allow_partial) {
         throw new PhabricatorTypeaheadInvalidTokenException(
           pht(
             'This datasource ("%s") can not evaluate the function "%s(...)".',
             get_class($this),
             $function));
       }
 
       return null;
     }
 
     // TODO: There is currently no way to quote characters in arguments, so
     // some characters can't be argument characters. Replace this with a real
     // parser once we get use cases.
 
     $argv = $matches[2];
     $argv = trim($argv);
     if (!strlen($argv)) {
       $argv = array();
     } else {
       $argv = preg_split('/,/', $matches[2]);
       foreach ($argv as $key => $arg) {
         $argv[$key] = trim($arg);
       }
     }
 
     foreach ($argv as $key => $arg) {
       if (self::isFunctionToken($arg)) {
         $subfunction = $this->parseFunction($arg);
 
         $results = $this->evaluateFunction(
           $subfunction['name'],
           array($subfunction['argv']));
 
         $argv[$key] = head($results);
       }
     }
 
     return array(
       'name' => $function,
       'argv' => $argv,
     );
   }
 
 
   /**
    * @task functions
    */
   public function renderFunctionTokens($function, array $argv_list) {
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * @task functions
    */
   public function setFunctionStack(array $function_stack) {
     $this->functionStack = $function_stack;
     return $this;
   }
 
 
   /**
    * @task functions
    */
   public function getFunctionStack() {
     return $this->functionStack;
   }
 
 
   /**
    * @task functions
    */
   protected function getCurrentFunction() {
     return nonempty(last($this->functionStack), null);
   }
 
   protected function renderTokensFromResults(array $results, array $values) {
     $tokens = array();
     foreach ($values as $key => $value) {
       if (empty($results[$value])) {
         continue;
       }
       $tokens[$key] = PhabricatorTypeaheadTokenView::newFromTypeaheadResult(
         $results[$value]);
     }
 
     return $tokens;
   }
 
   public function getWireTokens(array $values) {
     // TODO: This is a bit hacky for now: we're sort of generating wire
     // results, rendering them, then reverting them back to wire results. This
     // is pretty silly. It would probably be much cleaner to make
     // renderTokens() call this method instead, then render from the result
     // structure.
     $rendered = $this->renderTokens($values);
 
     $tokens = array();
     foreach ($rendered as $key => $render) {
       $tokens[$key] = id(new PhabricatorTypeaheadResult())
         ->setPHID($render->getKey())
         ->setIcon($render->getIcon())
         ->setColor($render->getColor())
         ->setDisplayName($render->getValue())
         ->setTokenType($render->getTokenType());
     }
 
     return mpull($tokens, 'getWireFormat', 'getPHID');
   }
 
 }