diff --git a/src/applications/diffusion/controller/DiffusionRepositoryController.php b/src/applications/diffusion/controller/DiffusionRepositoryController.php
index 37a98a0c79..d1486d3f21 100644
--- a/src/applications/diffusion/controller/DiffusionRepositoryController.php
+++ b/src/applications/diffusion/controller/DiffusionRepositoryController.php
@@ -1,579 +1,613 @@
 <?php
 
 final class DiffusionRepositoryController extends DiffusionController {
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function processRequest() {
     $drequest = $this->getDiffusionRequest();
     $repository = $drequest->getRepository();
 
     $content = array();
 
     $crumbs = $this->buildCrumbs();
     $content[] = $crumbs;
 
     $content[] = $this->buildPropertiesTable($drequest->getRepository());
     $phids = array();
 
     try {
       $history_results = $this->callConduitWithDiffusionRequest(
         'diffusion.historyquery',
         array(
           'commit' => $drequest->getCommit(),
           'path' => $drequest->getPath(),
           'offset' => 0,
           'limit' => 15));
       $history = DiffusionPathChange::newFromConduit(
         $history_results['pathChanges']);
 
       foreach ($history as $item) {
         $data = $item->getCommitData();
         if ($data) {
           if ($data->getCommitDetail('authorPHID')) {
             $phids[$data->getCommitDetail('authorPHID')] = true;
           }
           if ($data->getCommitDetail('committerPHID')) {
             $phids[$data->getCommitDetail('committerPHID')] = true;
           }
         }
       }
       $history_exception = null;
     } catch (Exception $ex) {
       $history_results = null;
       $history = null;
       $history_exception = $ex;
     }
 
     try {
       $browse_results = DiffusionBrowseResultSet::newFromConduit(
         $this->callConduitWithDiffusionRequest(
           'diffusion.browsequery',
           array(
             'path' => $drequest->getPath(),
             'commit' => $drequest->getCommit(),
           )));
       $browse_paths = $browse_results->getPaths();
 
       foreach ($browse_paths as $item) {
         $data = $item->getLastCommitData();
         if ($data) {
           if ($data->getCommitDetail('authorPHID')) {
             $phids[$data->getCommitDetail('authorPHID')] = true;
           }
           if ($data->getCommitDetail('committerPHID')) {
             $phids[$data->getCommitDetail('committerPHID')] = true;
           }
         }
       }
 
       $browse_exception = null;
     } catch (Exception $ex) {
       $browse_results = null;
       $browse_paths = null;
       $browse_exception = $ex;
     }
 
     $phids = array_keys($phids);
     $handles = $this->loadViewerHandles($phids);
 
     if ($browse_results) {
       $readme = $this->callConduitWithDiffusionRequest(
         'diffusion.readmequery',
         array(
          'paths' => $browse_results->getPathDicts()
         ));
     } else {
       $readme = null;
     }
 
     $content[] = $this->buildHistoryTable(
       $history_results,
       $history,
       $history_exception,
       $handles);
 
     $content[] = $this->buildBrowseTable(
       $browse_results,
       $browse_paths,
       $browse_exception,
       $handles);
 
     try {
       $content[] = $this->buildTagListTable($drequest);
     } catch (Exception $ex) {
       if (!$repository->isImporting()) {
         $content[] = $this->renderStatusMessage(
           pht('Unable to Load Tags'),
           $ex->getMessage());
       }
     }
 
     try {
       $content[] = $this->buildBranchListTable($drequest);
     } catch (Exception $ex) {
       if (!$repository->isImporting()) {
         $content[] = $this->renderStatusMessage(
           pht('Unable to Load Branches'),
           $ex->getMessage());
       }
     }
 
     if ($readme) {
       $box = new PHUIBoxView();
       $box->appendChild($readme);
       $box->addPadding(PHUI::PADDING_LARGE);
 
       $panel = new PHUIObjectBoxView();
       $panel->setHeaderText(pht('README'));
       $panel->appendChild($box);
       $content[] = $panel;
     }
 
     return $this->buildApplicationPage(
       $content,
       array(
         'title' => $drequest->getRepository()->getName(),
         'device' => true,
       ));
   }
 
   private function buildPropertiesTable(PhabricatorRepository $repository) {
     $user = $this->getRequest()->getUser();
 
     $header = id(new PHUIHeaderView())
       ->setHeader($repository->getName())
       ->setUser($user)
       ->setPolicyObject($repository);
 
     if (!$repository->isTracked()) {
       $header->setStatus('policy-noone', '', pht('Inactive'));
     } else if ($repository->isImporting()) {
       $header->setStatus('time', 'red', pht('Importing...'));
     } else {
       $header->setStatus('oh-ok', '', pht('Active'));
     }
 
 
     $actions = $this->buildActionList($repository);
 
     $view = id(new PHUIPropertyListView())
       ->setUser($user);
     $view->addProperty(pht('Callsign'), $repository->getCallsign());
 
     $project_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $repository->getPHID(),
       PhabricatorEdgeConfig::TYPE_OBJECT_HAS_PROJECT);
     if ($project_phids) {
       $this->loadHandles($project_phids);
       $view->addProperty(
         pht('Projects'),
         $this->renderHandlesForPHIDs($project_phids));
     }
 
     if ($repository->isHosted()) {
       $ssh_uri = $repository->getSSHCloneURIObject();
       if ($ssh_uri) {
-        $clone_uri = $this->renderCloneURI(
+        $clone_uri = $this->renderCloneCommand(
+          $repository,
           $ssh_uri,
           $repository->getServeOverSSH(),
           '/settings/panel/ssh/');
 
-        $view->addProperty(pht('Clone URI (SSH)'), $clone_uri);
+        $view->addProperty(
+          $repository->isSVN()
+            ? pht('Checkout (SSH)')
+            : pht('Clone (SSH)'),
+          $clone_uri);
       }
 
       $http_uri = $repository->getHTTPCloneURIObject();
       if ($http_uri) {
-        $clone_uri = $this->renderCloneURI(
+        $clone_uri = $this->renderCloneCommand(
+          $repository,
           $http_uri,
           $repository->getServeOverHTTP(),
           PhabricatorEnv::getEnvConfig('diffusion.allow-http-auth')
             ? '/settings/panel/vcspassword/'
             : null);
 
-        $view->addProperty(pht('Clone URI (HTTP)'), $clone_uri);
+        $view->addProperty(
+          $repository->isSVN()
+            ? pht('Checkout (HTTP)')
+            : pht('Clone (HTTP)'),
+          $clone_uri);
       }
     } else {
       switch ($repository->getVersionControlSystem()) {
         case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
           $view->addProperty(
-            pht('Clone URI'),
-            $this->renderCloneURI(
+            pht('Clone'),
+            $this->renderCloneCommand(
+              $repository,
               $repository->getPublicCloneURI()));
           break;
         case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
           $view->addProperty(
-            pht('Repository Root'),
-            $this->renderCloneURI(
+            pht('Checkout'),
+            $this->renderCloneCommand(
+              $repository,
               $repository->getPublicCloneURI()));
           break;
       }
     }
 
     $description = $repository->getDetail('description');
     if (strlen($description)) {
       $description = PhabricatorMarkupEngine::renderOneObject(
         $repository,
         'description',
         $user);
       $view->addSectionHeader(pht('Description'));
       $view->addTextContent($description);
     }
 
     $view->setActionList($actions);
 
     return id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->addPropertyList($view);
 
   }
 
   private function buildBranchListTable(DiffusionRequest $drequest) {
     $viewer = $this->getRequest()->getUser();
 
     if ($drequest->getBranch() === null) {
       return null;
     }
 
     $limit = 15;
 
     $branches = $this->callConduitWithDiffusionRequest(
       'diffusion.branchquery',
       array(
         'limit' => $limit + 1,
       ));
     if (!$branches) {
       return null;
     }
 
     $more_branches = (count($branches) > $limit);
     $branches = array_slice($branches, 0, $limit);
 
     $branches = DiffusionRepositoryRef::loadAllFromDictionaries($branches);
 
     $commits = id(new DiffusionCommitQuery())
       ->setViewer($viewer)
       ->withIdentifiers(mpull($branches, 'getCommitIdentifier'))
       ->withRepository($drequest->getRepository())
       ->execute();
 
     $table = id(new DiffusionBranchTableView())
       ->setUser($viewer)
       ->setDiffusionRequest($drequest)
       ->setBranches($branches)
       ->setCommits($commits);
 
     $panel = new PHUIObjectBoxView();
     $header = new PHUIHeaderView();
     $header->setHeader(pht('Branches'));
 
     if ($more_branches) {
       $header->setSubHeader(pht('Showing %d branches.', $limit));
     }
 
     $icon = id(new PHUIIconView())
       ->setSpriteSheet(PHUIIconView::SPRITE_ICONS)
       ->setSpriteIcon('fork');
 
     $button = new PHUIButtonView();
     $button->setText(pht("Show All Branches"));
     $button->setTag('a');
     $button->setIcon($icon);
     $button->setHref($drequest->generateURI(
             array(
               'action' => 'branches',
             )));
 
     $header->addActionLink($button);
     $panel->setHeader($header);
     $panel->appendChild($table);
 
     return $panel;
   }
 
   private function buildTagListTable(DiffusionRequest $drequest) {
     $viewer = $this->getRequest()->getUser();
 
     $tag_limit = 15;
     $tags = array();
     try {
       $tags = DiffusionRepositoryTag::newFromConduit(
         $this->callConduitWithDiffusionRequest(
           'diffusion.tagsquery',
           array(
             // On the home page, we want to find tags on any branch.
             'commit' => null,
             'limit' => $tag_limit + 1,
           )));
     } catch (ConduitException $e) {
       if ($e->getMessage() != 'ERR-UNSUPPORTED-VCS') {
         throw $e;
       }
     }
 
     if (!$tags) {
       return null;
     }
 
     $more_tags = (count($tags) > $tag_limit);
     $tags = array_slice($tags, 0, $tag_limit);
 
     $commits = id(new DiffusionCommitQuery())
       ->setViewer($viewer)
       ->withIdentifiers(mpull($tags, 'getCommitIdentifier'))
       ->withRepository($drequest->getRepository())
       ->needCommitData(true)
       ->execute();
 
     $view = id(new DiffusionTagListView())
       ->setUser($viewer)
       ->setDiffusionRequest($drequest)
       ->setTags($tags)
       ->setCommits($commits);
 
     $phids = $view->getRequiredHandlePHIDs();
     $handles = $this->loadViewerHandles($phids);
     $view->setHandles($handles);
 
     $panel = new PHUIObjectBoxView();
     $header = new PHUIHeaderView();
     $header->setHeader(pht('Tags'));
 
     if ($more_tags) {
       $header->setSubHeader(
         pht('Showing the %d most recent tags.', $tag_limit));
     }
 
     $icon = id(new PHUIIconView())
       ->setSpriteSheet(PHUIIconView::SPRITE_ICONS)
       ->setSpriteIcon('tag');
 
     $button = new PHUIButtonView();
     $button->setText(pht("Show All Tags"));
     $button->setTag('a');
     $button->setIcon($icon);
     $button->setHref($drequest->generateURI(
             array(
               'action' => 'tags',
             )));
 
     $header->addActionLink($button);
 
     $panel->setHeader($header);
     $panel->appendChild($view);
 
     return $panel;
   }
 
   private function buildActionList(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view_uri = $this->getApplicationURI($repository->getCallsign().'/');
     $edit_uri = $this->getApplicationURI($repository->getCallsign().'/edit/');
 
     $view = id(new PhabricatorActionListView())
       ->setUser($viewer)
       ->setObject($repository)
       ->setObjectURI($view_uri);
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $repository,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $view->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Edit Repository'))
         ->setIcon('edit')
         ->setHref($edit_uri)
         ->setWorkflow(!$can_edit)
         ->setDisabled(!$can_edit));
 
     if ($repository->isHosted()) {
       $callsign = $repository->getCallsign();
       $push_uri = $this->getApplicationURI(
         'pushlog/?repositories=r'.$callsign);
 
       $view->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('View Push Logs'))
           ->setIcon('transcript')
           ->setHref($push_uri));
     }
 
     return $view;
   }
 
   private function buildHistoryTable(
     $history_results,
     $history,
     $history_exception,
     array $handles) {
 
     $request = $this->getRequest();
     $viewer = $request->getUser();
     $drequest = $this->getDiffusionRequest();
     $repository = $drequest->getRepository();
 
     if ($history_exception) {
       if ($repository->isImporting()) {
         return $this->renderStatusMessage(
           pht('Still Importing...'),
           pht(
             'This repository is still importing. History is not yet '.
             'available.'));
       } else {
         return $this->renderStatusMessage(
           pht('Unable to Retrieve History'),
           $history_exception->getMessage());
       }
     }
 
     $history_table = id(new DiffusionHistoryTableView())
       ->setUser($viewer)
       ->setDiffusionRequest($drequest)
       ->setHandles($handles)
       ->setHistory($history);
 
     // TODO: Super sketchy.
     $history_table->loadRevisions();
 
     if ($history_results) {
       $history_table->setParents($history_results['parents']);
     }
 
     $history_table->setIsHead(true);
     $callsign = $drequest->getRepository()->getCallsign();
 
     $icon = id(new PHUIIconView())
       ->setSpriteSheet(PHUIIconView::SPRITE_ICONS)
       ->setSpriteIcon('transcript');
 
     $button = id(new PHUIButtonView())
       ->setText(pht('View Full History'))
       ->setHref($drequest->generateURI(
         array(
           'action' => 'history',
         )))
       ->setTag('a')
       ->setIcon($icon);
 
     $panel = new PHUIObjectBoxView();
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('Recent Commits'))
       ->addActionLink($button);
     $panel->setHeader($header);
     $panel->appendChild($history_table);
 
     return $panel;
   }
 
   private function buildBrowseTable(
     $browse_results,
     $browse_paths,
     $browse_exception,
     array $handles) {
 
     $request = $this->getRequest();
     $viewer = $request->getUser();
     $drequest = $this->getDiffusionRequest();
     $repository = $drequest->getRepository();
 
     if ($browse_exception) {
       if ($repository->isImporting()) {
         // The history table renders a useful message.
         return null;
       } else {
         return $this->renderStatusMessage(
           pht('Unable to Retrieve Paths'),
           $browse_exception->getMessage());
       }
     }
 
     $browse_table = id(new DiffusionBrowseTableView())
       ->setUser($viewer)
       ->setDiffusionRequest($drequest)
       ->setHandles($handles);
     if ($browse_paths) {
       $browse_table->setPaths($browse_paths);
     } else {
       $browse_table->setPaths(array());
     }
 
     $browse_uri = $drequest->generateURI(array('action' => 'browse'));
 
     $browse_panel = new PHUIObjectBoxView();
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('Repository'));
 
     $icon = id(new PHUIIconView())
       ->setSpriteSheet(PHUIIconView::SPRITE_ICONS)
       ->setSpriteIcon('data');
 
     $button = new PHUIButtonView();
     $button->setText(pht('Browse Repository'));
     $button->setTag('a');
     $button->setIcon($icon);
     $button->setHref($browse_uri);
 
     $header->addActionLink($button);
     $browse_panel->setHeader($header);
     $browse_panel->appendChild($browse_table);
 
     return $browse_panel;
   }
 
-  private function renderCloneURI(
+  private function renderCloneCommand(
+    PhabricatorRepository $repository,
     $uri,
     $serve_mode = null,
     $manage_uri = null) {
 
     require_celerity_resource('diffusion-icons-css');
 
     Javelin::initBehavior('select-on-click');
 
+    switch ($repository->getVersionControlSystem()) {
+      case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
+        $command = csprintf(
+          'git clone %s %s',
+          $uri,
+          $repository->getCloneName());
+        break;
+      case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
+        $command = csprintf(
+          'hg clone %s %s',
+          $uri,
+          $repository->getCloneName());
+        break;
+      case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
+        $command = csprintf(
+          'svn checkout %s %s',
+          $uri,
+          $repository->getCloneName());
+        break;
+    }
+
     $input = javelin_tag(
       'input',
       array(
         'type' => 'text',
-        'value' => (string)$uri,
+        'value' => (string)$command,
         'class' => 'diffusion-clone-uri',
         'sigil' => 'select-on-click',
         'readonly' => 'true',
       ));
 
     $extras = array();
     if ($serve_mode) {
       if ($serve_mode === PhabricatorRepository::SERVE_READONLY) {
         $extras[] = pht('(Read Only)');
       }
     }
 
     if ($manage_uri) {
       if ($this->getRequest()->getUser()->isLoggedIn()) {
         $extras[] = phutil_tag(
           'a',
           array(
             'href' => $manage_uri,
           ),
           pht('Manage Credentials'));
       }
     }
 
     if ($extras) {
       $extras = phutil_implode_html(' ', $extras);
       $extras = phutil_tag(
         'div',
         array(
           'class' => 'diffusion-clone-extras',
         ),
         $extras);
     }
 
     return array($input, $extras);
   }
 
 }
