diff --git a/src/applications/pholio/remarkup/PholioRemarkupRule.php b/src/applications/pholio/remarkup/PholioRemarkupRule.php
index e8c8f00a17..2b1ca0f876 100644
--- a/src/applications/pholio/remarkup/PholioRemarkupRule.php
+++ b/src/applications/pholio/remarkup/PholioRemarkupRule.php
@@ -1,81 +1,85 @@
 <?php
 
 final class PholioRemarkupRule extends PhabricatorObjectRemarkupRule {
 
   protected function getObjectNamePrefix() {
     return 'M';
   }
 
   protected function getObjectIDPattern() {
     // Match "M123", "M123/456", and "M123/456/". Users can hit the latter
     // forms when clicking comment anchors on a mock page.
     return '[1-9]\d*(?:/[1-9]\d*/?)?';
   }
 
   protected function getObjectHref(
     $object,
     PhabricatorObjectHandle $handle,
     $id) {
 
     $href = $handle->getURI();
 
     // If the ID has a `M123/456` component, link to that specific image.
     $id = explode('/', $id);
     if (isset($id[1])) {
       $href = $href.'/'.$id[1].'/';
     }
 
+    if ($this->getEngine()->getConfig('uri.full')) {
+      $href = PhabricatorEnv::getURI($href);
+    }
+
     return $href;
   }
 
   protected function loadObjects(array $ids) {
     // Strip off any image ID components of the URI.
     $map = array();
     foreach ($ids as $id) {
       $map[head(explode('/', $id))][] = $id;
     }
 
     $viewer = $this->getEngine()->getConfig('viewer');
     $mocks = id(new PholioMockQuery())
       ->setViewer($viewer)
       ->needCoverFiles(true)
       ->needImages(true)
       ->needTokenCounts(true)
       ->withIDs(array_keys($map))
       ->execute();
 
     $results = array();
     foreach ($mocks as $mock) {
       $ids = idx($map, $mock->getID(), array());
       foreach ($ids as $id) {
         $results[$id] = $mock;
       }
     }
 
     return $results;
   }
 
   protected function renderObjectEmbed(
     $object,
     PhabricatorObjectHandle $handle,
     $options) {
 
     $embed_mock = id(new PholioMockEmbedView())
       ->setMock($object);
 
     if (strlen($options)) {
       $parser = new PhutilSimpleOptions();
       $opts = $parser->parse(substr($options, 1));
 
       if (isset($opts['image'])) {
         $images = array_unique(
           explode('&', preg_replace('/\s+/', '', $opts['image'])));
 
         $embed_mock->setImages($images);
       }
     }
 
     return $embed_mock->render();
   }
 
 }