diff --git a/src/applications/diffusion/controller/DiffusionRepositoryEditBasicController.php b/src/applications/diffusion/controller/DiffusionRepositoryEditBasicController.php
index c7f80987f0..039edcb9a8 100644
--- a/src/applications/diffusion/controller/DiffusionRepositoryEditBasicController.php
+++ b/src/applications/diffusion/controller/DiffusionRepositoryEditBasicController.php
@@ -1,146 +1,162 @@
 <?php
 
 final class DiffusionRepositoryEditBasicController
   extends DiffusionRepositoryEditController {
 
   public function processRequest() {
     $request = $this->getRequest();
     $user = $request->getUser();
     $drequest = $this->diffusionRequest;
     $repository = $drequest->getRepository();
 
     $repository = id(new PhabricatorRepositoryQuery())
       ->setViewer($user)
       ->requireCapabilities(
         array(
           PhabricatorPolicyCapability::CAN_VIEW,
           PhabricatorPolicyCapability::CAN_EDIT,
         ))
       ->needProjectPHIDs(true)
       ->withIDs(array($repository->getID()))
       ->executeOne();
 
     if (!$repository) {
       return new Aphront404Response();
     }
 
     $edit_uri = $this->getRepositoryControllerURI($repository, 'edit/');
 
     $v_name = $repository->getName();
     $v_desc = $repository->getDetail('description');
+    $v_clone_name = $repository->getDetail('clone-name');
     $e_name = true;
     $errors = array();
 
     if ($request->isFormPost()) {
       $v_name = $request->getStr('name');
       $v_desc = $request->getStr('description');
       $v_projects = $request->getArr('projectPHIDs');
+      $v_clone_name = $request->getStr('cloneName');
 
       if (!strlen($v_name)) {
         $e_name = pht('Required');
         $errors[] = pht('Repository name is required.');
       } else {
         $e_name = null;
       }
 
       if (!$errors) {
         $xactions = array();
         $template = id(new PhabricatorRepositoryTransaction());
 
         $type_name = PhabricatorRepositoryTransaction::TYPE_NAME;
         $type_desc = PhabricatorRepositoryTransaction::TYPE_DESCRIPTION;
         $type_edge = PhabricatorTransactions::TYPE_EDGE;
+        $type_clone_name = PhabricatorRepositoryTransaction::TYPE_CLONE_NAME;
 
         $xactions[] = id(clone $template)
           ->setTransactionType($type_name)
           ->setNewValue($v_name);
 
         $xactions[] = id(clone $template)
           ->setTransactionType($type_desc)
           ->setNewValue($v_desc);
 
+        $xactions[] = id(clone $template)
+          ->setTransactionType($type_clone_name)
+          ->setNewValue($v_clone_name);
+
         $xactions[] = id(clone $template)
           ->setTransactionType($type_edge)
           ->setMetadataValue(
             'edge:type',
             PhabricatorEdgeConfig::TYPE_OBJECT_HAS_PROJECT)
           ->setNewValue(
             array(
               '=' => array_fuse($v_projects),
             ));
 
         id(new PhabricatorRepositoryEditor())
           ->setContinueOnNoEffect(true)
           ->setContentSourceFromRequest($request)
           ->setActor($user)
           ->applyTransactions($repository, $xactions);
 
         return id(new AphrontRedirectResponse())->setURI($edit_uri);
       }
     }
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb(pht('Edit Basics'));
 
     $title = pht('Edit %s', $repository->getName());
     $project_handles = $this->loadViewerHandles($repository->getProjectPHIDs());
 
     $form = id(new AphrontFormView())
       ->setUser($user)
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setName('name')
           ->setLabel(pht('Name'))
           ->setValue($v_name)
           ->setError($e_name))
+      ->appendChild(
+        id(new AphrontFormTextControl())
+          ->setName('cloneName')
+          ->setLabel(pht('Clone/Checkout As'))
+          ->setValue($v_clone_name)
+          ->setCaption(
+            pht(
+              'Optional directory name to use when cloning or checking out '.
+              'this repository.')))
       ->appendChild(
         id(new PhabricatorRemarkupControl())
           ->setName('description')
           ->setLabel(pht('Description'))
           ->setValue($v_desc))
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/projects/')
           ->setName('projectPHIDs')
           ->setLabel(pht('Projects'))
           ->setValue($project_handles))
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue(pht('Save'))
           ->addCancelButton($edit_uri))
       ->appendChild(id(new PHUIFormDividerControl()))
       ->appendRemarkupInstructions($this->getReadmeInstructions());
 
     $object_box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->setForm($form)
       ->setFormErrors($errors);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $object_box),
       array(
         'title' => $title,
         'device' => true,
       ));
   }
 
   private function getReadmeInstructions() {
     return pht(<<<EOTEXT
 You can also create a `README` file at the repository root (or in any
 subdirectory) to provide information about the repository. These formats are
 supported:
 
 | File Name       | Rendered As... |
 |-----------------|----------------|
 | `README`          | Plain Text |
 | `README.txt`      | Plain Text |
 | `README.remarkup` | Remarkup |
 | `README.md`       | Remarkup |
 | `README.rainbow`  | \xC2\xA1Fiesta! |
 EOTEXT
 );
   }
 
 }
diff --git a/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php b/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php
index a9ff6247ab..4ca2b301ca 100644
--- a/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php
+++ b/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php
@@ -1,1071 +1,1080 @@
 <?php
 
 final class DiffusionRepositoryEditMainController
   extends DiffusionRepositoryEditController {
 
   public function processRequest() {
     $request = $this->getRequest();
     $viewer = $request->getUser();
     $drequest = $this->diffusionRequest;
     $repository = $drequest->getRepository();
 
     PhabricatorPolicyFilter::requireCapability(
       $viewer,
       $repository,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $is_svn = false;
     $is_git = false;
     $is_hg = false;
     switch ($repository->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $is_git = true;
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $is_svn = true;
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $is_hg = true;
         break;
     }
 
     $has_branches = ($is_git || $is_hg);
     $has_local = $repository->usesLocalWorkingCopy();
 
     $crumbs = $this->buildApplicationCrumbs($is_main = true);
 
     $title = pht('Edit %s', $repository->getName());
 
     $header = id(new PHUIHeaderView())
       ->setHeader($title);
     if ($repository->isTracked()) {
       $header->setStatus('oh-ok', '', pht('Active'));
     } else {
       $header->setStatus('policy-noone', '', pht('Inactive'));
     }
 
     $basic_actions = $this->buildBasicActions($repository);
     $basic_properties =
       $this->buildBasicProperties($repository, $basic_actions);
 
     $policy_actions = $this->buildPolicyActions($repository);
     $policy_properties =
       $this->buildPolicyProperties($repository, $policy_actions);
 
     $remote_properties = null;
     if (!$repository->isHosted()) {
       $remote_properties = $this->buildRemoteProperties(
         $repository,
         $this->buildRemoteActions($repository));
     }
 
     $encoding_actions = $this->buildEncodingActions($repository);
     $encoding_properties =
       $this->buildEncodingProperties($repository, $encoding_actions);
 
     $hosting_properties = $this->buildHostingProperties(
       $repository,
       $this->buildHostingActions($repository));
 
 
     $branches_properties = null;
     if ($has_branches) {
       $branches_properties = $this->buildBranchesProperties(
         $repository,
         $this->buildBranchesActions($repository));
     }
 
     $subversion_properties = null;
     if ($is_svn) {
       $subversion_properties = $this->buildSubversionProperties(
         $repository,
         $this->buildSubversionActions($repository));
     }
 
     $local_properties = null;
     if ($has_local) {
       $local_properties = $this->buildLocalProperties(
         $repository,
         $this->buildLocalActions($repository));
     }
 
     $actions_properties = $this->buildActionsProperties(
       $repository,
       $this->buildActionsActions($repository));
 
     $xactions = id(new PhabricatorRepositoryTransactionQuery())
       ->setViewer($viewer)
       ->withObjectPHIDs(array($repository->getPHID()))
       ->execute();
 
     $engine = id(new PhabricatorMarkupEngine())
       ->setViewer($viewer);
     foreach ($xactions as $xaction) {
       if ($xaction->getComment()) {
         $engine->addObject(
           $xaction->getComment(),
           PhabricatorApplicationTransactionComment::MARKUP_FIELD_COMMENT);
       }
     }
     $engine->process();
 
     $xaction_view = id(new PhabricatorApplicationTransactionView())
       ->setUser($viewer)
       ->setObjectPHID($repository->getPHID())
       ->setTransactions($xactions)
       ->setMarkupEngine($engine);
 
     $boxes = array();
 
     $boxes[] = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->addPropertyList($basic_properties);
 
     $boxes[] = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Policies'))
       ->addPropertyList($policy_properties);
 
     $boxes[] = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Hosting'))
       ->addPropertyList($hosting_properties);
 
     if ($repository->canMirror()) {
       $mirror_actions = $this->buildMirrorActions($repository);
       $mirror_properties = $this->buildMirrorProperties(
         $repository,
         $mirror_actions);
 
       $mirrors = id(new PhabricatorRepositoryMirrorQuery())
         ->setViewer($viewer)
         ->withRepositoryPHIDs(array($repository->getPHID()))
         ->execute();
 
       $mirror_list = $this->buildMirrorList($repository, $mirrors);
 
       $boxes[] = id(new PhabricatorAnchorView())->setAnchorName('mirrors');
 
       $boxes[] = id(new PHUIObjectBoxView())
         ->setHeaderText(pht('Mirrors'))
         ->addPropertyList($mirror_properties);
 
       $boxes[] = $mirror_list;
     }
 
     if ($remote_properties) {
       $boxes[] = id(new PHUIObjectBoxView())
         ->setHeaderText(pht('Remote'))
         ->addPropertyList($remote_properties);
     }
 
     if ($local_properties) {
       $boxes[] = id(new PHUIObjectBoxView())
         ->setHeaderText(pht('Local'))
         ->addPropertyList($local_properties);
     }
 
     $boxes[] = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Text Encoding'))
       ->addPropertyList($encoding_properties);
 
     if ($branches_properties) {
       $boxes[] = id(new PHUIObjectBoxView())
         ->setHeaderText(pht('Branches'))
         ->addPropertyList($branches_properties);
     }
 
     if ($subversion_properties) {
       $boxes[] = id(new PHUIObjectBoxView())
         ->setHeaderText(pht('Subversion'))
         ->addPropertyList($subversion_properties);
     }
 
     $boxes[] = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Actions'))
       ->addPropertyList($actions_properties);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $boxes,
         $xaction_view,
       ),
       array(
         'title' => $title,
         'device' => true,
       ));
   }
 
   private function buildBasicActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Basic Information'))
       ->setHref($this->getRepositoryControllerURI($repository, 'edit/basic/'));
     $view->addAction($edit);
 
     $activate = id(new PhabricatorActionView())
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/activate/'))
       ->setWorkflow(true);
 
     if ($repository->isTracked()) {
       $activate
         ->setIcon('disable')
         ->setName(pht('Deactivate Repository'));
     } else {
       $activate
         ->setIcon('enable')
         ->setName(pht('Activate Repository'));
     }
 
     $view->addAction($activate);
 
     $view->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Delete Repository'))
         ->setIcon('delete')
         ->setHref(
           $this->getRepositoryControllerURI($repository, 'edit/delete/'))
         ->setDisabled(true)
         ->setWorkflow(true));
 
     return $view;
   }
 
   private function buildBasicProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $type = PhabricatorRepositoryType::getNameForRepositoryType(
       $repository->getVersionControlSystem());
 
     $view->addProperty(pht('Type'), $type);
     $view->addProperty(pht('Callsign'), $repository->getCallsign());
 