diff --git a/src/infrastructure/markup/PhabricatorMarkupEngine.php b/src/infrastructure/markup/PhabricatorMarkupEngine.php
index ccfe1e44fd..c29dddd821 100644
--- a/src/infrastructure/markup/PhabricatorMarkupEngine.php
+++ b/src/infrastructure/markup/PhabricatorMarkupEngine.php
@@ -1,631 +1,634 @@
 <?php
 
 /**
  * Manages markup engine selection, configuration, application, caching and
  * pipelining.
  *
  * @{class:PhabricatorMarkupEngine} can be used to render objects which
  * implement @{interface:PhabricatorMarkupInterface} in a batched, cache-aware
  * way. For example, if you have a list of comments written in remarkup (and
  * the objects implement the correct interface) you can render them by first
  * building an engine and adding the fields with @{method:addObject}.
  *
  *   $field  = 'field:body'; // Field you want to render. Each object exposes
  *                           // one or more fields of markup.
  *
  *   $engine = new PhabricatorMarkupEngine();
  *   foreach ($comments as $comment) {
  *     $engine->addObject($comment, $field);
  *   }
  *
  * Now, call @{method:process} to perform the actual cache/rendering
  * step. This is a heavyweight call which does batched data access and
  * transforms the markup into output.
  *
  *   $engine->process();
  *
  * Finally, do something with the results:
  *
  *   $results = array();
  *   foreach ($comments as $comment) {
  *     $results[] = $engine->getOutput($comment, $field);
  *   }
  *
  * If you have a single object to render, you can use the convenience method
  * @{method:renderOneObject}.
  *
  * @task markup Markup Pipeline
  * @task engine Engine Construction
  */
 final class PhabricatorMarkupEngine {
 
   private $objects = array();
   private $viewer;
   private $contextObject;
-  private $version = 14;
+  private $version = 15;
 
 
 /* -(  Markup Pipeline  )---------------------------------------------------- */
 
 
   /**
    * Convenience method for pushing a single object through the markup
    * pipeline.
    *
    * @param PhabricatorMarkupInterface  The object to render.
    * @param string                      The field to render.
    * @param PhabricatorUser             User viewing the markup.
    * @param object                      A context object for policy checks
    * @return string                     Marked up output.
    * @task markup
    */
   public static function renderOneObject(
     PhabricatorMarkupInterface $object,
     $field,
     PhabricatorUser $viewer,
     $context_object = null) {
     return id(new PhabricatorMarkupEngine())
       ->setViewer($viewer)
       ->setContextObject($context_object)
       ->addObject($object, $field)
       ->process()
       ->getOutput($object, $field);
   }
 
 
   /**
    * Queue an object for markup generation when @{method:process} is
    * called. You can retrieve the output later with @{method:getOutput}.
    *
    * @param PhabricatorMarkupInterface  The object to render.
    * @param string                      The field to render.
    * @return this
    * @task markup
    */
   public function addObject(PhabricatorMarkupInterface $object, $field) {
     $key = $this->getMarkupFieldKey($object, $field);
     $this->objects[$key] = array(
       'object' => $object,
       'field'  => $field,
     );
 
     return $this;
   }
 
 
   /**
    * Process objects queued with @{method:addObject}. You can then retrieve
    * the output with @{method:getOutput}.
    *
    * @return this
    * @task markup
    */
   public function process() {
     $keys = array();
     foreach ($this->objects as $key => $info) {
       if (!isset($info['markup'])) {
         $keys[] = $key;
       }
     }
 
     if (!$keys) {
       return;
     }
 
     $objects = array_select_keys($this->objects, $keys);
 
     // Build all the markup engines. We need an engine for each field whether
     // we have a cache or not, since we still need to postprocess the cache.
     $engines = array();
     foreach ($objects as $key => $info) {
       $engines[$key] = $info['object']->newMarkupEngine($info['field']);
       $engines[$key]->setConfig('viewer', $this->viewer);
       $engines[$key]->setConfig('contextObject', $this->contextObject);
     }
 
     // Load or build the preprocessor caches.
     $blocks = $this->loadPreprocessorCaches($engines, $objects);
     $blocks = mpull($blocks, 'getCacheData');
 
     $this->engineCaches = $blocks;
 
     // Finalize the output.
     foreach ($objects as $key => $info) {
       $engine = $engines[$key];
       $field = $info['field'];
       $object = $info['object'];
 
       $output = $engine->postprocessText($blocks[$key]);
       $output = $object->didMarkupText($field, $output, $engine);
       $this->objects[$key]['output'] = $output;
     }
 
     return $this;
   }
 
 
   /**
    * Get the output of markup processing for a field queued with
    * @{method:addObject}. Before you can call this method, you must call
    * @{method:process}.
    *
    * @param PhabricatorMarkupInterface  The object to retrieve.
    * @param string                      The field to retrieve.
    * @return string                     Processed output.
    * @task markup
    */
   public function getOutput(PhabricatorMarkupInterface $object, $field) {
     $key = $this->getMarkupFieldKey($object, $field);
     $this->requireKeyProcessed($key);
 
     return $this->objects[$key]['output'];
   }
 
 
   /**
    * Retrieve engine metadata for a given field.
    *
    * @param PhabricatorMarkupInterface  The object to retrieve.
    * @param string                      The field to retrieve.
    * @param string                      The engine metadata field to retrieve.
    * @param wild                        Optional default value.
    * @task markup
    */
   public function getEngineMetadata(
     PhabricatorMarkupInterface $object,
     $field,
     $metadata_key,
     $default = null) {
 
     $key = $this->getMarkupFieldKey($object, $field);
     $this->requireKeyProcessed($key);
 
     return idx($this->engineCaches[$key]['metadata'], $metadata_key, $default);
   }
 
 
   /**
    * @task markup
    */
   private function requireKeyProcessed($key) {
     if (empty($this->objects[$key])) {
       throw new Exception(
         "Call addObject() before using results (key = '{$key}').");
     }
 
     if (!isset($this->objects[$key]['output'])) {
       throw new Exception(
         'Call process() before using results.');
     }
   }
 
 
   /**
    * @task markup
    */
   private function getMarkupFieldKey(
     PhabricatorMarkupInterface $object,
     $field) {
 
     static $custom;
     if ($custom === null) {
       $custom = array_merge(
         self::loadCustomInlineRules(),
         self::loadCustomBlockRules());
 
       $custom = mpull($custom, 'getRuleVersion', null);
       ksort($custom);
       $custom = PhabricatorHash::digestForIndex(serialize($custom));
     }
 
     return $object->getMarkupFieldKey($field).'@'.$this->version.'@'.$custom;
   }
 
 
   /**
    * @task markup
    */
   private function loadPreprocessorCaches(array $engines, array $objects) {
     $blocks = array();
 
     $use_cache = array();
     foreach ($objects as $key => $info) {
       if ($info['object']->shouldUseMarkupCache($info['field'])) {
         $use_cache[$key] = true;
       }
     }
 
     if ($use_cache) {
       try {
         $blocks = id(new PhabricatorMarkupCache())->loadAllWhere(
           'cacheKey IN (%Ls)',
           array_keys($use_cache));
         $blocks = mpull($blocks, null, 'getCacheKey');
       } catch (Exception $ex) {
         phlog($ex);
       }
     }
 
     foreach ($objects as $key => $info) {
       // False check in case MySQL doesn't support unicode characters
       // in the string (T1191), resulting in unserialize returning false.
       if (isset($blocks[$key]) && $blocks[$key]->getCacheData() !== false) {
         // If we already have a preprocessing cache, we don't need to rebuild
         // it.
         continue;
       }
 
       $text = $info['object']->getMarkupText($info['field']);
       $data = $engines[$key]->preprocessText($text);
 
       // NOTE: This is just debugging information to help sort out cache issues.
       // If one machine is misconfigured and poisoning caches you can use this
       // field to hunt it down.
 
       $metadata = array(
         'host' => php_uname('n'),
       );
 
       $blocks[$key] = id(new PhabricatorMarkupCache())
         ->setCacheKey($key)
         ->setCacheData($data)
         ->setMetadata($metadata);
 
       if (isset($use_cache[$key])) {
         // This is just filling a cache and always safe, even on a read pathway.
         $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
           $blocks[$key]->replace();
         unset($unguarded);
       }
     }
 
     return $blocks;
   }
 
 
   /**
    * Set the viewing user. Used to implement object permissions.
    *
    * @param PhabricatorUser The viewing user.
    * @return this
    * @task markup
    */
   public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   /**
    * Set the context object. Used to implement object permissions.
    *
    * @param The object in which context this remarkup is used.
    * @return this
    * @task markup
    */
   public function setContextObject($object) {
     $this->contextObject = $object;
     return $this;
   }
 
 
 /* -(  Engine Construction  )------------------------------------------------ */
 
 
 
   /**
    * @task engine
    */
   public static function newManiphestMarkupEngine() {
     return self::newMarkupEngine(array(
     ));
   }
 
 
   /**
    * @task engine
    */
   public static function newPhrictionMarkupEngine() {
     return self::newMarkupEngine(array(
       'header.generate-toc' => true,
     ));
   }
 
 
   /**
    * @task engine
    */
   public static function newPhameMarkupEngine() {
     return self::newMarkupEngine(array(
       'macros' => false,
+      'uri.full' => true,
     ));
   }
 
 
   /**
    * @task engine
    */
   public static function newFeedMarkupEngine() {
     return self::newMarkupEngine(
       array(
         'macros'      => false,
         'youtube'     => false,
-
       ));
   }
 
   /**
    * @task engine
    */
   public static function newCalendarMarkupEngine() {
     return self::newMarkupEngine(array(
     ));
   }
 
 
   /**
    * @task engine
    */
   public static function newDifferentialMarkupEngine(array $options = array()) {
     return self::newMarkupEngine(array(
       'differential.diff' => idx($options, 'differential.diff'),
     ));
   }
 
 
   /**
    * @task engine
    */
   public static function newDiffusionMarkupEngine(array $options = array()) {
     return self::newMarkupEngine(array(
       'header.generate-toc' => true,
     ));
   }
 
   /**
    * @task engine
    */
   public static function getEngine($ruleset = 'default') {
     static $engines = array();
     if (isset($engines[$ruleset])) {
       return $engines[$ruleset];
     }
 
     $engine = null;
     switch ($ruleset) {
       case 'default':
         $engine = self::newMarkupEngine(array());
         break;
       case 'nolinebreaks':
         $engine = self::newMarkupEngine(array());
         $engine->setConfig('preserve-linebreaks', false);
         break;
       case 'diffusion-readme':
         $engine = self::newMarkupEngine(array());
         $engine->setConfig('preserve-linebreaks', false);
         $engine->setConfig('header.generate-toc', true);
         break;
       case 'diviner':
         $engine = self::newMarkupEngine(array());
         $engine->setConfig('preserve-linebreaks', false);
   //    $engine->setConfig('diviner.renderer', new DivinerDefaultRenderer());
         $engine->setConfig('header.generate-toc', true);
         break;
       case 'extract':
         // Engine used for reference/edge extraction. Turn off anything which
         // is slow and doesn't change reference extraction.
         $engine = self::newMarkupEngine(array());
         $engine->setConfig('pygments.enabled', false);
         break;
       default:
         throw new Exception("Unknown engine ruleset: {$ruleset}!");
     }
 
     $engines[$ruleset] = $engine;
     return $engine;
   }
 
   /**
    * @task engine
    */
   private static function getMarkupEngineDefaultConfiguration() {
     return array(
       'pygments'      => PhabricatorEnv::getEnvConfig('pygments.enabled'),
       'youtube'       => PhabricatorEnv::getEnvConfig(
         'remarkup.enable-embedded-youtube'),
       'differential.diff' => null,
       'header.generate-toc' => false,
       'macros'        => true,
       'uri.allowed-protocols' => PhabricatorEnv::getEnvConfig(
         'uri.allowed-protocols'),
+      'uri.full' => false,
       'syntax-highlighter.engine' => PhabricatorEnv::getEnvConfig(
         'syntax-highlighter.engine'),
       'preserve-linebreaks' => true,
     );
   }
 
 
   /**
    * @task engine
    */
   public static function newMarkupEngine(array $options) {
 
     $options += self::getMarkupEngineDefaultConfiguration();
 
     $engine = new PhutilRemarkupEngine();
 
     $engine->setConfig('preserve-linebreaks', $options['preserve-linebreaks']);
     $engine->setConfig('pygments.enabled', $options['pygments']);
     $engine->setConfig(
       'uri.allowed-protocols',
       $options['uri.allowed-protocols']);
     $engine->setConfig('differential.diff', $options['differential.diff']);
     $engine->setConfig('header.generate-toc', $options['header.generate-toc']);
     $engine->setConfig(
       'syntax-highlighter.engine',
       $options['syntax-highlighter.engine']);
 
+    $engine->setConfig('uri.full', $options['uri.full']);
+
     $rules = array();
     $rules[] = new PhutilRemarkupEscapeRemarkupRule();
     $rules[] = new PhutilRemarkupMonospaceRule();
 
 
     $rules[] = new PhutilRemarkupDocumentLinkRule();
     $rules[] = new PhabricatorNavigationRemarkupRule();
 
     if ($options['youtube']) {
       $rules[] = new PhabricatorYoutubeRemarkupRule();
     }
 
     $applications = PhabricatorApplication::getAllInstalledApplications();
     foreach ($applications as $application) {
       foreach ($application->getRemarkupRules() as $rule) {
         $rules[] = $rule;
       }
     }
 
     $rules[] = new PhutilRemarkupHyperlinkRule();
 
     if ($options['macros']) {
       $rules[] = new PhabricatorImageMacroRemarkupRule();
       $rules[] = new PhabricatorMemeRemarkupRule();
     }
 
     $rules[] = new PhutilRemarkupBoldRule();
     $rules[] = new PhutilRemarkupItalicRule();
     $rules[] = new PhutilRemarkupDelRule();
     $rules[] = new PhutilRemarkupUnderlineRule();
 
     foreach (self::loadCustomInlineRules() as $rule) {
       $rules[] = $rule;
     }
 
     $blocks = array();
     $blocks[] = new PhutilRemarkupQuotesBlockRule();
     $blocks[] = new PhutilRemarkupReplyBlockRule();
     $blocks[] = new PhutilRemarkupLiteralBlockRule();
     $blocks[] = new PhutilRemarkupHeaderBlockRule();
     $blocks[] = new PhutilRemarkupHorizontalRuleBlockRule();
     $blocks[] = new PhutilRemarkupListBlockRule();
     $blocks[] = new PhutilRemarkupCodeBlockRule();
     $blocks[] = new PhutilRemarkupNoteBlockRule();
     $blocks[] = new PhutilRemarkupTableBlockRule();
     $blocks[] = new PhutilRemarkupSimpleTableBlockRule();
     $blocks[] = new PhutilRemarkupInterpreterBlockRule();
     $blocks[] = new PhutilRemarkupDefaultBlockRule();
 
     foreach (self::loadCustomBlockRules() as $rule) {
       $blocks[] = $rule;
     }
 
     foreach ($blocks as $block) {
       $block->setMarkupRules($rules);
     }
 
     $engine->setBlockRules($blocks);
 
     return $engine;
   }
 
   public static function extractPHIDsFromMentions(
     PhabricatorUser $viewer,
     array $content_blocks) {
 
     $mentions = array();
 
     $engine = self::newDifferentialMarkupEngine();
     $engine->setConfig('viewer', $viewer);
 
     foreach ($content_blocks as $content_block) {
       $engine->markupText($content_block);
       $phids = $engine->getTextMetadata(
         PhabricatorMentionRemarkupRule::KEY_MENTIONED,
         array());
       $mentions += $phids;
     }
 
     return $mentions;
   }
 
   public static function extractFilePHIDsFromEmbeddedFiles(
     PhabricatorUser $viewer,
     array $content_blocks) {
     $files = array();
 
     $engine = self::newDifferentialMarkupEngine();
     $engine->setConfig('viewer', $viewer);
 
     foreach ($content_blocks as $content_block) {
       $engine->markupText($content_block);
       $phids = $engine->getTextMetadata(
         PhabricatorEmbedFileRemarkupRule::KEY_EMBED_FILE_PHIDS,
         array());
       foreach ($phids as $phid) {
         $files[$phid] = $phid;
       }
     }
 
     return array_values($files);
   }
 
   /**
    * Produce a corpus summary, in a way that shortens the underlying text
    * without truncating it somewhere awkward.
    *
    * TODO: We could do a better job of this.
    *
    * @param string  Remarkup corpus to summarize.
    * @return string Summarized corpus.
    */
   public static function summarize($corpus) {
 
     // Major goals here are:
     //  - Don't split in the middle of a character (utf-8).
     //  - Don't split in the middle of, e.g., **bold** text, since
     //    we end up with hanging '**' in the summary.
     //  - Try not to pick an image macro, header, embedded file, etc.
     //  - Hopefully don't return too much text. We don't explicitly limit
     //    this right now.
 
     $blocks = preg_split("/\n *\n\s*/", $corpus);
 
     $best = null;
     foreach ($blocks as $block) {
       // This is a test for normal spaces in the block, i.e. a heuristic to
       // distinguish standard paragraphs from things like image macros. It may
       // not work well for non-latin text. We prefer to summarize with a
       // paragraph of normal words over an image macro, if possible.
       $has_space = preg_match('/\w\s\w/', $block);
 
       // This is a test to find embedded images and headers. We prefer to
       // summarize with a normal paragraph over a header or an embedded object,
       // if possible.
       $has_embed = preg_match('/^[{=]/', $block);
 
       if ($has_space && !$has_embed) {
         // This seems like a good summary, so return it.
         return $block;
       }
 
       if (!$best) {
         // This is the first block we found; if everything is garbage just
         // use the first block.
         $best = $block;
       }
     }
 
     return $best;
   }
 
   private static function loadCustomInlineRules() {
     return id(new PhutilSymbolLoader())
       ->setAncestorClass('PhabricatorRemarkupCustomInlineRule')
       ->loadObjects();
   }
 
   private static function loadCustomBlockRules() {
     return id(new PhutilSymbolLoader())
       ->setAncestorClass('PhabricatorRemarkupCustomBlockRule')
       ->loadObjects();
   }
 
 }