+
+    $clone_name = $repository->getDetail('clone-name');
+
+    $view->addProperty(
+      pht('Clone/Checkout As'),
+      $clone_name
+        ? $clone_name.'/'
+        : phutil_tag('em', array(), $repository->getCloneName().'/'));
+
     $project_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $repository->getPHID(),
       PhabricatorEdgeConfig::TYPE_OBJECT_HAS_PROJECT);
     if ($project_phids) {
       $this->loadHandles($project_phids);
       $view->addProperty(
         pht('Projects'),
         $this->renderHandlesForPHIDs($project_phids));
     }
 
     $view->addProperty(
       pht('Status'),
       $this->buildRepositoryStatus($repository));
 
     $description = $repository->getDetail('description');
     $view->addSectionHeader(pht('Description'));
     if (!strlen($description)) {
       $description = phutil_tag('em', array(), pht('No description provided.'));
     } else {
       $description = PhabricatorMarkupEngine::renderOneObject(
         $repository,
         'description',
         $viewer);
     }
     $view->addTextContent($description);
 
     return $view;
   }
 
   private function buildEncodingActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Text Encoding'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/encoding/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildEncodingProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $encoding = $repository->getDetail('encoding');
     if (!$encoding) {
       $encoding = phutil_tag('em', array(), pht('Use Default (UTF-8)'));
     }
 
     $view->addProperty(pht('Encoding'), $encoding);
 
     return $view;
   }
 
   private function buildPolicyActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Policies'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/policy/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildPolicyProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $descriptions = PhabricatorPolicyQuery::renderPolicyDescriptions(
       $viewer,
       $repository);
 
     $view->addProperty(
       pht('Visible To'),
       $descriptions[PhabricatorPolicyCapability::CAN_VIEW]);
 
     $view->addProperty(
       pht('Editable By'),
       $descriptions[PhabricatorPolicyCapability::CAN_EDIT]);
 
     $pushable = $repository->isHosted()
       ? $descriptions[DiffusionCapabilityPush::CAPABILITY]
       : phutil_tag('em', array(), pht('Not a Hosted Repository'));
     $view->addProperty(pht('Pushable By'), $pushable);
 
     return $view;
   }
 
   private function buildBranchesActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Branches'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/branches/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildBranchesProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $default_branch = nonempty(
       $repository->getHumanReadableDetail('default-branch'),
       phutil_tag('em', array(), $repository->getDefaultBranch()));
     $view->addProperty(pht('Default Branch'), $default_branch);
 
     $track_only = nonempty(
       $repository->getHumanReadableDetail('branch-filter', array()),
       phutil_tag('em', array(), pht('Track All Branches')));
     $view->addProperty(pht('Track Only'), $track_only);
 
     $autoclose_only = nonempty(
       $repository->getHumanReadableDetail('close-commits-filter', array()),
       phutil_tag('em', array(), pht('Autoclose On All Branches')));
 
     if ($repository->getDetail('disable-autoclose')) {
       $autoclose_only = phutil_tag('em', array(), pht('Disabled'));
     }
 
     $view->addProperty(pht('Autoclose Only'), $autoclose_only);
 
     return $view;
   }
 
   private function buildSubversionActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Subversion Info'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/subversion/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildSubversionProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $svn_uuid = nonempty(
       $repository->getUUID(),
       phutil_tag('em', array(), pht('Not Configured')));
     $view->addProperty(pht('Subversion UUID'), $svn_uuid);
 
     $svn_subpath = nonempty(
       $repository->getHumanReadableDetail('svn-subpath'),
       phutil_tag('em', array(), pht('Import Entire Repository')));
     $view->addProperty(pht('Import Only'), $svn_subpath);
 
     return $view;
   }
 
   private function buildActionsActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Actions'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/actions/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildActionsProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $notify = $repository->getDetail('herald-disabled')
       ? pht('Off')
       : pht('On');
     $notify = phutil_tag('em', array(), $notify);
     $view->addProperty(pht('Publish/Notify'), $notify);
 
     $autoclose = $repository->getDetail('disable-autoclose')
       ? pht('Off')
       : pht('On');
     $autoclose = phutil_tag('em', array(), $autoclose);
     $view->addProperty(pht('Autoclose'), $autoclose);
 
     return $view;
   }
 
   private function buildRemoteActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Remote'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/remote/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildRemoteProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $view->addProperty(
       pht('Remote URI'),
       $repository->getHumanReadableDetail('remote-uri'));
 
     $credential_phid = $repository->getCredentialPHID();
     if ($credential_phid) {
       $this->loadHandles(array($credential_phid));
       $view->addProperty(
         pht('Credential'),
         $this->getHandle($credential_phid)->renderLink());
     }
 
     return $view;
   }
 
   private function buildLocalActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Local'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/local/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildLocalProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $view->addProperty(
       pht('Local Path'),
       $repository->getHumanReadableDetail('local-path'));
 
     return $view;
   }
 
   private function buildHostingActions(PhabricatorRepository $repository) {
     $user = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($user);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Hosting'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/hosting/'));
     $view->addAction($edit);
 
     if ($repository->canAllowDangerousChanges()) {
       if ($repository->shouldAllowDangerousChanges()) {
         $changes = id(new PhabricatorActionView())
           ->setIcon('blame')
           ->setName(pht('Prevent Dangerous Changes'))
           ->setHref(
             $this->getRepositoryControllerURI($repository, 'edit/dangerous/'))
           ->setWorkflow(true);
       } else {
         $changes = id(new PhabricatorActionView())
           ->setIcon('warning')
           ->setName(pht('Allow Dangerous Changes'))
           ->setHref(
             $this->getRepositoryControllerURI($repository, 'edit/dangerous/'))
           ->setWorkflow(true);
       }
       $view->addAction($changes);
     }
 
     return $view;
   }
 
   private function buildHostingProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $user = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($user)
       ->setActionList($actions);
 
     $hosting = $repository->isHosted()
       ? pht('Hosted on Phabricator')
       : pht('Hosted Elsewhere');
     $view->addProperty(pht('Hosting'), phutil_tag('em', array(), $hosting));
 
     $view->addProperty(
       pht('Serve over HTTP'),
       phutil_tag(
         'em',
         array(),
         PhabricatorRepository::getProtocolAvailabilityName(
           $repository->getServeOverHTTP())));
 
     $view->addProperty(
       pht('Serve over SSH'),
       phutil_tag(
         'em',
         array(),
         PhabricatorRepository::getProtocolAvailabilityName(
           $repository->getServeOverSSH())));
 
     if ($repository->canAllowDangerousChanges()) {
       if ($repository->shouldAllowDangerousChanges()) {
         $description = pht('Allowed');
       } else {
         $description = pht('Not Allowed');
       }
 
       $view->addProperty(
         pht('Dangerous Changes'),
         $description);
     }
 
     return $view;
   }
 
   private function buildRepositoryStatus(
     PhabricatorRepository $repository) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = new PHUIStatusListView();
 
     $messages = id(new PhabricatorRepositoryStatusMessage())
       ->loadAllWhere('repositoryID = %d', $repository->getID());
     $messages = mpull($messages, null, 'getStatusType');
 
     if ($repository->isTracked()) {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon('accept-green')
           ->setTarget(pht('Repository Active')));
     } else {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon('warning')
           ->setTarget(pht('Repository Inactive'))
           ->setNote(
             pht('Activate this repository to begin or resume import.')));
       return $view;
     }
 
     $binaries = array();
     switch ($repository->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $binaries[] = 'git';
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $binaries[] = 'svn';
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $binaries[] = 'hg';
         break;
     }
 
     if ($repository->isHosted()) {
       if ($repository->getServeOverHTTP() != PhabricatorRepository::SERVE_OFF) {
         switch ($repository->getVersionControlSystem()) {
           case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
             $binaries[] = 'git-http-backend';
             break;
           case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
             $binaries[] = 'svnserve';
             $binaries[] = 'svnadmin';
             break;
           case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
             $binaries[] = 'hg';
             break;
         }
       }
       if ($repository->getServeOverSSH() != PhabricatorRepository::SERVE_OFF) {
         switch ($repository->getVersionControlSystem()) {
           case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
             $binaries[] = 'git-receive-pack';
             $binaries[] = 'git-upload-pack';
             break;
           case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
             $binaries[] = 'svnserve';
             $binaries[] = 'svnadmin';
             break;
           case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
             $binaries[] = 'hg';
             break;
         }
       }
     }
 
     $binaries = array_unique($binaries);
     foreach ($binaries as $binary) {
       $where = Filesystem::resolveBinary($binary);
       if (!$where) {
         $config_href = '/config/edit/environment.append-paths/';
         $config_link = phutil_tag(
           'a',
           array(
             'href' => $config_href,
           ),
           'environment.append-paths');
 
         $view->addItem(
           id(new PHUIStatusItemView())
             ->setIcon('warning-red')
             ->setTarget(
               pht('Missing Binary %s', phutil_tag('tt', array(), $binary)))
             ->setNote(pht(
               "Unable to find this binary in the webserver's PATH. You may ".
               "need to configure %s.",
               $config_link)));
       } else {
         $view->addItem(
           id(new PHUIStatusItemView())
             ->setIcon('accept-green')
             ->setTarget(
               pht('Found Binary %s', phutil_tag('tt', array(), $binary)))
             ->setNote(phutil_tag('tt', array(), $where)));
       }
     }
 
     $doc_href = PhabricatorEnv::getDocLink(
       'article/Managing_Daemons_with_phd.html');
     $daemon_instructions = pht(
       'Use %s to start daemons. See %s.',
       phutil_tag('tt', array(), 'bin/phd start'),
       phutil_tag(
         'a',
         array(
           'href' => $doc_href,
         ),
         pht('Managing Daemons with phd')));
 
 
     $pull_daemon = id(new PhabricatorDaemonLogQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withStatus(PhabricatorDaemonLogQuery::STATUS_ALIVE)
       ->withDaemonClasses(array('PhabricatorRepositoryPullLocalDaemon'))
       ->setLimit(1)
       ->execute();
 
     if ($pull_daemon) {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon('accept-green')
           ->setTarget(pht('Pull Daemon Running')));
     } else {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon('warning-red')
           ->setTarget(pht('Pull Daemon Not Running'))
           ->setNote($daemon_instructions));
     }
 
 
     $task_daemon = id(new PhabricatorDaemonLogQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withStatus(PhabricatorDaemonLogQuery::STATUS_ALIVE)
       ->withDaemonClasses(array('PhabricatorTaskmasterDaemon'))
       ->setLimit(1)
       ->execute();
     if ($task_daemon) {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon('accept-green')
           ->setTarget(pht('Task Daemon Running')));
     } else {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon('warning-red')
           ->setTarget(pht('Task Daemon Not Running'))
           ->setNote($daemon_instructions));
     }
 
     if ($repository->usesLocalWorkingCopy()) {
       $local_parent = dirname($repository->getLocalPath());
       if (Filesystem::pathExists($local_parent)) {
         $view->addItem(
           id(new PHUIStatusItemView())
             ->setIcon('accept-green')
             ->setTarget(pht('Storage Directory OK'))
             ->setNote(phutil_tag('tt', array(), $local_parent)));
       } else {
         $view->addItem(
           id(new PHUIStatusItemView())
             ->setIcon('warning-red')
             ->setTarget(pht('No Storage Directory'))
             ->setNote(
               pht(
                 'Storage directory %s does not exist, or is not readable by '.
                 'the webserver. Create this directory or make it readable.',
                 phutil_tag('tt', array(), $local_parent))));
         return $view;
       }
 
       $local_path = $repository->getLocalPath();
       $message = idx($messages, PhabricatorRepositoryStatusMessage::TYPE_INIT);
       if ($message) {
         switch ($message->getStatusCode()) {
           case PhabricatorRepositoryStatusMessage::CODE_ERROR:
             $view->addItem(
               id(new PHUIStatusItemView())
                 ->setIcon('warning-red')
                 ->setTarget(pht('Initialization Error'))
                 ->setNote($message->getParameter('message')));
             return $view;
           case PhabricatorRepositoryStatusMessage::CODE_OKAY:
               if (Filesystem::pathExists($local_path)) {
                 $view->addItem(
                   id(new PHUIStatusItemView())
                     ->setIcon('accept-green')
                     ->setTarget(pht('Working Copy OK'))
                     ->setNote(phutil_tag('tt', array(), $local_path)));
               } else {
                 $view->addItem(
                   id(new PHUIStatusItemView())
                     ->setIcon('warning-red')
                     ->setTarget(pht('Working Copy Error'))
                     ->setNote(
                       pht(
                         'Working copy %s has been deleted, or is not '.
                         'readable by the webserver. Make this directory '.
                         'readable. If it has been deleted, the daemons should '.
                         'restore it automatically.',
                         phutil_tag('tt', array(), $local_path))));
                 return $view;
               }
             break;
           case PhabricatorRepositoryStatusMessage::CODE_WORKING:
             $view->addItem(
               id(new PHUIStatusItemView())
                 ->setIcon('time-green')
                 ->setTarget(pht('Initializing Working Copy'))
                 ->setNote(pht('Daemons are initializing the working copy.')));
             return $view;
           default:
             $view->addItem(
               id(new PHUIStatusItemView())
                 ->setIcon('warning-red')
                 ->setTarget(pht('Unknown Init Status'))
                 ->setNote($message->getStatusCode()));
             return $view;
         }
       } else {
         $view->addItem(
           id(new PHUIStatusItemView())
             ->setIcon('time-orange')
             ->setTarget(pht('No Working Copy Yet'))
             ->setNote(
               pht('Waiting for daemons to build a working copy.')));
         return $view;
       }
     }
 
     $message = idx($messages, PhabricatorRepositoryStatusMessage::TYPE_FETCH);
     if ($message) {
       switch ($message->getStatusCode()) {
         case PhabricatorRepositoryStatusMessage::CODE_ERROR:
           $view->addItem(
             id(new PHUIStatusItemView())
               ->setIcon('warning-red')
               ->setTarget(pht('Update Error'))
               ->setNote($message->getParameter('message')));
           return $view;
         case PhabricatorRepositoryStatusMessage::CODE_OKAY:
           $view->addItem(
             id(new PHUIStatusItemView())
               ->setIcon('accept-green')
               ->setTarget(pht('Updates OK'))
               ->setNote(
                 pht(
                   'Last updated %s.',
                   phabricator_datetime($message->getEpoch(), $viewer))));
           break;
       }
     } else {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon('time-orange')
           ->setTarget(pht('Waiting For Update'))
           ->setNote(
             pht('Waiting for daemons to read updates.')));
     }
 
     if ($repository->isImporting()) {
       $progress = queryfx_all(
         $repository->establishConnection('r'),
         'SELECT importStatus, count(*) N FROM %T WHERE repositoryID = %d
           GROUP BY importStatus',
         id(new PhabricatorRepositoryCommit())->getTableName(),
         $repository->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) {
         $percentage = 100 * ($done / $total);
       } else {
         $percentage = 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 ($percentage > 99.99) {
         $percentage = 99.99;
       }
 
       $percentage = sprintf('%.2f%%', $percentage);
 
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon('time-green')
           ->setTarget(pht('Importing'))
           ->setNote(
             pht('%s Complete', $percentage)));
     } else {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon('accept-green')
           ->setTarget(pht('Fully Imported')));
     }
 
     if (idx($messages, PhabricatorRepositoryStatusMessage::TYPE_NEEDS_UPDATE)) {
       $view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon('up')
           ->setTarget(pht('Prioritized'))
           ->setNote(pht('This repository will be updated soon.')));
     }
 
     return $view;
   }
 
   private function buildMirrorActions(
     PhabricatorRepository $repository) {
 
     $viewer = $this->getRequest()->getUser();
 
     $mirror_actions = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $new_mirror_uri = $this->getRepositoryControllerURI(
       $repository,
       'mirror/edit/');
 
     $mirror_actions->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Add Mirror'))
         ->setIcon('new')
         ->setHref($new_mirror_uri)
         ->setWorkflow(true));
 
     return $mirror_actions;
   }
 
   private function buildMirrorProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $mirror_properties = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
     $mirror_properties->addProperty(
       '',
       phutil_tag(
         'em',
         array(),
         pht('Automatically push changes into other remotes.')));
 
     return $mirror_properties;
   }
 
   private function buildMirrorList(
     PhabricatorRepository $repository,
     array $mirrors) {
     assert_instances_of($mirrors, 'PhabricatorRepositoryMirror');
 
     $mirror_list = id(new PHUIObjectItemListView())
       ->setNoDataString(pht('This repository has no configured mirrors.'));
 
     foreach ($mirrors as $mirror) {
       $item = id(new PHUIObjectItemView())
         ->setHeader($mirror->getRemoteURI());
 
       $edit_uri = $this->getRepositoryControllerURI(
         $repository,
         'mirror/edit/'.$mirror->getID().'/');
 
       $delete_uri = $this->getRepositoryControllerURI(
         $repository,
         'mirror/delete/'.$mirror->getID().'/');
 
       $item->addAction(
         id(new PHUIListItemView())
           ->setIcon('edit')
           ->setHref($edit_uri)
           ->setWorkflow(true));
 
       $item->addAction(
         id(new PHUIListItemView())
           ->setIcon('delete')
           ->setHref($delete_uri)
           ->setWorkflow(true));
 
       $mirror_list->addItem($item);
     }
 
     return $mirror_list;
   }
 
 
 }