diff --git a/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php b/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php
index 28377c19d5..8f776716ea 100644
--- a/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php
+++ b/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php
@@ -1,376 +1,382 @@
 <?php
 
 abstract class PhabricatorObjectRemarkupRule extends PhutilRemarkupRule {
 
   const KEY_RULE_OBJECT = 'rule.object';
   const KEY_MENTIONED_OBJECTS = 'rule.object.mentioned';
 
   abstract protected function getObjectNamePrefix();
   abstract protected function loadObjects(array $ids);
 
   public function getPriority() {
     return 450.0;
   }
 
   protected function getObjectNamePrefixBeginsWithWordCharacter() {
     $prefix = $this->getObjectNamePrefix();
     return preg_match('/^\w/', $prefix);
   }
 
   protected function getObjectIDPattern() {
     return '[1-9]\d*';
   }
 
   protected function shouldMarkupObject(array $params) {
     return true;
   }
 
   protected function loadHandles(array $objects) {
     $phids = mpull($objects, 'getPHID');
 
     $viewer = $this->getEngine()->getConfig('viewer');
     $handles = $viewer->loadHandles($phids);
     $handles = iterator_to_array($handles);
 
     $result = array();
     foreach ($objects as $id => $object) {
       $result[$id] = $handles[$object->getPHID()];
     }
     return $result;
   }
 
   protected function getObjectHref(
     $object,
     PhabricatorObjectHandle $handle,
     $id) {
 
-    return $handle->getURI();
+    $uri = $handle->getURI();
+
+    if ($this->getEngine()->getConfig('uri.full')) {
+      $uri = PhabricatorEnv::getURI($uri);
+    }
+
+    return $uri;
   }
 
   protected function renderObjectRefForAnyMedia (
     $object,
     PhabricatorObjectHandle $handle,
     $anchor,
     $id) {
 
     $href = $this->getObjectHref($object, $handle, $id);
     $text = $this->getObjectNamePrefix().$id;
 
     if ($anchor) {
       $href = $href.'#'.$anchor;
       $text = $text.'#'.$anchor;
     }
 
     if ($this->getEngine()->isTextMode()) {
       return PhabricatorEnv::getProductionURI($href);
     } else if ($this->getEngine()->isHTMLMailMode()) {
       $href = PhabricatorEnv::getProductionURI($href);
       return $this->renderObjectTagForMail($text, $href, $handle);
     }
 
     return $this->renderObjectRef($object, $handle, $anchor, $id);
 
   }
 
   protected function renderObjectRef(
     $object,
     PhabricatorObjectHandle $handle,
     $anchor,
     $id) {
 
     $href = $this->getObjectHref($object, $handle, $id);
     $text = $this->getObjectNamePrefix().$id;
     $status_closed = PhabricatorObjectHandleStatus::STATUS_CLOSED;
 
     if ($anchor) {
       $href = $href.'#'.$anchor;
       $text = $text.'#'.$anchor;
     }
 
     $attr = array(
       'phid'    => $handle->getPHID(),
       'closed'  => ($handle->getStatus() == $status_closed),
     );
 
     return $this->renderHovertag($text, $href, $attr);
   }
 
   protected function renderObjectEmbedForAnyMedia(
     $object,
     PhabricatorObjectHandle $handle,
     $options) {
 
     $name = $handle->getFullName();
     $href = $handle->getURI();
 
     if ($this->getEngine()->isTextMode()) {
       return $name.' <'.PhabricatorEnv::getProductionURI($href).'>';
     } else if ($this->getEngine()->isHTMLMailMode()) {
       $href = PhabricatorEnv::getProductionURI($href);
       return $this->renderObjectTagForMail($name, $href, $handle);
     }
 
     return $this->renderObjectEmbed($object, $handle, $options);
   }
 
   protected function renderObjectEmbed(
     $object,
     PhabricatorObjectHandle $handle,
     $options) {
 
     $name = $handle->getFullName();
     $href = $handle->getURI();
     $status_closed = PhabricatorObjectHandleStatus::STATUS_CLOSED;
     $attr = array(
       'phid' => $handle->getPHID(),
       'closed'  => ($handle->getStatus() == $status_closed),
     );
 
     return $this->renderHovertag($name, $href, $attr);
   }
 
   protected function renderObjectTagForMail(
     $text,
     $href,
     PhabricatorObjectHandle $handle) {
 
     $status_closed = PhabricatorObjectHandleStatus::STATUS_CLOSED;
     $strikethrough = $handle->getStatus() == $status_closed ?
       'text-decoration: line-through;' :
       'text-decoration: none;';
 
     return phutil_tag(
       'a',
       array(
         'href' => $href,
         'style' => 'background-color: #e7e7e7;
           border-color: #e7e7e7;
           border-radius: 3px;
           padding: 0 4px;
           font-weight: bold;
           color: black;'
           .$strikethrough,
       ),
       $text);
   }
 
   protected function renderHovertag($name, $href, array $attr = array()) {
     return id(new PHUITagView())
       ->setName($name)
       ->setHref($href)
       ->setType(PHUITagView::TYPE_OBJECT)
       ->setPHID(idx($attr, 'phid'))
       ->setClosed(idx($attr, 'closed'))
       ->render();
   }
 
   public function apply($text) {
     $text = preg_replace_callback(
       $this->getObjectEmbedPattern(),
       array($this, 'markupObjectEmbed'),
       $text);
 
     $text = preg_replace_callback(
       $this->getObjectReferencePattern(),
       array($this, 'markupObjectReference'),
       $text);
 
     return $text;
   }
 
   private function getObjectEmbedPattern() {
     $prefix = $this->getObjectNamePrefix();
     $prefix = preg_quote($prefix);
     $id = $this->getObjectIDPattern();
 
     return '(\B{'.$prefix.'('.$id.')([,\s](?:[^}\\\\]|\\\\.)*)?}\B)u';
   }
 
   private function getObjectReferencePattern() {
     $prefix = $this->getObjectNamePrefix();
     $prefix = preg_quote($prefix);
 
     $id = $this->getObjectIDPattern();
 
     // If the prefix starts with a word character (like "D"), we want to
     // require a word boundary so that we don't match "XD1" as "D1". If the
     // prefix does not start with a word character, we want to require no word
     // boundary for the same reasons. Test if the prefix starts with a word
     // character.
     if ($this->getObjectNamePrefixBeginsWithWordCharacter()) {
       $boundary = '\\b';
     } else {
       $boundary = '\\B';
     }
 
     // The "(?<![#-])" prevents us from linking "#abcdef" or similar, and
     // "ABC-T1" (see T5714).
 
     // The "\b" allows us to link "(abcdef)" or similar without linking things
     // in the middle of words.
 
     return '((?<![#-])'.$boundary.$prefix.'('.$id.')(?:#([-\w\d]+))?(?!\w))u';
   }
 
 
   /**
    * Extract matched object references from a block of text.
    *
    * This is intended to make it easy to write unit tests for object remarkup
    * rules. Production code is not normally expected to call this method.
    *
    * @param   string  Text to match rules against.
    * @return  wild    Matches, suitable for writing unit tests against.
    */
   public function extractReferences($text) {
     $embed_matches = null;
     preg_match_all(
       $this->getObjectEmbedPattern(),
       $text,
       $embed_matches,
       PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
 
     $ref_matches = null;
     preg_match_all(
       $this->getObjectReferencePattern(),
       $text,
       $ref_matches,
       PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
 
     $results = array();
     $sets = array(
       'embed' => $embed_matches,
       'ref' => $ref_matches,
     );
     foreach ($sets as $type => $matches) {
       $formatted = array();
       foreach ($matches as $match) {
         $format = array(
           'offset' => $match[1][1],
           'id' => $match[1][0],
         );
         if (isset($match[2][0])) {
           $format['tail'] = $match[2][0];
         }
         $formatted[] = $format;
       }
       $results[$type] = $formatted;
     }
 
     return $results;
   }
 
   public function markupObjectEmbed(array $matches) {
     if (!$this->isFlatText($matches[0])) {
       return $matches[0];
     }
 
     return $this->markupObject(array(
       'type' => 'embed',
       'id' => $matches[1],
       'options' => idx($matches, 2),
       'original' => $matches[0],
     ));
   }
 
   public function markupObjectReference(array $matches) {
     if (!$this->isFlatText($matches[0])) {
       return $matches[0];
     }
 
     return $this->markupObject(array(
       'type' => 'ref',
       'id' => $matches[1],
       'anchor' => idx($matches, 2),
       'original' => $matches[0],
     ));
   }
 
   private function markupObject(array $params) {
     if (!$this->shouldMarkupObject($params)) {
       return $params['original'];
     }
 
     $regex = trim(
       PhabricatorEnv::getEnvConfig('remarkup.ignored-object-names'));
     if ($regex && preg_match($regex, $params['original'])) {
       return $params['original'];
     }
 
     $engine = $this->getEngine();
     $token = $engine->storeText('x');
 
     $metadata_key = self::KEY_RULE_OBJECT.'.'.$this->getObjectNamePrefix();
     $metadata = $engine->getTextMetadata($metadata_key, array());
 
     $metadata[] = array(
       'token'   => $token,
     ) + $params;
 
     $engine->setTextMetadata($metadata_key, $metadata);
 
     return $token;
   }
 
   public function didMarkupText() {
     $engine = $this->getEngine();
     $metadata_key = self::KEY_RULE_OBJECT.'.'.$this->getObjectNamePrefix();
     $metadata = $engine->getTextMetadata($metadata_key, array());
 
     if (!$metadata) {
       return;
     }
 
 
     $ids = ipull($metadata, 'id');
     $objects = $this->loadObjects($ids);
 
     // For objects that are invalid or which the user can't see, just render
     // the original text.
 
     // TODO: We should probably distinguish between these cases and render a
     // "you can't see this" state for nonvisible objects.
 
     foreach ($metadata as $key => $spec) {
       if (empty($objects[$spec['id']])) {
         $engine->overwriteStoredText(
           $spec['token'],
           $spec['original']);
         unset($metadata[$key]);
       }
     }
 
     $phids = $engine->getTextMetadata(self::KEY_MENTIONED_OBJECTS, array());
     foreach ($objects as $object) {
       $phids[$object->getPHID()] = $object->getPHID();
     }
     $engine->setTextMetadata(self::KEY_MENTIONED_OBJECTS, $phids);
 
     $handles = $this->loadHandles($objects);
     foreach ($metadata as $key => $spec) {
       $handle = $handles[$spec['id']];
       $object = $objects[$spec['id']];
       switch ($spec['type']) {
         case 'ref':
 
           $view = $this->renderObjectRefForAnyMedia(
             $object,
             $handle,
             $spec['anchor'],
             $spec['id']);
           break;
         case 'embed':
           $spec['options'] = $this->assertFlatText($spec['options']);
           $view = $this->renderObjectEmbedForAnyMedia(
             $object,
             $handle,
             $spec['options']);
           break;
       }
       $engine->overwriteStoredText($spec['token'], $view);
     }
 
     $engine->setTextMetadata($metadata_key, array());
   }
 
 }