diff --git a/src/applications/repository/editor/PhabricatorRepositoryEditor.php b/src/applications/repository/editor/PhabricatorRepositoryEditor.php
index 19a747cbc0..399302c363 100644
--- a/src/applications/repository/editor/PhabricatorRepositoryEditor.php
+++ b/src/applications/repository/editor/PhabricatorRepositoryEditor.php
@@ -1,305 +1,313 @@
 <?php
 
 final class PhabricatorRepositoryEditor
   extends PhabricatorApplicationTransactionEditor {
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorRepositoryTransaction::TYPE_VCS;
     $types[] = PhabricatorRepositoryTransaction::TYPE_ACTIVATE;
     $types[] = PhabricatorRepositoryTransaction::TYPE_NAME;
     $types[] = PhabricatorRepositoryTransaction::TYPE_DESCRIPTION;
     $types[] = PhabricatorRepositoryTransaction::TYPE_ENCODING;
     $types[] = PhabricatorRepositoryTransaction::TYPE_DEFAULT_BRANCH;
     $types[] = PhabricatorRepositoryTransaction::TYPE_TRACK_ONLY;
     $types[] = PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE_ONLY;
     $types[] = PhabricatorRepositoryTransaction::TYPE_UUID;
     $types[] = PhabricatorRepositoryTransaction::TYPE_SVN_SUBPATH;
     $types[] = PhabricatorRepositoryTransaction::TYPE_NOTIFY;
     $types[] = PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE;
     $types[] = PhabricatorRepositoryTransaction::TYPE_REMOTE_URI;
     $types[] = PhabricatorRepositoryTransaction::TYPE_SSH_LOGIN;
     $types[] = PhabricatorRepositoryTransaction::TYPE_SSH_KEY;
     $types[] = PhabricatorRepositoryTransaction::TYPE_SSH_KEYFILE;
     $types[] = PhabricatorRepositoryTransaction::TYPE_HTTP_LOGIN;
     $types[] = PhabricatorRepositoryTransaction::TYPE_HTTP_PASS;
     $types[] = PhabricatorRepositoryTransaction::TYPE_LOCAL_PATH;
     $types[] = PhabricatorRepositoryTransaction::TYPE_HOSTING;
     $types[] = PhabricatorRepositoryTransaction::TYPE_PROTOCOL_HTTP;
     $types[] = PhabricatorRepositoryTransaction::TYPE_PROTOCOL_SSH;
     $types[] = PhabricatorRepositoryTransaction::TYPE_PUSH_POLICY;
     $types[] = PhabricatorRepositoryTransaction::TYPE_CREDENTIAL;
     $types[] = PhabricatorRepositoryTransaction::TYPE_DANGEROUS;
+    $types[] = PhabricatorRepositoryTransaction::TYPE_CLONE_NAME;
 
     $types[] = PhabricatorTransactions::TYPE_EDGE;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorRepositoryTransaction::TYPE_VCS:
         return $object->getVersionControlSystem();
       case PhabricatorRepositoryTransaction::TYPE_ACTIVATE:
         return $object->isTracked();
       case PhabricatorRepositoryTransaction::TYPE_NAME:
         return $object->getName();
       case PhabricatorRepositoryTransaction::TYPE_DESCRIPTION:
         return $object->getDetail('description');
       case PhabricatorRepositoryTransaction::TYPE_ENCODING:
         return $object->getDetail('encoding');
       case PhabricatorRepositoryTransaction::TYPE_DEFAULT_BRANCH:
         return $object->getDetail('default-branch');
       case PhabricatorRepositoryTransaction::TYPE_TRACK_ONLY:
         return array_keys($object->getDetail('branch-filter', array()));
       case PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE_ONLY:
         return array_keys($object->getDetail('close-commits-filter', array()));
       case PhabricatorRepositoryTransaction::TYPE_UUID:
         return $object->getUUID();
       case PhabricatorRepositoryTransaction::TYPE_SVN_SUBPATH:
         return $object->getDetail('svn-subpath');
       case PhabricatorRepositoryTransaction::TYPE_NOTIFY:
         return (int)!$object->getDetail('herald-disabled');
       case PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE:
         return (int)!$object->getDetail('disable-autoclose');
       case PhabricatorRepositoryTransaction::TYPE_REMOTE_URI:
         return $object->getDetail('remote-uri');
       case PhabricatorRepositoryTransaction::TYPE_LOCAL_PATH:
         return $object->getDetail('local-path');
       case PhabricatorRepositoryTransaction::TYPE_HOSTING:
         return $object->isHosted();
       case PhabricatorRepositoryTransaction::TYPE_PROTOCOL_HTTP:
         return $object->getServeOverHTTP();
       case PhabricatorRepositoryTransaction::TYPE_PROTOCOL_SSH:
         return $object->getServeOverSSH();
       case PhabricatorRepositoryTransaction::TYPE_PUSH_POLICY:
         return $object->getPushPolicy();
       case PhabricatorRepositoryTransaction::TYPE_CREDENTIAL:
         return $object->getCredentialPHID();
       case PhabricatorRepositoryTransaction::TYPE_DANGEROUS:
         return $object->shouldAllowDangerousChanges();
+      case PhabricatorRepositoryTransaction::TYPE_CLONE_NAME:
+        return $object->getDetail('clone-name');
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorRepositoryTransaction::TYPE_ACTIVATE:
       case PhabricatorRepositoryTransaction::TYPE_NAME:
       case PhabricatorRepositoryTransaction::TYPE_DESCRIPTION:
       case PhabricatorRepositoryTransaction::TYPE_ENCODING:
       case PhabricatorRepositoryTransaction::TYPE_DEFAULT_BRANCH:
       case PhabricatorRepositoryTransaction::TYPE_TRACK_ONLY:
       case PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE_ONLY:
       case PhabricatorRepositoryTransaction::TYPE_UUID:
       case PhabricatorRepositoryTransaction::TYPE_SVN_SUBPATH:
       case PhabricatorRepositoryTransaction::TYPE_REMOTE_URI:
       case PhabricatorRepositoryTransaction::TYPE_SSH_LOGIN:
       case PhabricatorRepositoryTransaction::TYPE_SSH_KEY:
       case PhabricatorRepositoryTransaction::TYPE_SSH_KEYFILE:
       case PhabricatorRepositoryTransaction::TYPE_HTTP_LOGIN:
       case PhabricatorRepositoryTransaction::TYPE_HTTP_PASS:
       case PhabricatorRepositoryTransaction::TYPE_LOCAL_PATH:
       case PhabricatorRepositoryTransaction::TYPE_VCS:
       case PhabricatorRepositoryTransaction::TYPE_HOSTING:
       case PhabricatorRepositoryTransaction::TYPE_PROTOCOL_HTTP:
       case PhabricatorRepositoryTransaction::TYPE_PROTOCOL_SSH:
       case PhabricatorRepositoryTransaction::TYPE_PUSH_POLICY:
       case PhabricatorRepositoryTransaction::TYPE_CREDENTIAL:
       case PhabricatorRepositoryTransaction::TYPE_DANGEROUS:
+      case PhabricatorRepositoryTransaction::TYPE_CLONE_NAME:
         return $xaction->getNewValue();
       case PhabricatorRepositoryTransaction::TYPE_NOTIFY:
       case PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE:
         return (int)$xaction->getNewValue();
     }
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorRepositoryTransaction::TYPE_VCS:
         $object->setVersionControlSystem($xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_ACTIVATE:
         $object->setDetail('tracking-enabled', $xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_NAME:
         $object->setName($xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_DESCRIPTION:
         $object->setDetail('description', $xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_DEFAULT_BRANCH:
         $object->setDetail('default-branch', $xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_TRACK_ONLY:
         $object->setDetail(
           'branch-filter',
           array_fill_keys($xaction->getNewValue(), true));
         break;
       case PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE_ONLY:
         $object->setDetail(
           'close-commits-filter',
           array_fill_keys($xaction->getNewValue(), true));
         break;
       case PhabricatorRepositoryTransaction::TYPE_UUID:
         $object->setUUID($xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_SVN_SUBPATH:
         $object->setDetail('svn-subpath', $xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_NOTIFY:
         $object->setDetail('herald-disabled', (int)!$xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE:
         $object->setDetail('disable-autoclose', (int)!$xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_REMOTE_URI:
         $object->setDetail('remote-uri', $xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_LOCAL_PATH:
         $object->setDetail('local-path', $xaction->getNewValue());
         break;
       case PhabricatorRepositoryTransaction::TYPE_HOSTING:
         return $object->setHosted($xaction->getNewValue());
       case PhabricatorRepositoryTransaction::TYPE_PROTOCOL_HTTP:
         return $object->setServeOverHTTP($xaction->getNewValue());
       case PhabricatorRepositoryTransaction::TYPE_PROTOCOL_SSH:
         return $object->setServeOverSSH($xaction->getNewValue());
       case PhabricatorRepositoryTransaction::TYPE_PUSH_POLICY:
         return $object->setPushPolicy($xaction->getNewValue());
       case PhabricatorRepositoryTransaction::TYPE_CREDENTIAL:
         return $object->setCredentialPHID($xaction->getNewValue());
       case PhabricatorRepositoryTransaction::TYPE_DANGEROUS:
         $object->setDetail('allow-dangerous-changes', $xaction->getNewValue());
         return;
+      case PhabricatorRepositoryTransaction::TYPE_CLONE_NAME:
+        $object->setDetail('clone-name', $xaction->getNewValue());
+        return;
       case PhabricatorRepositoryTransaction::TYPE_ENCODING:
         // Make sure the encoding is valid by converting to UTF-8. This tests
         // that the user has mbstring installed, and also that they didn't type
         // a garbage encoding name. Note that we're converting from UTF-8 to
         // the target encoding, because mbstring is fine with converting from
         // a nonsense encoding.
         $encoding = $xaction->getNewValue();
         if (strlen($encoding)) {
           try {
             phutil_utf8_convert('.', $encoding, 'UTF-8');
           } catch (Exception $ex) {
             throw new PhutilProxyException(
               pht(
                 "Error setting repository encoding '%s': %s'",
                 $encoding,
                 $ex->getMessage()),
               $ex);
           }
         }
         $object->setDetail('encoding', $encoding);
         break;
     }
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorRepositoryTransaction::TYPE_CREDENTIAL:
         // Adjust the object <-> credential edge for this repository.
 
         $old_phid = $xaction->getOldValue();
         $new_phid = $xaction->getNewValue();
 
         $editor = id(new PhabricatorEdgeEditor())
           ->setActor($this->requireActor());
 
         $edge_type = PhabricatorEdgeConfig::TYPE_OBJECT_USES_CREDENTIAL;
         $src_phid = $object->getPHID();
 
         if ($old_phid) {
           $editor->removeEdge($src_phid, $edge_type, $old_phid);
         }
 
         if ($new_phid) {
           $editor->addEdge($src_phid, $edge_type, $new_phid);
         }
 
         $editor->save();
         break;
     }
 
   }
 
   protected function mergeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $type = $u->getTransactionType();
     switch ($type) {
     }
 
     return parent::mergeTransactions($u, $v);
   }
 
   protected function transactionHasEffect(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $old = $xaction->getOldValue();
     $new = $xaction->getNewValue();
 
     $type = $xaction->getTransactionType();
     switch ($type) {
 
     }
 
     return parent::transactionHasEffect($object, $xaction);
   }
 
   protected function requireCapabilities(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorRepositoryTransaction::TYPE_ACTIVATE:
       case PhabricatorRepositoryTransaction::TYPE_NAME:
       case PhabricatorRepositoryTransaction::TYPE_DESCRIPTION:
       case PhabricatorRepositoryTransaction::TYPE_ENCODING:
       case PhabricatorRepositoryTransaction::TYPE_DEFAULT_BRANCH:
       case PhabricatorRepositoryTransaction::TYPE_TRACK_ONLY:
       case PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE_ONLY:
       case PhabricatorRepositoryTransaction::TYPE_UUID:
       case PhabricatorRepositoryTransaction::TYPE_SVN_SUBPATH:
       case PhabricatorRepositoryTransaction::TYPE_REMOTE_URI:
       case PhabricatorRepositoryTransaction::TYPE_SSH_LOGIN:
       case PhabricatorRepositoryTransaction::TYPE_SSH_KEY:
       case PhabricatorRepositoryTransaction::TYPE_SSH_KEYFILE:
       case PhabricatorRepositoryTransaction::TYPE_HTTP_LOGIN:
       case PhabricatorRepositoryTransaction::TYPE_HTTP_PASS:
       case PhabricatorRepositoryTransaction::TYPE_LOCAL_PATH:
       case PhabricatorRepositoryTransaction::TYPE_VCS:
       case PhabricatorRepositoryTransaction::TYPE_NOTIFY:
       case PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE:
       case PhabricatorRepositoryTransaction::TYPE_HOSTING:
       case PhabricatorRepositoryTransaction::TYPE_PROTOCOL_HTTP:
       case PhabricatorRepositoryTransaction::TYPE_PROTOCOL_SSH:
       case PhabricatorRepositoryTransaction::TYPE_PUSH_POLICY:
       case PhabricatorRepositoryTransaction::TYPE_CREDENTIAL:
       case PhabricatorRepositoryTransaction::TYPE_DANGEROUS:
+      case PhabricatorRepositoryTransaction::TYPE_CLONE_NAME:
         PhabricatorPolicyFilter::requireCapability(
           $this->requireActor(),
           $object,
           PhabricatorPolicyCapability::CAN_EDIT);
         break;
     }
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepository.php b/src/applications/repository/storage/PhabricatorRepository.php
index 1dd390b8b1..dd70348b82 100644
--- a/src/applications/repository/storage/PhabricatorRepository.php
+++ b/src/applications/repository/storage/PhabricatorRepository.php
@@ -1,1255 +1,1283 @@
 <?php
 
 /**
  * @task uri Repository URI Management
  */
 final class PhabricatorRepository extends PhabricatorRepositoryDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorFlaggableInterface,
     PhabricatorMarkupInterface {
 
   /**
    * Shortest hash we'll recognize in raw "a829f32" form.
    */
   const MINIMUM_UNQUALIFIED_HASH = 7;
 
   /**
    * Shortest hash we'll recognize in qualified "rXab7ef2f8" form.
    */
   const MINIMUM_QUALIFIED_HASH = 5;
 
   const TABLE_PATH = 'repository_path';
   const TABLE_PATHCHANGE = 'repository_pathchange';
   const TABLE_FILESYSTEM = 'repository_filesystem';
   const TABLE_SUMMARY = 'repository_summary';
   const TABLE_BADCOMMIT = 'repository_badcommit';
   const TABLE_LINTMESSAGE = 'repository_lintmessage';
 
   const SERVE_OFF = 'off';
   const SERVE_READONLY = 'readonly';
   const SERVE_READWRITE = 'readwrite';
 
   protected $name;
   protected $callsign;
   protected $uuid;
   protected $viewPolicy;
   protected $editPolicy;
   protected $pushPolicy;
 
   protected $versionControlSystem;
   protected $details = array();
   protected $credentialPHID;
 
   private $commitCount = self::ATTACHABLE;
   private $mostRecentCommit = self::ATTACHABLE;
   private $projectPHIDs = self::ATTACHABLE;
 
   public static function initializeNewRepository(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorApplicationDiffusion'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(DiffusionCapabilityDefaultView::CAPABILITY);
     $edit_policy = $app->getPolicy(DiffusionCapabilityDefaultEdit::CAPABILITY);
     $push_policy = $app->getPolicy(DiffusionCapabilityDefaultPush::CAPABILITY);
 
     return id(new PhabricatorRepository())
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setPushPolicy($push_policy);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'details' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorRepositoryPHIDTypeRepository::TYPECONST);
   }
 
   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(),
     );
   }
 
   public function getMonogram() {
     return 'r'.$this->getCallsign();
   }
 
   public function getDetail($key, $default = null) {
     return idx($this->details, $key, $default);
   }
 
   public function getHumanReadableDetail($key, $default = null) {
     $value = $this->getDetail($key, $default);
 
     switch ($key) {
       case 'branch-filter':
       case 'close-commits-filter':
         $value = array_keys($value);
         $value = implode(', ', $value);
         break;
     }
 
     return $value;
   }
 
   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 getLocalPath() {
     return $this->getDetail('local-path');
   }
 
   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("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->getDetail('clone-name');
+
+    // 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;
+  }
+
+
 /* -(  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) {
     $argv = $this->formatRemoteCommand($argv);
     $future = newv('ExecFuture', $argv);
     $future->setEnv($this->getRemoteCommandEnvironment());
     return $future;
   }
 
   private function newRemoteCommandPassthru(array $argv) {
     $argv = $this->formatRemoteCommand($argv);
     $passthru = newv('PhutilExecPassthru', $argv);
     $passthru->setEnv($this->getRemoteCommandEnvironment());
     return $passthru;
   }
 
 
 /* -(  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();
 
     $argv = $this->formatLocalCommand($argv);
     $future = newv('ExecFuture', $argv);
     $future->setEnv($this->getLocalCommandEnvironment());
 
     if ($this->usesLocalWorkingCopy()) {
       $future->setCWD($this->getLocalPath());
     }
 
     return $future;
   }
 
   private function newLocalCommandPassthru(array $argv) {
     $this->assertLocalExists();
 
     $argv = $this->formatLocalCommand($argv);
     $future = newv('PhutilExecPassthru', $argv);
     $future->setEnv($this->getLocalCommandEnvironment());
 
     if ($this->usesLocalWorkingCopy()) {
       $future->setCWD($this->getLocalPath());
     }
 
     return $future;
   }
 
 
 /* -(  Command Infrastructure  )--------------------------------------------- */
 
 
   private function getSSHWrapper() {
     $root = dirname(phutil_get_library_root('phabricator'));
     return $root.'/bin/ssh-connect';
   }
 
   private function getCommonCommandEnvironment() {
     $env = array(
       // NOTE: Force the language to "en_US.UTF-8", which overrides locale
       // settings. This makes stuff print in English instead of, e.g., French,
       // so we can parse the output of some commands, error messages, etc.
       'LANG' => 'en_US.UTF-8',
 
       // Propagate PHABRICATOR_ENV explicitly. For discussion, see T4155.
       'PHABRICATOR_ENV' => PhabricatorEnv::getSelectedEnvironmentName(),
     );
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         // NOTE: See T2965. Some time after Git 1.7.5.4, Git started fataling if
         // it can not read $HOME. For many users, $HOME points at /root (this
         // seems to be a default result of Apache setup). Instead, explicitly
         // point $HOME at a readable, empty directory so that Git looks for the
         // config file it's after, fails to locate it, and moves on. This is
         // really silly, but seems like the least damaging approach to
         // mitigating the issue.
 
         $root = dirname(phutil_get_library_root('phabricator'));
         $env['HOME'] = $root.'/support/empty/';
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         // NOTE: This overrides certain configuration, extensions, and settings
         // which make Mercurial commands do random unusual things.
         $env['HGPLAIN'] = 1;
         break;
       default:
         throw new Exception("Unrecognized version control system.");
     }
 
     return $env;
   }
 
   private function getLocalCommandEnvironment() {
     return $this->getCommonCommandEnvironment();
   }
 
   private function getRemoteCommandEnvironment() {
     $env = $this->getCommonCommandEnvironment();
 
     if ($this->shouldUseSSH()) {
       // NOTE: This is read by `bin/ssh-connect`, and tells it which credentials
       // to use.
       $env['PHABRICATOR_CREDENTIAL'] = $this->getCredentialPHID();
       switch ($this->getVersionControlSystem()) {
         case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
           // Force SVN to use `bin/ssh-connect`.
           $env['SVN_SSH'] = $this->getSSHWrapper();
           break;
         case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
           // Force Git to use `bin/ssh-connect`.
           $env['GIT_SSH'] = $this->getSSHWrapper();
           break;
         case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
           // We force Mercurial through `bin/ssh-connect` too, but it uses a
           // command-line flag instead of an environmental variable.
           break;
         default:
           throw new Exception("Unrecognized version control system.");
       }
     }
 
     return $env;
   }
 
   private function formatRemoteCommand(array $args) {
     $pattern = $args[0];
     $args = array_slice($args, 1);
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         if ($this->shouldUseHTTP() || $this->shouldUseSVNProtocol()) {
           $flags = array();
           $flag_args = array();
           $flags[] = '--non-interactive';
           $flags[] = '--no-auth-cache';
           if ($this->shouldUseHTTP()) {
             $flags[] = '--trust-server-cert';
           }
 
           $credential_phid = $this->getCredentialPHID();
           if ($credential_phid) {
             $key = PassphrasePasswordKey::loadFromPHID(
               $credential_phid,
               PhabricatorUser::getOmnipotentUser());
             $flags[] = '--username %P';
             $flags[] = '--password %P';
             $flag_args[] = $key->getUsernameEnvelope();
             $flag_args[] = $key->getPasswordEnvelope();
           }
 
           $flags = implode(' ', $flags);
           $pattern = "svn {$flags} {$pattern}";
           $args = array_mergev(array($flag_args, $args));
         } else {
           $pattern = "svn --non-interactive {$pattern}";
         }
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $pattern = "git {$pattern}";
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         if ($this->shouldUseSSH()) {
           $pattern = "hg --config ui.ssh=%s {$pattern}";
           array_unshift(
             $args,
             $this->getSSHWrapper());
         } else {
           $pattern = "hg {$pattern}";
         }
         break;
       default:
         throw new Exception("Unrecognized version control system.");
     }
 
     array_unshift($args, $pattern);
 
     return $args;
   }
 
   private function formatLocalCommand(array $args) {
     $pattern = $args[0];
     $args = array_slice($args, 1);
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $pattern = "svn --non-interactive {$pattern}";
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $pattern = "git {$pattern}";
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $pattern = "hg {$pattern}";
         break;
       default:
         throw new Exception("Unrecognized version control system.");
     }
 
     array_unshift($args, $pattern);
 
     return $args;
   }
 
   /**
    * Sanitize output of an `hg` command invoked with the `--debug` flag to make
    * it usable.
    *
    * @param string Output from `hg --debug ...`
    * @return string Usable output.
    */
   public static function filterMercurialDebugOutput($stdout) {
     // When hg commands are run with `--debug` and some config file isn't
     // trusted, Mercurial prints out a warning to stdout, twice, after Feb 2011.
     //
     // http://selenic.com/pipermail/mercurial-devel/2011-February/028541.html
 
     $lines = preg_split('/(?<=\n)/', $stdout);
     $regex = '/ignoring untrusted configuration option .*\n$/';
 
     foreach ($lines as $key => $line) {
       $lines[$key] = preg_replace($regex, '', $line);
     }
 
     return implode('', $lines);
   }
 
   public function getURI() {
     return '/diffusion/'.$this->getCallsign().'/';
   }
 
   public function getNormalizedPath() {
     $uri = (string)$this->getCloneURIObject();
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $normalized_uri = new PhabricatorRepositoryURINormalizer(
           PhabricatorRepositoryURINormalizer::TYPE_GIT,
           $uri);
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $normalized_uri = new PhabricatorRepositoryURINormalizer(
           PhabricatorRepositoryURINormalizer::TYPE_SVN,
           $uri);
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $normalized_uri = new PhabricatorRepositoryURINormalizer(
           PhabricatorRepositoryURINormalizer::TYPE_MERCURIAL,
           $uri);
         break;
       default:
         throw new Exception("Unrecognized version control system.");
     }
 
     return $normalized_uri->getNormalizedPath();
   }
 
   public function isTracked() {
     return $this->getDetail('tracking-enabled', false);
   }
 
   public function getDefaultBranch() {
     $default = $this->getDetail('default-branch');
     if (strlen($default)) {
       return $default;
     }
 
     $default_branches = array(
       PhabricatorRepositoryType::REPOSITORY_TYPE_GIT        => 'master',
       PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL  => 'default',
     );
 
     return idx($default_branches, $this->getVersionControlSystem());
   }
 
   public function getDefaultArcanistBranch() {
     return coalesce($this->getDefaultBranch(), 'svn');
   }
 
   private function isBranchInFilter($branch, $filter_key) {
     $vcs = $this->getVersionControlSystem();
 
     $is_git = ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
 
     $use_filter = ($is_git);
 
     if ($use_filter) {
       $filter = $this->getDetail($filter_key, array());
       if ($filter && empty($filter[$branch])) {
         return false;
       }
     }
 
     // By default, all branches pass.
     return true;
   }
 
   public function shouldTrackBranch($branch) {
     return $this->isBranchInFilter($branch, 'branch-filter');
   }
 
   public function shouldAutocloseBranch($branch) {
     if ($this->isImporting()) {
       return false;
     }
 
     if ($this->getDetail('disable-autoclose', false)) {
       return false;
     }
 
     return $this->isBranchInFilter($branch, 'close-commits-filter');
   }
 
   public function shouldAutocloseCommit(
     PhabricatorRepositoryCommit $commit,
     PhabricatorRepositoryCommitData $data) {
 
     if ($this->getDetail('disable-autoclose', false)) {
       return false;
     }
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         return true;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return true;
       default:
         throw new Exception("Unrecognized version control system.");
     }
 
     $closeable_flag = PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE;
     if ($commit->isPartiallyImported($closeable_flag)) {
       return true;
     }
 
     // TODO: Remove this eventually, it's no longer written to by the import
     // pipeline (however, old tasks may still be queued which don't reflect
     // the new data format).
     $branches = $data->getCommitDetail('seenOnBranches', array());
     foreach ($branches as $branch) {
       if ($this->shouldAutocloseBranch($branch)) {
         return true;
       }
     }
 
     return false;
   }
 
   public function formatCommitName($commit_identifier) {
     $vcs = $this->getVersionControlSystem();
 
     $type_git = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
     $type_hg = PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL;
 
     $is_git = ($vcs == $type_git);
     $is_hg = ($vcs == $type_hg);
     if ($is_git || $is_hg) {
       $short_identifier = substr($commit_identifier, 0, 12);
     } else {
       $short_identifier = $commit_identifier;
     }
 
     return 'r'.$this->getCallsign().$short_identifier;
   }
 
   public function isImporting() {
     return (bool)$this->getDetail('importing', false);
   }
 
 
 /* -(  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() {
     $uri = $this->getCloneURIObject();
 
     // Make sure we don't leak anything if this repo is using HTTP Basic Auth
     // with the credentials in the URI or something zany like that.
 
     // If repository is not accessed over SSH we remove both username and
     // password.
     if (!$this->isHosted()) {
       if (!$this->shouldUseSSH()) {
         $uri->setUser(null);
 
         // This might be a Git URI or a normal URI. If it's Git, there's no
         // password support.
         if ($uri instanceof PhutilURI) {
           $uri->setPass(null);
         }
       }
     }
 
     return (string)$uri;
   }
 
 
   /**
    * Get the protocol for the repository's remote.
    *
    * @return string Protocol, like "ssh" or "git".
    * @task uri
    */
   public function getRemoteProtocol() {
     $uri = $this->getRemoteURIObject();
 
     if ($uri instanceof PhutilGitURI) {
       return 'ssh';
     } else {
       return $uri->getProtocol();
     }
   }
 
 
   /**
    * Get a parsed object representation of the repository's remote URI. This
    * may be a normal URI (returned as a @{class@libphutil:PhutilURI}) or a git
    * URI (returned as a @{class@libphutil:PhutilGitURI}).
    *
    * @return wild A @{class@libphutil:PhutilURI} or
    *              @{class@libphutil:PhutilGitURI}.
    * @task uri
    */
   public function getRemoteURIObject() {
     $raw_uri = $this->getDetail('remote-uri');
     if (!$raw_uri) {
       return new PhutilURI('');
     }
 
     if (!strncmp($raw_uri, '/', 1)) {
       return new PhutilURI('file://'.$raw_uri);
     }
 
     $uri = new PhutilURI($raw_uri);
     if ($uri->getProtocol()) {
       return $uri;
     }
 
     $uri = new PhutilGitURI($raw_uri);
     if ($uri->getDomain()) {
       return $uri;
     }
 
     throw new Exception("Remote URI '{$raw_uri}' could not be parsed!");
   }
 
 
   /**
    * Get the "best" clone/checkout URI for this repository, on any protocol.
    */
   public function getCloneURIObject() {
     if (!$this->isHosted()) {
       return $this->getRemoteURIObject();
     }
 
     // Choose the best URI: pick a read/write URI over a URI which is not
     // read/write, and SSH over HTTP.
 
     $serve_ssh = $this->getServeOverSSH();
     $serve_http = $this->getServeOverHTTP();
 
     if ($serve_ssh === self::SERVE_READWRITE) {
       return $this->getSSHCloneURIObject();
     } else if ($serve_http === self::SERVE_READWRITE) {
       return $this->getHTTPCloneURIObject();
     } else if ($serve_ssh !== self::SERVE_OFF) {
       return $this->getSSHCloneURIObject();
     } else if ($serve_http !== self::SERVE_OFF) {
       return $this->getHTTPCloneURIObject();
     } else {
       return null;
     }
   }
 
 
   /**
    * Get the repository's SSH clone/checkout URI, if one exists.
    */
   public function getSSHCloneURIObject() {
     if (!$this->isHosted()) {
       if ($this->shouldUseSSH()) {
         return $this->getRemoteURIObject();
       } else {
         return null;
       }
     }
 
     $serve_ssh = $this->getServeOverSSH();
     if ($serve_ssh === self::SERVE_OFF) {
       return null;
     }
 
     $uri = new PhutilURI(PhabricatorEnv::getProductionURI($this->getURI()));
 
     if ($this->isSVN()) {
       $uri->setProtocol('svn+ssh');
     } else {
       $uri->setProtocol('ssh');
     }
 
     $ssh_user = PhabricatorEnv::getEnvConfig('diffusion.ssh-user');
     if ($ssh_user) {
       $uri->setUser($ssh_user);
     }
 
     $uri->setPort(PhabricatorEnv::getEnvConfig('diffusion.ssh-port'));
 
     return $uri;
   }
 
 
   /**
    * Get the repository's HTTP clone/checkout URI, if one exists.
    */
   public function getHTTPCloneURIObject() {
     if (!$this->isHosted()) {
       if ($this->shouldUseHTTP()) {
         return $this->getRemoteURIObject();
       } else {
         return null;
       }
     }
 
     $serve_http = $this->getServeOverHTTP();
     if ($serve_http === self::SERVE_OFF) {
       return null;
     }
 
 
     $uri = PhabricatorEnv::getProductionURI($this->getURI());
 
     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();
       }
 
       $projects = id(new PhabricatorRepositoryArcanistProject())
         ->loadAllWhere('repositoryID = %d', $this->getID());
       foreach ($projects as $project) {
         // note each project deletes its PhabricatorRepositorySymbols
         $project->delete();
       }
 
       $commits = id(new PhabricatorRepositoryCommit())
         ->loadAllWhere('repositoryID = %d', $this->getID());
       foreach ($commits as $commit) {
         // note PhabricatorRepositoryAuditRequests and
         // PhabricatorRepositoryCommitData are deleted here too.
         $commit->delete();
       }
 
       $mirrors = id(new PhabricatorRepositoryMirror())
         ->loadAllWhere('repositoryPHID = %s', $this->getPHID());
       foreach ($mirrors as $mirror) {
         $mirror->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 getServeOverHTTP() {
     if ($this->isSVN()) {
       return self::SERVE_OFF;
     }
     $serve = $this->getDetail('serve-over-http', self::SERVE_OFF);
     return $this->normalizeServeConfigSetting($serve);
   }
 
   public function setServeOverHTTP($mode) {
     return $this->setDetail('serve-over-http', $mode);
   }
 
   public function getServeOverSSH() {
     $serve = $this->getDetail('serve-over-ssh', self::SERVE_OFF);
     return $this->normalizeServeConfigSetting($serve);
   }
 
   public function setServeOverSSH($mode) {
     return $this->setDetail('serve-over-ssh', $mode);
   }
 
   public static function getProtocolAvailabilityName($constant) {
     switch ($constant) {
       case self::SERVE_OFF:
         return pht('Off');
       case self::SERVE_READONLY:
         return pht('Read Only');
       case self::SERVE_READWRITE:
         return pht('Read/Write');
       default:
         return pht('Unknown');
     }
   }
 
   private function normalizeServeConfigSetting($value) {
     switch ($value) {
       case self::SERVE_OFF:
       case self::SERVE_READONLY:
         return $value;
       case self::SERVE_READWRITE:
         if ($this->isHosted()) {
           return self::SERVE_READWRITE;
         } else {
           return self::SERVE_READONLY;
         }
       default:
         return self::SERVE_OFF;
     }
   }
 
 
   /**
    * 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 canMirror() {
     if ($this->isGit() || $this->isHg()) {
       return true;
     }
 
     return false;
   }
 
   public function canAllowDangerousChanges() {
     if (!$this->isHosted()) {
       return false;
     }
 
     if ($this->isGit() || $this->isHg()) {
       return true;
     }
 
     return false;
   }
 
   public function shouldAllowDangerousChanges() {
     return (bool)$this->getDetail('allow-dangerous-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 {
       queryfx(
         $conn_w,
         'INSERT INTO %T
           (repositoryID, statusType, statusCode, parameters, epoch)
           VALUES (%d, %s, %s, %s, %d)
           ON DUPLICATE KEY UPDATE
             statusCode = VALUES(statusCode),
             parameters = VALUES(parameters),
             epoch = VALUES(epoch)',
         $table_name,
         $this->getID(),
         $status_type,
         $status_code,
         json_encode($parameters),
         time());
     }
 
     return $this;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
       DiffusionCapabilityPush::CAPABILITY,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
       case DiffusionCapabilityPush::CAPABILITY:
         return $this->getPushPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 
 
 /* -(  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;
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepositoryTransaction.php b/src/applications/repository/storage/PhabricatorRepositoryTransaction.php
index 4ad20f8b0a..c29aafde9b 100644
--- a/src/applications/repository/storage/PhabricatorRepositoryTransaction.php
+++ b/src/applications/repository/storage/PhabricatorRepositoryTransaction.php
@@ -1,378 +1,396 @@
 <?php
 
 final class PhabricatorRepositoryTransaction
   extends PhabricatorApplicationTransaction {
 
   const TYPE_VCS = 'repo:vcs';
   const TYPE_ACTIVATE     = 'repo:activate';
   const TYPE_NAME         = 'repo:name';
   const TYPE_DESCRIPTION  = 'repo:description';
   const TYPE_ENCODING     = 'repo:encoding';
   const TYPE_DEFAULT_BRANCH = 'repo:default-branch';
   const TYPE_TRACK_ONLY = 'repo:track-only';
   const TYPE_AUTOCLOSE_ONLY = 'repo:autoclose-only';
   const TYPE_SVN_SUBPATH = 'repo:svn-subpath';
   const TYPE_UUID = 'repo:uuid';
   const TYPE_NOTIFY = 'repo:notify';
   const TYPE_AUTOCLOSE = 'repo:autoclose';
   const TYPE_REMOTE_URI = 'repo:remote-uri';
   const TYPE_LOCAL_PATH = 'repo:local-path';
   const TYPE_HOSTING = 'repo:hosting';
   const TYPE_PROTOCOL_HTTP = 'repo:serve-http';
   const TYPE_PROTOCOL_SSH = 'repo:serve-ssh';
   const TYPE_PUSH_POLICY = 'repo:push-policy';
   const TYPE_CREDENTIAL = 'repo:credential';
   const TYPE_DANGEROUS = 'repo:dangerous';
+  const TYPE_CLONE_NAME = 'repo:clone-name';
 
   // TODO: Clean up these legacy transaction types.
   const TYPE_SSH_LOGIN = 'repo:ssh-login';
   const TYPE_SSH_KEY = 'repo:ssh-key';
   const TYPE_SSH_KEYFILE = 'repo:ssh-keyfile';
   const TYPE_HTTP_LOGIN = 'repo:http-login';
   const TYPE_HTTP_PASS = 'repo:http-pass';
 
   public function getApplicationName() {
     return 'repository';
   }
 
   public function getApplicationTransactionType() {
     return PhabricatorRepositoryPHIDTypeRepository::TYPECONST;
   }
 
   public function getApplicationTransactionCommentObject() {
     return null;
   }
 
   public function getRequiredHandlePHIDs() {
     $phids = parent::getRequiredHandlePHIDs();
 
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     switch ($this->getTransactionType()) {
       case self::TYPE_PUSH_POLICY:
         $phids[] = $old;
         $phids[] = $new;
         break;
     }
 
     return $phids;
   }
 
   public function shouldHide() {
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     switch ($this->getTransactionType()) {
       case self::TYPE_REMOTE_URI:
       case self::TYPE_SSH_LOGIN:
       case self::TYPE_SSH_KEY:
       case self::TYPE_SSH_KEYFILE:
       case self::TYPE_HTTP_LOGIN:
       case self::TYPE_HTTP_PASS:
         // Hide null vs empty string changes.
         return (!strlen($old) && !strlen($new));
       case self::TYPE_LOCAL_PATH:
       case self::TYPE_NAME:
         // Hide these on create, they aren't interesting and we have an
         // explicit "create" transaction.
         if (!strlen($old)) {
           return true;
         }
         break;
     }
 
     return parent::shouldHide();
   }
 
   public function getIcon() {
     switch ($this->getTransactionType()) {
       case self::TYPE_VCS:
         return 'create';
     }
     return parent::getIcon();
   }
 
   public function getColor() {
     switch ($this->getTransactionType()) {
       case self::TYPE_VCS:
         return 'green';
     }
     return parent::getIcon();
   }
 
   public function getTitle() {
     $author_phid = $this->getAuthorPHID();
 
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     switch ($this->getTransactionType()) {
       case self::TYPE_VCS:
         return pht(
           '%s created this repository.',
           $this->renderHandleLink($author_phid));
       case self::TYPE_ACTIVATE:
         if ($new) {
           return pht(
             '%s activated this repository.',
             $this->renderHandleLink($author_phid));
         } else {
           return pht(
             '%s deactivated this repository.',
             $this->renderHandleLink($author_phid));
         }
       case self::TYPE_NAME:
         return pht(
           '%s renamed this repository from "%s" to "%s".',
           $this->renderHandleLink($author_phid),
           $old,
           $new);
       case self::TYPE_DESCRIPTION:
         return pht(
           '%s updated the description of this repository.',
           $this->renderHandleLink($author_phid));
       case self::TYPE_ENCODING:
         if (strlen($old) && !strlen($new)) {
           return pht(
             '%s removed the "%s" encoding configured for this repository.',
             $this->renderHandleLink($author_phid),
             $old);
         } else if (strlen($new) && !strlen($old)) {
           return pht(
             '%s set the encoding for this repository to "%s".',
             $this->renderHandleLink($author_phid),
             $new);
         } else {
           return pht(
             '%s changed the repository encoding from "%s" to "%s".',
             $this->renderHandleLink($author_phid),
             $old,
             $new);
         }
       case self::TYPE_DEFAULT_BRANCH:
         if (!strlen($new)) {
           return pht(
             '%s removed "%s" as the default branch.',
             $this->renderHandleLink($author_phid),
             $old);
         } else if (!strlen($old)) {
           return pht(
             '%s set the default branch to "%s".',
             $this->renderHandleLink($author_phid),
             $new);
         } else {
           return pht(
             '%s changed the default branch from "%s" to "%s".',
             $this->renderHandleLink($author_phid),
             $old,
             $new);
         }
         break;
       case self::TYPE_TRACK_ONLY:
         if (!$new) {
           return pht(
             '%s set this repository to track all branches.',
             $this->renderHandleLink($author_phid));
         } else if (!$old) {
           return pht(
             '%s set this repository to track branches: %s.',
             $this->renderHandleLink($author_phid),
             implode(', ', $new));
         } else {
           return pht(
             '%s changed track branches from "%s" to "%s".',
             $this->renderHandleLink($author_phid),
             implode(', ', $old),
             implode(', ', $new));
         }
         break;
       case self::TYPE_AUTOCLOSE_ONLY:
         if (!$new) {
           return pht(
             '%s set this repository to autoclose on all branches.',
             $this->renderHandleLink($author_phid));
         } else if (!$old) {
           return pht(
             '%s set this repository to autoclose on branches: %s.',
             $this->renderHandleLink($author_phid),
             implode(', ', $new));
         } else {
           return pht(
             '%s changed autoclose branches from "%s" to "%s".',
             $this->renderHandleLink($author_phid),
             implode(', ', $old),
             implode(', ', $new));
         }
         break;
       case self::TYPE_UUID:
         if (!strlen($new)) {
           return pht(
             '%s removed "%s" as the repository UUID.',
             $this->renderHandleLink($author_phid),
             $old);
         } else if (!strlen($old)) {
           return pht(
             '%s set the repository UUID to "%s".',
             $this->renderHandleLink($author_phid),
             $new);
         } else {
           return pht(
             '%s changed the repository UUID from "%s" to "%s".',
             $this->renderHandleLink($author_phid),
             $old,
             $new);
         }
         break;
       case self::TYPE_SVN_SUBPATH:
         if (!strlen($new)) {
           return pht(
             '%s removed "%s" as the Import Only path.',
             $this->renderHandleLink($author_phid),
             $old);
         } else if (!strlen($old)) {
           return pht(
             '%s set the repository to import only "%s".',
             $this->renderHandleLink($author_phid),
             $new);
         } else {
           return pht(
             '%s changed the import path from "%s" to "%s".',
             $this->renderHandleLink($author_phid),
             $old,
             $new);
         }
         break;
       case self::TYPE_NOTIFY:
         if ($new) {
           return pht(
             '%s enabled notifications and publishing for this repository.',
             $this->renderHandleLink($author_phid));
         } else {
           return pht(
             '%s disabled notifications and publishing for this repository.',
             $this->renderHandleLink($author_phid));
         }
         break;
       case self::TYPE_AUTOCLOSE:
         if ($new) {
           return pht(
             '%s enabled autoclose for this repository.',
             $this->renderHandleLink($author_phid));
         } else {
           return pht(
             '%s disabled autoclose for this repository.',
             $this->renderHandleLink($author_phid));
         }
         break;
       case self::TYPE_REMOTE_URI:
         if (!strlen($old)) {
           return pht(
             '%s set the remote URI for this repository to "%s".',
             $this->renderHandleLink($author_phid),
             $new);
         } else if (!strlen($new)) {
           return pht(
             '%s removed the remote URI for this repository.',
             $this->renderHandleLink($author_phid));
         } else {
           return pht(
             '%s changed the remote URI for this repository from "%s" to "%s".',
             $this->renderHandleLink($author_phid),
             $old,
             $new);
         }
         break;
       case self::TYPE_SSH_LOGIN:
         return pht(
           '%s updated the SSH login for this repository.',
           $this->renderHandleLink($author_phid));
       case self::TYPE_SSH_KEY:
         return pht(
           '%s updated the SSH key for this repository.',
           $this->renderHandleLink($author_phid));
       case self::TYPE_SSH_KEYFILE:
         return pht(
           '%s updated the SSH keyfile for this repository.',
           $this->renderHandleLink($author_phid));
       case self::TYPE_HTTP_LOGIN:
         return pht(
           '%s updated the HTTP login for this repository.',
           $this->renderHandleLink($author_phid));
       case self::TYPE_HTTP_PASS:
         return pht(
           '%s updated the HTTP password for this repository.',
           $this->renderHandleLink($author_phid));
       case self::TYPE_LOCAL_PATH:
         return pht(
           '%s changed the local path from "%s" to "%s".',
           $this->renderHandleLink($author_phid),
           $old,
           $new);
       case self::TYPE_HOSTING:
         if ($new) {
           return pht(
             '%s changed this repository to be hosted on Phabricator.',
             $this->renderHandleLink($author_phid));
         } else {
           return pht(
             '%s changed this repository to track a remote elsewhere.',
             $this->renderHandleLink($author_phid));
         }
       case self::TYPE_PROTOCOL_HTTP:
         return pht(
           '%s changed the availability of this repository over HTTP from '.
           '"%s" to "%s".',
           $this->renderHandleLink($author_phid),
           PhabricatorRepository::getProtocolAvailabilityName($old),
           PhabricatorRepository::getProtocolAvailabilityName($new));
       case self::TYPE_PROTOCOL_SSH:
         return pht(
           '%s changed the availability of this repository over SSH from '.
           '"%s" to "%s".',
           $this->renderHandleLink($author_phid),
           PhabricatorRepository::getProtocolAvailabilityName($old),
           PhabricatorRepository::getProtocolAvailabilityName($new));
       case self::TYPE_PUSH_POLICY:
         return pht(
           '%s changed the push policy of this repository from "%s" to "%s".',
           $this->renderHandleLink($author_phid),
           $this->renderPolicyName($old),
           $this->renderPolicyName($new));
       case self::TYPE_DANGEROUS:
         if ($new) {
           return pht(
             '%s disabled protection against dangerous changes.',
             $this->renderHandleLink($author_phid));
         } else {
           return pht(
             '%s enabled protection against dangerous changes.',
             $this->renderHandleLink($author_phid));
         }
+      case self::TYPE_CLONE_NAME:
+        if (strlen($old) && !strlen($new)) {
+          return pht(
+            '%s removed the clone name of this repository.',
+            $this->renderHandleLink($author_phid));
+        } else if (strlen($new) && !strlen($old)) {
+          return pht(
+            '%s set the clone name of this repository to "%s".',
+            $this->renderHandleLink($author_phid),
+            $new);
+        } else {
+          return pht(
+            '%s changed the clone name of this repository from "%s" to "%s".',
+            $this->renderHandleLink($author_phid),
+            $old,
+            $new);
+        }
     }
 
     return parent::getTitle();
   }
 
   public function hasChangeDetails() {
     switch ($this->getTransactionType()) {
       case self::TYPE_DESCRIPTION:
         return true;
     }
     return parent::hasChangeDetails();
   }
 
   public function renderChangeDetails(PhabricatorUser $viewer) {
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     $view = id(new PhabricatorApplicationTransactionTextDiffDetailView())
       ->setUser($viewer)
       ->setOldText($old)
       ->setNewText($new);
 
     return $view->render();
   }
 
 }
 
diff --git a/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php b/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
index 9046988de1..8a864443b0 100644
--- a/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
+++ b/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
@@ -1,1695 +1,1696 @@
 <?php
 
 /**
  * @task mail   Sending Mail
  * @task feed   Publishing Feed Stories
  * @task search Search Index
  * @task files  Integration with Files
  */
 abstract class PhabricatorApplicationTransactionEditor
   extends PhabricatorEditor {
 
   private $contentSource;
   private $object;
   private $xactions;
 
   private $isNewObject;
   private $mentionedPHIDs;
   private $continueOnNoEffect;
   private $continueOnMissingFields;
   private $parentMessageID;
   private $heraldAdapter;
   private $heraldTranscript;
   private $subscribers;
 
   private $isPreview;
 
   /**
    * When the editor tries to apply transactions that have no effect, should
    * it raise an exception (default) or drop them and continue?
    *
    * Generally, you will set this flag for edits coming from "Edit" interfaces,
    * and leave it cleared for edits coming from "Comment" interfaces, so the
    * user will get a useful error if they try to submit a comment that does
    * nothing (e.g., empty comment with a status change that has already been
    * performed by another user).
    *
    * @param bool  True to drop transactions without effect and continue.
    * @return this
    */
   public function setContinueOnNoEffect($continue) {
     $this->continueOnNoEffect = $continue;
     return $this;
   }
 
   public function getContinueOnNoEffect() {
     return $this->continueOnNoEffect;
   }
 
 
   /**
    * When the editor tries to apply transactions which don't populate all of
    * an object's required fields, should it raise an exception (default) or
    * drop them and continue?
    *
    * For example, if a user adds a new required custom field (like "Severity")
    * to a task, all existing tasks won't have it populated. When users
    * manually edit existing tasks, it's usually desirable to have them provide
    * a severity. However, other operations (like batch editing just the
    * owner of a task) will fail by default.
    *
    * By setting this flag for edit operations which apply to specific fields
    * (like the priority, batch, and merge editors in Maniphest), these
    * operations can continue to function even if an object is outdated.
    *
    * @param bool  True to continue when transactions don't completely satisfy
    *              all required fields.
    * @return this
    */
   public function setContinueOnMissingFields($continue_on_missing_fields) {
     $this->continueOnMissingFields = $continue_on_missing_fields;
     return $this;
   }
 
   public function getContinueOnMissingFields() {
     return $this->continueOnMissingFields;
   }
 
 
   /**
    * Not strictly necessary, but reply handlers ideally set this value to
    * make email threading work better.
    */
   public function setParentMessageID($parent_message_id) {
     $this->parentMessageID = $parent_message_id;
     return $this;
   }
   public function getParentMessageID() {
     return $this->parentMessageID;
   }
 
   protected function getIsNewObject() {
     return $this->isNewObject;
   }
 
   protected function getMentionedPHIDs() {
     return $this->mentionedPHIDs;
   }
 
   public function setIsPreview($is_preview) {
     $this->isPreview = $is_preview;
     return $this;
   }
 
   public function getIsPreview() {
     return $this->isPreview;
   }
 
   public function getTransactionTypes() {
     $types = array();
 
     if ($this->object instanceof PhabricatorSubscribableInterface) {
       $types[] = PhabricatorTransactions::TYPE_SUBSCRIBERS;
     }
 
     if ($this->object instanceof PhabricatorCustomFieldInterface) {
       $types[] = PhabricatorTransactions::TYPE_CUSTOMFIELD;
     }
 
     return $types;
   }
 
   private function adjustTransactionValues(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     $old = $this->getTransactionOldValue($object, $xaction);
     $xaction->setOldValue($old);
 
     $new = $this->getTransactionNewValue($object, $xaction);
     $xaction->setNewValue($new);
   }
 
   private function getTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         return array_values($this->subscribers);
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
         return $object->getViewPolicy();
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         return $object->getEditPolicy();
       case PhabricatorTransactions::TYPE_EDGE:
         $edge_type = $xaction->getMetadataValue('edge:type');
         if (!$edge_type) {
           throw new Exception("Edge transaction has no 'edge:type'!");
         }
 
         $old_edges = array();
         if ($object->getPHID()) {
           $edge_src = $object->getPHID();
 
           $old_edges = id(new PhabricatorEdgeQuery())
             ->withSourcePHIDs(array($edge_src))
             ->withEdgeTypes(array($edge_type))
             ->needEdgeData(true)
             ->execute();
 
           $old_edges = $old_edges[$edge_src][$edge_type];
         }
         return $old_edges;
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         // NOTE: Custom fields have their old value pre-populated when they are
         // built by PhabricatorCustomFieldList.
         return $xaction->getOldValue();
       default:
         return $this->getCustomTransactionOldValue($object, $xaction);
     }
   }
 
   private function getTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         return $this->getPHIDTransactionNewValue($xaction);
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         return $xaction->getNewValue();
       case PhabricatorTransactions::TYPE_EDGE:
         return $this->getEdgeTransactionNewValue($xaction);
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getCustomFieldForTransaction($object, $xaction);
         return $field->getNewValueFromApplicationTransactions($xaction);
       default:
         return $this->getCustomTransactionNewValue($object, $xaction);
     }
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     throw new Exception("Capability not supported!");
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     throw new Exception("Capability not supported!");
   }
 
   protected function transactionHasEffect(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         return $xaction->hasComment();
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getCustomFieldForTransaction($object, $xaction);
         return $field->getApplicationTransactionHasEffect($xaction);
     }
 
     return ($xaction->getOldValue() !== $xaction->getNewValue());
   }
 
   protected function shouldApplyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return false;
   }
 
   protected function applyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
     throw new Exception('Not implemented.');
   }
 
   private function applyInternalEffects(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
+
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
         $object->setViewPolicy($xaction->getNewValue());
         break;
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         $object->setEditPolicy($xaction->getNewValue());
         break;
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getCustomFieldForTransaction($object, $xaction);
         return $field->applyApplicationTransactionInternalEffects($xaction);
     }
     return $this->applyCustomInternalTransaction($object, $xaction);
   }
 
   private function applyExternalEffects(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         $subeditor = id(new PhabricatorSubscriptionsEditor())
           ->setObject($object)
           ->setActor($this->requireActor());
 
         $old_map = array_fuse($xaction->getOldValue());
         $new_map = array_fuse($xaction->getNewValue());
 
         $subeditor->unsubscribe(
           array_keys(
             array_diff_key($old_map, $new_map)));
 
         $subeditor->subscribeExplicit(
           array_keys(
             array_diff_key($new_map, $old_map)));
 
         $subeditor->save();
 
         // for the rest of these edits, subscribers should include those just
         // added as well as those just removed.
         $subscribers = array_unique(array_merge(
           $this->subscribers,
           $xaction->getOldValue(),
           $xaction->getNewValue()));
         $this->subscribers = $subscribers;
 
         break;
       case PhabricatorTransactions::TYPE_EDGE:
         $old = $xaction->getOldValue();
         $new = $xaction->getNewValue();
         $src = $object->getPHID();
         $type = $xaction->getMetadataValue('edge:type');
 
         foreach ($new as $dst_phid => $edge) {
           $new[$dst_phid]['src'] = $src;
         }
 
         $editor = id(new PhabricatorEdgeEditor())
           ->setActor($this->getActor());
 
         foreach ($old as $dst_phid => $edge) {
           if (!empty($new[$dst_phid])) {
             if ($old[$dst_phid]['data'] === $new[$dst_phid]['data']) {
               continue;
             }
           }
           $editor->removeEdge($src, $type, $dst_phid);
         }
 
         foreach ($new as $dst_phid => $edge) {
           if (!empty($old[$dst_phid])) {
             if ($old[$dst_phid]['data'] === $new[$dst_phid]['data']) {
               continue;
             }
           }
 
           $data = array(
             'data' => $edge['data'],
           );
 
           $editor->addEdge($src, $type, $dst_phid, $data);
         }
 
         $editor->save();
         break;
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getCustomFieldForTransaction($object, $xaction);
         return $field->applyApplicationTransactionExternalEffects($xaction);
     }
 
     return $this->applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     $type = $xaction->getTransactionType();
     throw new Exception(
       "Transaction type '{$type}' is missing an internal apply ".
       "implementation!");
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     $type = $xaction->getTransactionType();
     throw new Exception(
       "Transaction type '{$type}' is missing an external apply ".
       "implementation!");
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
   }
 
   public function setContentSource(PhabricatorContentSource $content_source) {
     $this->contentSource = $content_source;
     return $this;
   }
 
   public function setContentSourceFromRequest(AphrontRequest $request) {
     return $this->setContentSource(
       PhabricatorContentSource::newFromRequest($request));
   }
 
   public function getContentSource() {
     return $this->contentSource;
   }
 
   final public function applyTransactions(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $this->object = $object;
     $this->xactions = $xactions;
     $this->isNewObject = ($object->getPHID() === null);
 
     $this->validateEditParameters($object, $xactions);
 
     $actor = $this->requireActor();
 
     $this->loadSubscribers($object);
 
     $xactions = $this->applyImplicitCC($object, $xactions);
 
     $mention_xaction = $this->buildMentionTransaction($object, $xactions);
     if ($mention_xaction) {
       $xactions[] = $mention_xaction;
     }
 
     $xactions = $this->combineTransactions($xactions);
 
     foreach ($xactions as $xaction) {
       // TODO: This needs to be more sophisticated once we have meta-policies.
       $xaction->setViewPolicy(PhabricatorPolicies::POLICY_PUBLIC);
       $xaction->setEditPolicy($actor->getPHID());
 
       $xaction->setAuthorPHID($actor->getPHID());
       $xaction->setContentSource($this->getContentSource());
       $xaction->attachViewer($this->getActor());
     }
 
     $is_preview = $this->getIsPreview();
     $read_locking = false;
     $transaction_open = false;
 
     if (!$is_preview) {
       $errors = array();
       $type_map = mgroup($xactions, 'getTransactionType');
       foreach ($this->getTransactionTypes() as $type) {
         $type_xactions = idx($type_map, $type, array());
         $errors[] = $this->validateTransaction($object, $type, $type_xactions);
       }
 
       $errors = array_mergev($errors);
 
       $continue_on_missing = $this->getContinueOnMissingFields();
       foreach ($errors as $key => $error) {
         if ($continue_on_missing && $error->getIsMissingFieldError()) {
           unset($errors[$key]);
         }
       }
 
       if ($errors) {
         throw new PhabricatorApplicationTransactionValidationException($errors);
       }
 
       $file_phids = $this->extractFilePHIDs($object, $xactions);
 
       if ($object->getID()) {
         foreach ($xactions as $xaction) {
 
           // If any of the transactions require a read lock, hold one and
           // reload the object. We need to do this fairly early so that the
           // call to `adjustTransactionValues()` (which populates old values)
           // is based on the synchronized state of the object, which may differ
           // from the state when it was originally loaded.
 
           if ($this->shouldReadLock($object, $xaction)) {
             $object->openTransaction();
             $object->beginReadLocking();
             $transaction_open = true;
             $read_locking = true;
             $object->reload();
             break;
           }
         }
       }
 
       if ($this->shouldApplyInitialEffects($object, $xactions)) {
         if (!$transaction_open) {
           $object->openTransaction();
           $transaction_open = true;
         }
       }
     }
 
     if ($this->shouldApplyInitialEffects($object, $xactions)) {
       $this->applyInitialEffects($object, $xactions);
     }
 
     foreach ($xactions as $xaction) {
       $this->adjustTransactionValues($object, $xaction);
     }
 
     $xactions = $this->filterTransactions($object, $xactions);
 
     if (!$xactions) {
       if ($read_locking) {
         $object->endReadLocking();
         $read_locking = false;
       }
       if ($transaction_open) {
         $object->killTransaction();
         $transaction_open = false;
       }
       return array();
     }
 
     // Now that we've merged, filtered, and combined transactions, check for
     // required capabilities.
     foreach ($xactions as $xaction) {
       $this->requireCapabilities($object, $xaction);
     }
 
     $xactions = $this->sortTransactions($xactions);
 
     if ($is_preview) {
       $this->loadHandles($xactions);
       return $xactions;
     }
 
     $comment_editor = id(new PhabricatorApplicationTransactionCommentEditor())
       ->setActor($actor)
       ->setContentSource($this->getContentSource());
 
     if (!$transaction_open) {
       $object->openTransaction();
     }
 
       foreach ($xactions as $xaction) {
         $this->applyInternalEffects($object, $xaction);
       }
 
       $object->save();
 
       foreach ($xactions as $xaction) {
         $xaction->setObjectPHID($object->getPHID());
         if ($xaction->getComment()) {
           $xaction->setPHID($xaction->generatePHID());
           $comment_editor->applyEdit($xaction, $xaction->getComment());
         } else {
           $xaction->save();
         }
       }
 
       if ($file_phids) {
         $this->attachFiles($object, $file_phids);
       }
 
       foreach ($xactions as $xaction) {
         $this->applyExternalEffects($object, $xaction);
       }
 
       if ($this->supportsHerald()) {
         $this->applyHeraldRules($object, $xactions);
       }
 
       $this->applyFinalEffects($object, $xactions);
 
       if ($read_locking) {
         $object->endReadLocking();
         $read_locking = false;
       }
 
     $object->saveTransaction();
 
     $this->loadHandles($xactions);
 
     $mail = null;
     if ($this->shouldSendMail($object, $xactions)) {
       $mail = $this->sendMail($object, $xactions);
     }
 
     if ($this->supportsSearch()) {
       id(new PhabricatorSearchIndexer())
         ->queueDocumentForIndexing($object->getPHID());
     }
 
     if ($this->supportsFeed()) {
       $mailed = array();
       if ($mail) {
         $mailed = $mail->buildRecipientList();
       }
       $this->publishFeedStory(
         $object,
         $xactions,
         $mailed);
     }
 
     $this->didApplyTransactions($xactions);
 
     if ($object instanceof PhabricatorCustomFieldInterface) {
       // Maybe this makes more sense to move into the search index itself? For
       // now I'm putting it here since I think we might end up with things that
       // need it to be up to date once the next page loads, but if we don't go
       // there we we could move it into search once search moves to the daemons.
 
       $fields = PhabricatorCustomField::getObjectFields(
         $object,
         PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
       $fields->readFieldsFromStorage($object);
       $fields->rebuildIndexes($object);
     }
 
     return $xactions;
   }
 
   protected function didApplyTransactions(array $xactions) {
     // Hook for subclasses.
     return;
   }
 
 
   /**
    * Determine if the editor should hold a read lock on the object while
    * applying a transaction.
    *
    * If the editor does not hold a lock, two editors may read an object at the
    * same time, then apply their changes without any synchronization. For most
    * transactions, this does not matter much. However, it is important for some
    * transactions. For example, if an object has a transaction count on it, both
    * editors may read the object with `count = 23`, then independently update it
    * and save the object with `count = 24` twice. This will produce the wrong
    * state: the object really has 25 transactions, but the count is only 24.
    *
    * Generally, transactions fall into one of four buckets:
    *
    *   - Append operations: Actions like adding a comment to an object purely
    *     add information to its state, and do not depend on the current object
    *     state in any way. These transactions never need to hold locks.
    *   - Overwrite operations: Actions like changing the title or description
    *     of an object replace the current value with a new value, so the end
    *     state is consistent without a lock. We currently do not lock these
    *     transactions, although we may in the future.
    *   - Edge operations: Edge and subscription operations have internal
    *     synchronization which limits the damage race conditions can cause.
    *     We do not currently lock these transactions, although we may in the
    *     future.
    *   - Update operations: Actions like incrementing a count on an object.
    *     These operations generally should use locks, unless it is not
    *     important that the state remain consistent in the presence of races.
    *
    * @param   PhabricatorLiskDAO  Object being updated.
    * @param   PhabricatorApplicationTransaction Transaction being applied.
    * @return  bool                True to synchronize the edit with a lock.
    */
   protected function shouldReadLock(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     return false;
   }
 
   private function loadHandles(array $xactions) {
     $phids = array();
     foreach ($xactions as $key => $xaction) {
       $phids[$key] = $xaction->getRequiredHandlePHIDs();
     }
     $handles = array();
     $merged = array_mergev($phids);
     if ($merged) {
       $handles = id(new PhabricatorHandleQuery())
         ->setViewer($this->requireActor())
         ->withPHIDs($merged)
         ->execute();
     }
     foreach ($xactions as $key => $xaction) {
       $xaction->setHandles(array_select_keys($handles, $phids[$key]));
     }
   }
 
   private function loadSubscribers(PhabricatorLiskDAO $object) {
     if ($object->getPHID() &&
         ($object instanceof PhabricatorSubscribableInterface)) {
       $subs = PhabricatorSubscribersQuery::loadSubscribersForPHID(
         $object->getPHID());
       $this->subscribers = array_fuse($subs);
     } else {
       $this->subscribers = array();
     }
   }
 
   private function validateEditParameters(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     if (!$this->getContentSource()) {
       throw new Exception(
         "Call setContentSource() before applyTransactions()!");
     }
 
     // Do a bunch of sanity checks that the incoming transactions are fresh.
     // They should be unsaved and have only "transactionType" and "newValue"
     // set.
 
     $types = array_fill_keys($this->getTransactionTypes(), true);
 
     assert_instances_of($xactions, 'PhabricatorApplicationTransaction');
     foreach ($xactions as $xaction) {
       if ($xaction->getPHID() || $xaction->getID()) {
         throw new Exception(
           "You can not apply transactions which already have IDs/PHIDs!");
       }
       if ($xaction->getObjectPHID()) {
         throw new Exception(
           "You can not apply transactions which already have objectPHIDs!");
       }
       if ($xaction->getAuthorPHID()) {
         throw new Exception(
           "You can not apply transactions which already have authorPHIDs!");
       }
       if ($xaction->getCommentPHID()) {
         throw new Exception(
           "You can not apply transactions which already have commentPHIDs!");
       }
       if ($xaction->getCommentVersion() !== 0) {
         throw new Exception(
           "You can not apply transactions which already have commentVersions!");
       }
 
       $exempt_types = array(
         // CustomField logic currently prefills these before we enter the
         // transaction editor.
         PhabricatorTransactions::TYPE_CUSTOMFIELD => true,
 
         // TODO: Remove this, this edge type is encumbered with a bunch of
         // legacy nonsense.
         ManiphestTransaction::TYPE_EDGE => true,
       );
 
       if (empty($exempt_types[$xaction->getTransactionType()])) {
         if ($xaction->getOldValue() !== null) {
           throw new Exception(
             "You can not apply transactions which already have oldValue!");
         }
       }
 
       $type = $xaction->getTransactionType();
       if (empty($types[$type])) {
         throw new Exception("Transaction has unknown type '{$type}'.");
       }
     }
 
     // The actor must have permission to view and edit the object.
 
     $actor = $this->requireActor();
 
     PhabricatorPolicyFilter::requireCapability(
       $actor,
       $object,
       PhabricatorPolicyCapability::CAN_VIEW);
   }
 
   protected function requireCapabilities(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         // You must have the edit capability to alter the edit policy of an
         // object. For other default transaction types, we don't enforce
         // anything for the moment.
 
         PhabricatorPolicyFilter::requireCapability(
           $this->requireActor(),
           $object,
           PhabricatorPolicyCapability::CAN_EDIT);
         break;
     }
   }
 
   private function buildMentionTransaction(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     if (!($object instanceof PhabricatorSubscribableInterface)) {
       return null;
     }
 
     $texts = array();
     foreach ($xactions as $xaction) {
       $texts[] = $this->getRemarkupBlocksFromTransaction($xaction);
     }
     $texts = array_mergev($texts);
 
     $phids = PhabricatorMarkupEngine::extractPHIDsFromMentions($texts);
 
     $this->mentionedPHIDs = $phids;
 
     if ($object->getPHID()) {
       // Don't try to subscribe already-subscribed mentions: we want to generate
       // a dialog about an action having no effect if the user explicitly adds
       // existing CCs, but not if they merely mention existing subscribers.
       $phids = array_diff($phids, $this->subscribers);
     }
 
     foreach ($phids as $key => $phid) {
       if ($object->isAutomaticallySubscribed($phid)) {
         unset($phids[$key]);
       }
     }
     $phids = array_values($phids);
 
     if (!$phids) {
       return null;
     }
 
     $xaction = newv(get_class(head($xactions)), array());
     $xaction->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
     $xaction->setNewValue(array('+' => $phids));
 
     return $xaction;
   }
 
   protected function getRemarkupBlocksFromTransaction(
     PhabricatorApplicationTransaction $transaction) {
     $texts = array();
     if ($transaction->getComment()) {
       $texts[] = $transaction->getComment()->getContent();
     }
     return $texts;
   }
 
   protected function mergeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $type = $u->getTransactionType();
 
     switch ($type) {
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         return $this->mergePHIDOrEdgeTransactions($u, $v);
       case PhabricatorTransactions::TYPE_EDGE:
         $u_type = $u->getMetadataValue('edge:type');
         $v_type = $v->getMetadataValue('edge:type');
         if ($u_type == $v_type) {
           return $this->mergePHIDOrEdgeTransactions($u, $v);
         }
         return null;
     }
 
     // By default, do not merge the transactions.
     return null;
   }
 
 
   /**
    * Attempt to combine similar transactions into a smaller number of total
    * transactions. For example, two transactions which edit the title of an
    * object can be merged into a single edit.
    */
   private function combineTransactions(array $xactions) {
     $stray_comments = array();
 
     $result = array();
     $types = array();
     foreach ($xactions as $key => $xaction) {
       $type = $xaction->getTransactionType();
       if (isset($types[$type])) {
         foreach ($types[$type] as $other_key) {
           $merged = $this->mergeTransactions($result[$other_key], $xaction);
           if ($merged) {
             $result[$other_key] = $merged;
 
             if ($xaction->getComment() &&
                 ($xaction->getComment() !== $merged->getComment())) {
               $stray_comments[] = $xaction->getComment();
             }
 
             if ($result[$other_key]->getComment() &&
                 ($result[$other_key]->getComment() !== $merged->getComment())) {
               $stray_comments[] = $result[$other_key]->getComment();
             }
 
             // Move on to the next transaction.
             continue 2;
           }
         }
       }
       $result[$key] = $xaction;
       $types[$type][] = $key;
     }
 
     // If we merged any comments away, restore them.
     foreach ($stray_comments as $comment) {
       $xaction = newv(get_class(head($result)), array());
       $xaction->setTransactionType(PhabricatorTransactions::TYPE_COMMENT);
       $xaction->setComment($comment);
       $result[] = $xaction;
     }
 
     return array_values($result);
   }
 
   protected function mergePHIDOrEdgeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $result = $u->getNewValue();
     foreach ($v->getNewValue() as $key => $value) {
       $result[$key] = array_merge($value, idx($result, $key, array()));
     }
     $u->setNewValue($result);
 
     return $u;
   }
 
   protected function getPHIDTransactionNewValue(
     PhabricatorApplicationTransaction $xaction) {
 
     $old = array_fuse($xaction->getOldValue());
 
     $new = $xaction->getNewValue();
     $new_add = idx($new, '+', array());
     unset($new['+']);
     $new_rem = idx($new, '-', array());
     unset($new['-']);
     $new_set = idx($new, '=', null);
     if ($new_set !== null) {
       $new_set = array_fuse($new_set);
     }
     unset($new['=']);
 
     if ($new) {
       throw new Exception(
         "Invalid 'new' value for PHID transaction. Value should contain only ".
         "keys '+' (add PHIDs), '-' (remove PHIDs) and '=' (set PHIDS).");
     }
 
     $result = array();
 
     foreach ($old as $phid) {
       if ($new_set !== null && empty($new_set[$phid])) {
         continue;
       }
       $result[$phid] = $phid;
     }
 
     if ($new_set !== null) {
       foreach ($new_set as $phid) {
         $result[$phid] = $phid;
       }
     }
 
     foreach ($new_add as $phid) {
       $result[$phid] = $phid;
     }
 
     foreach ($new_rem as $phid) {
       unset($result[$phid]);
     }
 
     return array_values($result);
   }
 
   protected function getEdgeTransactionNewValue(
     PhabricatorApplicationTransaction $xaction) {
 
     $new = $xaction->getNewValue();
     $new_add = idx($new, '+', array());
     unset($new['+']);
     $new_rem = idx($new, '-', array());
     unset($new['-']);
     $new_set = idx($new, '=', null);
     unset($new['=']);
 
     if ($new) {
       throw new Exception(
         "Invalid 'new' value for Edge transaction. Value should contain only ".
         "keys '+' (add edges), '-' (remove edges) and '=' (set edges).");
     }
 
     $old = $xaction->getOldValue();
 
     $lists = array($new_set, $new_add, $new_rem);
     foreach ($lists as $list) {
       $this->checkEdgeList($list);
     }
 
     $result = array();
     foreach ($old as $dst_phid => $edge) {
       if ($new_set !== null && empty($new_set[$dst_phid])) {
         continue;
       }
       $result[$dst_phid] = $this->normalizeEdgeTransactionValue(
         $xaction,
         $edge);
     }
 
     if ($new_set !== null) {
       foreach ($new_set as $dst_phid => $edge) {
         $result[$dst_phid] = $this->normalizeEdgeTransactionValue(
           $xaction,
           $edge);
       }
     }
 
     foreach ($new_add as $dst_phid => $edge) {
       $result[$dst_phid] = $this->normalizeEdgeTransactionValue(
         $xaction,
         $edge);
     }
 
     foreach ($new_rem as $dst_phid => $edge) {
       unset($result[$dst_phid]);
     }
 
     return $result;
   }
 
   private function checkEdgeList($list) {
     if (!$list) {
       return;
     }
     foreach ($list as $key => $item) {
       if (phid_get_type($key) === PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
         throw new Exception(
           "Edge transactions must have destination PHIDs as in edge ".
           "lists (found key '{$key}').");
       }
       if (!is_array($item) && $item !== $key) {
         throw new Exception(
           "Edge transactions must have PHIDs or edge specs as values ".
           "(found value '{$item}').");
       }
     }
   }
 
   protected function normalizeEdgeTransactionValue(
     PhabricatorApplicationTransaction $xaction,
     $edge) {
 
     if (!is_array($edge)) {
       $edge = array(
         'dst' => $edge,
       );
     }
 
     $edge_type = $xaction->getMetadataValue('edge:type');
 
     if (empty($edge['type'])) {
       $edge['type'] = $edge_type;
     } else {
       if ($edge['type'] != $edge_type) {
         $this_type = $edge['type'];
         throw new Exception(
           "Edge transaction includes edge of type '{$this_type}', but ".
           "transaction is of type '{$edge_type}'. Each edge transaction must ".
           "alter edges of only one type.");
       }
     }
 
     if (!isset($edge['data'])) {
       $edge['data'] = null;
     }
 
     return $edge;
   }
 
   protected function sortTransactions(array $xactions) {
     $head = array();
     $tail = array();
 
     // Move bare comments to the end, so the actions precede them.
     foreach ($xactions as $xaction) {
       $type = $xaction->getTransactionType();
       if ($type == PhabricatorTransactions::TYPE_COMMENT) {
         $tail[] = $xaction;
       } else {
         $head[] = $xaction;
       }
     }
 
     return array_values(array_merge($head, $tail));
   }
 
 
   protected function filterTransactions(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $type_comment = PhabricatorTransactions::TYPE_COMMENT;
 
     $no_effect = array();
     $has_comment = false;
     $any_effect = false;
     foreach ($xactions as $key => $xaction) {
       if ($this->transactionHasEffect($object, $xaction)) {
         if ($xaction->getTransactionType() != $type_comment) {
           $any_effect = true;
         }
       } else {
         $no_effect[$key] = $xaction;
       }
       if ($xaction->hasComment()) {
         $has_comment = true;
       }
     }
 
     if (!$no_effect) {
       return $xactions;
     }
 
     if (!$this->getContinueOnNoEffect() && !$this->getIsPreview()) {
       throw new PhabricatorApplicationTransactionNoEffectException(
         $no_effect,
         $any_effect,
         $has_comment);
     }
 
     if (!$any_effect && !$has_comment) {
       // If we only have empty comment transactions, just drop them all.
       return array();
     }
 
     foreach ($no_effect as $key => $xaction) {
       if ($xaction->getComment()) {
         $xaction->setTransactionType($type_comment);
         $xaction->setOldValue(null);
         $xaction->setNewValue(null);
       } else {
         unset($xactions[$key]);
       }
     }
 
     return $xactions;
   }
 
 
   /**
    * Hook for validating transactions. This callback will be invoked for each
    * available transaction type, even if an edit does not apply any transactions
    * of that type. This allows you to raise exceptions when required fields are
    * missing, by detecting that the object has no field value and there is no
    * transaction which sets one.
    *
    * @param PhabricatorLiskDAO Object being edited.
    * @param string Transaction type to validate.
    * @param list<PhabricatorApplicationTransaction> Transactions of given type,
    *   which may be empty if the edit does not apply any transactions of the
    *   given type.
    * @return list<PhabricatorApplicationTransactionValidationError> List of
    *   validation errors.
    */
   protected function validateTransaction(
     PhabricatorLiskDAO $object,
     $type,
     array $xactions) {
 
     $errors = array();
     switch ($type) {
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $groups = array();
         foreach ($xactions as $xaction) {
           $groups[$xaction->getMetadataValue('customfield:key')][] = $xaction;
         }
 
         $field_list = PhabricatorCustomField::getObjectFields(
           $object,
           PhabricatorCustomField::ROLE_EDIT);
 
         $role_xactions = PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS;
         foreach ($field_list->getFields() as $field) {
           if (!$field->shouldEnableForRole($role_xactions)) {
             continue;
           }
           $errors[] = $field->validateApplicationTransactions(
             $this,
             $type,
             idx($groups, $field->getFieldKey(), array()));
         }
         break;
     }
 
     return array_mergev($errors);
   }
 
 
   /**
    * Check for a missing text field.
    *
    * A text field is missing if the object has no value and there are no
    * transactions which set a value, or if the transactions remove the value.
    * This method is intended to make implementing @{method:validateTransaction}
    * more convenient:
    *
    *   $missing = $this->validateIsEmptyTextField(
    *     $object->getName(),
    *     $xactions);
    *
    * This will return `true` if the net effect of the object and transactions
    * is an empty field.
    *
    * @param wild Current field value.
    * @param list<PhabricatorApplicationTransaction> Transactions editing the
    *          field.
    * @return bool True if the field will be an empty text field after edits.
    */
   protected function validateIsEmptyTextField($field_value, array $xactions) {
     if (strlen($field_value) && empty($xactions)) {
       return false;
     }
 
     if ($xactions && strlen(last($xactions)->getNewValue())) {
       return false;
     }
 
     return true;
   }
 
 
 /* -(  Implicit CCs  )------------------------------------------------------- */
 
 
   /**
    * When a user interacts with an object, we might want to add them to CC.
    */
   final public function applyImplicitCC(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     if (!($object instanceof PhabricatorSubscribableInterface)) {
       // If the object isn't subscribable, we can't CC them.
       return $xactions;
     }
 
     $actor_phid = $this->requireActor()->getPHID();
     if ($object->isAutomaticallySubscribed($actor_phid)) {
       // If they're auto-subscribed, don't CC them.
       return $xactions;
     }
 
     $should_cc = false;
     foreach ($xactions as $xaction) {
       if ($this->shouldImplyCC($object, $xaction)) {
         $should_cc = true;
         break;
       }
     }
 
     if (!$should_cc) {
       // Only some types of actions imply a CC (like adding a comment).
       return $xactions;
     }
 
     if ($object->getPHID()) {
       if (isset($this->subscribers[$actor_phid])) {
         // If the user is already subscribed, don't implicitly CC them.
         return $xactions;
       }
 
       $unsub = PhabricatorEdgeQuery::loadDestinationPHIDs(
         $object->getPHID(),
         PhabricatorEdgeConfig::TYPE_OBJECT_HAS_UNSUBSCRIBER);
       $unsub = array_fuse($unsub);
       if (isset($unsub[$actor_phid])) {
         // If the user has previously unsubscribed from this object explicitly,
         // don't implicitly CC them.
         return $xactions;
       }
     }
 
     $xaction = newv(get_class(head($xactions)), array());
     $xaction->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
     $xaction->setNewValue(array('+' => array($actor_phid)));
 
     array_unshift($xactions, $xaction);
 
     return $xactions;
   }
 
   protected function shouldImplyCC(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         return true;
       default:
         return false;
     }
   }
 
 
 /* -(  Sending Mail  )------------------------------------------------------- */
 
 
   /**
    * @task mail
    */
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return false;
   }
 
 
   /**
    * @task mail
    */
   protected function sendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $email_to = array_filter(array_unique($this->getMailTo($object)));
     $email_cc = array_filter(array_unique($this->getMailCC($object)));
 
     $phids = array_merge($email_to, $email_cc);
     $handles = id(new PhabricatorHandleQuery())
       ->setViewer($this->requireActor())
       ->withPHIDs($phids)
       ->execute();
 
     $template = $this->buildMailTemplate($object);
     $body = $this->buildMailBody($object, $xactions);
 
     $mail_tags = $this->getMailTags($object, $xactions);
 
     $action = $this->getStrongestAction($object, $xactions)->getActionName();
 
     $template
       ->setFrom($this->requireActor()->getPHID())
       ->setSubjectPrefix($this->getMailSubjectPrefix())
       ->setVarySubjectPrefix('['.$action.']')
       ->setThreadID($this->getMailThreadID($object), $this->getIsNewObject())
       ->setRelatedPHID($object->getPHID())
       ->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
       ->setMailTags($mail_tags)
       ->setIsBulk(true)
       ->setBody($body->render());
 
     if ($this->getParentMessageID()) {
       $template->setParentMessageID($this->getParentMessageID());
     }
 
     $mails = $this
       ->buildReplyHandler($object)
       ->multiplexMail(
         $template,
         array_select_keys($handles, $email_to),
         array_select_keys($handles, $email_cc));
 
     foreach ($mails as $mail) {
       $mail->saveAndSend();
     }
 
     $template->addTos($email_to);
     $template->addCCs($email_cc);
 
     return $template;
   }
 
   protected function getMailThreadID(PhabricatorLiskDAO $object) {
     return $object->getPHID();
   }
 
 
   /**
    * @task mail
    */
   protected function getStrongestAction(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return last(msort($xactions, 'getActionStrength'));
   }
 
 
   /**
    * @task mail
    */
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     throw new Exception("Capability not supported.");
   }
 
 
   /**
    * @task mail
    */
   protected function getMailSubjectPrefix() {
     throw new Exception("Capability not supported.");
   }
 
 
   /**
    * @task mail
    */
   protected function getMailTags(
     PhabricatorLiskDAO $object,
     array $xactions) {
     $tags = array();
 
     foreach ($xactions as $xaction) {
       $tags[] = $xaction->getMailTags();
     }
 
     return array_mergev($tags);
   }
 
 
   /**
    * @task mail
    */
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     throw new Exception("Capability not supported.");
   }
 
 
   /**
    * @task mail
    */
   protected function getMailTo(PhabricatorLiskDAO $object) {
     throw new Exception("Capability not supported.");
   }
 
 
   /**
    * @task mail
    */
   protected function getMailCC(PhabricatorLiskDAO $object) {
     if ($object instanceof PhabricatorSubscribableInterface) {
       return $this->subscribers;
     }
     throw new Exception("Capability not supported.");
   }
 
 
   /**
    * @task mail
    */
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $headers = array();
     $comments = array();
 
     foreach ($xactions as $xaction) {
       if ($xaction->shouldHideForMail()) {
         continue;
       }
       $headers[] = id(clone $xaction)->setRenderingTarget('text')->getTitle();
       $comment = $xaction->getComment();
       if ($comment && strlen($comment->getContent())) {
         $comments[] = $comment->getContent();
       }
     }
 
     $body = new PhabricatorMetaMTAMailBody();
     $body->addRawSection(implode("\n", $headers));
 
     foreach ($comments as $comment) {
       $body->addRawSection($comment);
     }
 
     return $body;
   }
 
 
 /* -(  Publishing Feed Stories  )-------------------------------------------- */
 
 
   /**
    * @task feed
    */
   protected function supportsFeed() {
     return false;
   }
 
 
   /**
    * @task feed
    */
   protected function getFeedStoryType() {
     return 'PhabricatorApplicationTransactionFeedStory';
   }
 
 
   /**
    * @task feed
    */
   protected function getFeedRelatedPHIDs(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return array(
       $object->getPHID(),
       $this->requireActor()->getPHID(),
     );
   }
 
 
   /**
    * @task feed
    */
   protected function getFeedNotifyPHIDs(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return array_unique(array_merge(
       $this->getMailTo($object),
       $this->getMailCC($object)));
   }
 
 
   /**
    * @task feed
    */
   protected function getFeedStoryData(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $xactions = msort($xactions, 'getActionStrength');
     $xactions = array_reverse($xactions);
 
     return array(
       'objectPHID'        => $object->getPHID(),
       'transactionPHIDs'  => mpull($xactions, 'getPHID'),
     );
   }
 
 
   /**
    * @task feed
    */
   protected function publishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions,
     array $mailed_phids) {
 
     $related_phids = $this->getFeedRelatedPHIDs($object, $xactions);
     $subscribed_phids = $this->getFeedNotifyPHIDs($object, $xactions);
 
     $story_type = $this->getFeedStoryType();
     $story_data = $this->getFeedStoryData($object, $xactions);
 
     id(new PhabricatorFeedStoryPublisher())
       ->setStoryType($story_type)
       ->setStoryData($story_data)
       ->setStoryTime(time())
       ->setStoryAuthorPHID($this->requireActor()->getPHID())
       ->setRelatedPHIDs($related_phids)
       ->setPrimaryObjectPHID($object->getPHID())
       ->setSubscribedPHIDs($subscribed_phids)
       ->setMailRecipientPHIDs($mailed_phids)
       ->publish();
   }
 
 
 /* -(  Search Index  )------------------------------------------------------- */
 
 
   /**
    * @task search
    */
   protected function supportsSearch() {
     return false;
   }
 
 
 /* -(  Herald Integration )-------------------------------------------------- */
 
 
   protected function supportsHerald() {
     return false;
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
     throw new Exception('No herald adapter specified.');
   }
 
   private function setHeraldAdapter(HeraldAdapter $adapter) {
     $this->heraldAdapter = $adapter;
     return $this;
   }
 
   protected function getHeraldAdapter() {
     return $this->heraldAdapter;
   }
 
   private function setHeraldTranscript(HeraldTranscript $transcript) {
     $this->heraldTranscript = $transcript;
     return $this;
   }
 
   protected function getHeraldTranscript() {
     return $this->heraldTranscript;
   }
 
   private function applyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $adapter = $this->buildHeraldAdapter($object, $xactions);
     $adapter->setContentSource($this->getContentSource());
     $xscript = HeraldEngine::loadAndApplyRules($adapter);
 
     $this->setHeraldAdapter($adapter);
     $this->setHeraldTranscript($xscript);
 
     $this->didApplyHeraldRules($object, $adapter, $xscript);
   }
 
   protected function didApplyHeraldRules(
     PhabricatorLiskDAO $object,
     HeraldAdapter $adapter,
     HeraldTranscript $transcript) {
 
   }
 
 
 /* -(  Custom Fields  )------------------------------------------------------ */
 
 
   /**
    * @task customfield
    */
   private function getCustomFieldForTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $field_key = $xaction->getMetadataValue('customfield:key');
     if (!$field_key) {
       throw new Exception(
         "Custom field transaction has no 'customfield:key'!");
     }
 
     $field = PhabricatorCustomField::getObjectField(
       $object,
       PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS,
       $field_key);
 
     if (!$field) {
       throw new Exception(
         "Custom field transaction has invalid 'customfield:key'; field ".
         "'{$field_key}' is disabled or does not exist.");
     }
 
     if (!$field->shouldAppearInApplicationTransactions()) {
       throw new Exception(
         "Custom field transaction '{$field_key}' does not implement ".
         "integration for ApplicationTransactions.");
     }
 
     return $field;
   }
 
 
 /* -(  Files  )-------------------------------------------------------------- */
 
 
   /**
    * Extract the PHIDs of any files which these transactions attach.
    *
    * @task files
    */
   private function extractFilePHIDs(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $blocks = array();
     foreach ($xactions as $xaction) {
       $blocks[] = $this->getRemarkupBlocksFromTransaction($xaction);
     }
     $blocks = array_mergev($blocks);
 
 
     $phids = array();
     if ($blocks) {
       $phids[] = PhabricatorMarkupEngine::extractFilePHIDsFromEmbeddedFiles(
         $blocks);
     }
 
     foreach ($xactions as $xaction) {
       $phids[] = $this->extractFilePHIDsFromCustomTransaction(
         $object,
         $xaction);
     }
 
     $phids = array_unique(array_filter(array_mergev($phids)));
     if (!$phids) {
       return array();
     }
 
     // Only let a user attach files they can actually see, since this would
     // otherwise let you access any file by attaching it to an object you have
     // view permission on.
 
     $files = id(new PhabricatorFileQuery())
       ->setViewer($this->getActor())
       ->withPHIDs($phids)
       ->execute();
 
     return mpull($files, 'getPHID');
   }
 
   /**
    * @task files
    */
   protected function extractFilePHIDsFromCustomTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     return array();
   }
 
 
   /**
    * @task files
    */
   private function attachFiles(
     PhabricatorLiskDAO $object,
     array $file_phids) {
 
     if (!$file_phids) {
       return;
     }
 
     $editor = id(new PhabricatorEdgeEditor())
       ->setActor($this->getActor());
 
     // TODO: Edge-based events were almost certainly a terrible idea. If we
     // don't suppress this event, the Maniphest listener reenters and adds
     // more transactions. Just suppress it until that can get cleaned up.
     $editor->setSuppressEvents(true);
 
     $src = $object->getPHID();
     $type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_FILE;
     foreach ($file_phids as $dst) {
       $editor->addEdge($src, $type, $dst);
     }
 
     $editor->save();
   }
 
 }