No OneTemporary
Actions

Size

63 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php b/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php
	index 8e2d0cf0c9..9f37bdcaab 100644
	--- a/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php
	+++ b/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php
	@@ -1,327 +1,358 @@
	<?php

	final class PhabricatorEmbedFileRemarkupRule
	extends PhabricatorObjectRemarkupRule {

	private $viewer;

	- const KEY_EMBED_FILE_PHIDS = 'phabricator.embedded-file-phids';
	+ const KEY_ATTACH_INTENT_FILE_PHIDS = 'files.attach-intent';

	protected function getObjectNamePrefix() {
	return 'F';
	}

	protected function loadObjects(array $ids) {
	$engine = $this->getEngine();

	$this->viewer = $engine->getConfig('viewer');
	$objects = id(new PhabricatorFileQuery())
	->setViewer($this->viewer)
	->withIDs($ids)
	->needTransforms(
	array(
	PhabricatorFileThumbnailTransform::TRANSFORM_PREVIEW,
	))
	->execute();
	+ $objects = mpull($objects, null, 'getID');

	- $phids_key = self::KEY_EMBED_FILE_PHIDS;
	- $phids = $engine->getTextMetadata($phids_key, array());
	- foreach (mpull($objects, 'getPHID') as $phid) {
	- $phids[] = $phid;
	+
	+ // Identify files embedded in the block with "attachment intent", i.e.
	+ // those files which the user appears to want to attach to the object.
	+ // Files referenced inside quoted blocks are not considered to have this
	+ // attachment intent.
	+
	+ $metadata_key = self::KEY_RULE_OBJECT.'.'.$this->getObjectNamePrefix();
	+ $metadata = $engine->getTextMetadata($metadata_key, array());
	+
	+ $attach_key = self::KEY_ATTACH_INTENT_FILE_PHIDS;
	+ $attach_phids = $engine->getTextMetadata($attach_key, array());
	+
	+ foreach ($metadata as $item) {
	+
	+ // If this reference was inside a quoted block, don't count it. Quoting
	+ // someone else doesn't establish an intent to attach a file.
	+ $depth = idx($item, 'quote.depth');
	+ if ($depth > 0) {
	+ continue;
	+ }
	+
	+ $id = $item['id'];
	+ $file = idx($objects, $id);
	+
	+ if (!$file) {
	+ continue;
	+ }
	+
	+ $attach_phids[] = $file->getPHID();
	}
	- $engine->setTextMetadata($phids_key, $phids);
	+
	+ $attach_phids = array_fuse($attach_phids);
	+ $attach_phids = array_keys($attach_phids);
	+
	+ $engine->setTextMetadata($attach_key, $attach_phids);
	+

	return $objects;
	}

	protected function renderObjectEmbed(
	$object,
	PhabricatorObjectHandle $handle,
	$options) {

	$options = $this->getFileOptions($options) + array(
	'name' => $object->getName(),
	);

	$is_viewable_image = $object->isViewableImage();
	$is_audio = $object->isAudio();
	$is_video = $object->isVideo();
	$force_link = ($options['layout'] == 'link');

	// If a file is both audio and video, as with "application/ogg" by default,
	// render it as video but allow the user to specify `media=audio` if they
	// want to force it to render as audio.
	if ($is_audio && $is_video) {
	$media = $options['media'];
	if ($media == 'audio') {
	$is_video = false;
	} else {
	$is_audio = false;
	}
	}

	$options['viewable'] = ($is_viewable_image \|\| $is_audio \|\| $is_video);

	if ($is_viewable_image && !$force_link) {
	return $this->renderImageFile($object, $handle, $options);
	} else if ($is_video && !$force_link) {
	return $this->renderVideoFile($object, $handle, $options);
	} else if ($is_audio && !$force_link) {
	return $this->renderAudioFile($object, $handle, $options);
	} else {
	return $this->renderFileLink($object, $handle, $options);
	}
	}

	private function getFileOptions($option_string) {
	$options = array(
	'size' => null,
	'layout' => 'left',
	'float' => false,
	'width' => null,
	'height' => null,
	'alt' => null,
	'media' => null,
	'autoplay' => null,
	'loop' => null,
	);

	if ($option_string) {
	$option_string = trim($option_string, ', ');
	$parser = new PhutilSimpleOptions();
	$options = $parser->parse($option_string) + $options;
	}

	return $options;
	}

	private function renderImageFile(
	PhabricatorFile $file,
	PhabricatorObjectHandle $handle,
	array $options) {

	require_celerity_resource('phui-lightbox-css');

	$attrs = array();
	$image_class = 'phabricator-remarkup-embed-image';

	$use_size = true;
	if (!$options['size']) {
	$width = $this->parseDimension($options['width']);
	$height = $this->parseDimension($options['height']);
	if ($width \|\| $height) {
	$use_size = false;
	$attrs += array(
	'src' => $file->getBestURI(),
	'width' => $width,
	'height' => $height,
	);
	}
	}

	if ($use_size) {
	switch ((string)$options['size']) {
	case 'full':
	$attrs += array(
	'src' => $file->getBestURI(),
	'height' => $file->getImageHeight(),
	'width' => $file->getImageWidth(),
	);
	$image_class = 'phabricator-remarkup-embed-image-full';
	break;
	// Displays "full" in normal Remarkup, "wide" in Documents
	case 'wide':
	$attrs += array(
	'src' => $file->getBestURI(),
	'width' => $file->getImageWidth(),
	);
	$image_class = 'phabricator-remarkup-embed-image-wide';
	break;
	case 'thumb':
	default:
	$preview_key = PhabricatorFileThumbnailTransform::TRANSFORM_PREVIEW;
	$xform = PhabricatorFileTransform::getTransformByKey($preview_key);

	$existing_xform = $file->getTransform($preview_key);
	if ($existing_xform) {
	$xform_uri = $existing_xform->getCDNURI('data');
	} else {
	$xform_uri = $file->getURIForTransform($xform);
	}

	$attrs['src'] = $xform_uri;

	$dimensions = $xform->getTransformedDimensions($file);
	if ($dimensions) {
	list($x, $y) = $dimensions;
	$attrs['width'] = $x;
	$attrs['height'] = $y;
	}
	break;
	}
	}

	$alt = null;
	if (isset($options['alt'])) {
	$alt = $options['alt'];
	}

	if (!strlen($alt)) {
	$alt = $file->getAltText();
	}

	$attrs['alt'] = $alt;

	$img = phutil_tag('img', $attrs);

	$embed = javelin_tag(
	'a',
	array(
	'href' => $file->getBestURI(),
	'class' => $image_class,
	'sigil' => 'lightboxable',
	'meta' => array(
	'phid' => $file->getPHID(),
	'uri' => $file->getBestURI(),
	'dUri' => $file->getDownloadURI(),
	'alt' => $alt,
	'viewable' => true,
	'monogram' => $file->getMonogram(),
	),
	),
	$img);

	switch ($options['layout']) {
	case 'right':
	case 'center':
	case 'inline':
	case 'left':
	$layout_class = 'phabricator-remarkup-embed-layout-'.$options['layout'];
	break;
	default:
	$layout_class = 'phabricator-remarkup-embed-layout-left';
	break;
	}

	if ($options['float']) {
	switch ($options['layout']) {
	case 'center':
	case 'inline':
	break;
	case 'right':
	$layout_class .= ' phabricator-remarkup-embed-float-right';
	break;
	case 'left':
	default:
	$layout_class .= ' phabricator-remarkup-embed-float-left';
	break;
	}
	}

	return phutil_tag(
	($options['layout'] == 'inline' ? 'span' : 'div'),
	array(
	'class' => $layout_class,
	),
	$embed);
	}

	private function renderAudioFile(
	PhabricatorFile $file,
	PhabricatorObjectHandle $handle,
	array $options) {
	return $this->renderMediaFile('audio', $file, $handle, $options);
	}

	private function renderVideoFile(
	PhabricatorFile $file,
	PhabricatorObjectHandle $handle,
	array $options) {
	return $this->renderMediaFile('video', $file, $handle, $options);
	}

	private function renderMediaFile(
	$tag,
	PhabricatorFile $file,
	PhabricatorObjectHandle $handle,
	array $options) {

	$is_video = ($tag == 'video');

	if (idx($options, 'autoplay')) {
	$preload = 'auto';
	$autoplay = 'autoplay';
	} else {
	// If we don't preload video, the user can't see the first frame and
	// has no clue what they're looking at, so always preload.
	if ($is_video) {
	$preload = 'auto';
	} else {
	$preload = 'none';
	}
	$autoplay = null;
	}

	// Rendering contexts like feed can disable autoplay.
	$engine = $this->getEngine();
	if ($engine->getConfig('autoplay.disable')) {
	$autoplay = null;
	}

	if ($is_video) {
	// See T13135. Chrome refuses to play videos with type "video/quicktime",
	// even though it may actually be able to play them. The least awful fix
	// based on available information is to simply omit the "type" attribute
	// from `<source />` tags. This causes Chrome to try to play the video
	// and realize it can, and does not appear to produce any bad behavior in
	// any other browser.
	$mime_type = null;
	} else {
	$mime_type = $file->getMimeType();
	}

	return $this->newTag(
	$tag,
	array(
	'controls' => 'controls',
	'preload' => $preload,
	'autoplay' => $autoplay,
	'loop' => idx($options, 'loop') ? 'loop' : null,
	'alt' => $options['alt'],
	'class' => 'phabricator-media',
	),
	$this->newTag(
	'source',
	array(
	'src' => $file->getBestURI(),
	'type' => $mime_type,
	)));
	}

	private function renderFileLink(
	PhabricatorFile $file,
	PhabricatorObjectHandle $handle,
	array $options) {

	return id(new PhabricatorFileLinkView())
	->setViewer($this->viewer)
	->setFilePHID($file->getPHID())
	->setFileName($this->assertFlatText($options['name']))
	->setFileDownloadURI($file->getDownloadURI())
	->setFileViewURI($file->getBestURI())
	->setFileViewable((bool)$options['viewable'])
	->setFileSize(phutil_format_bytes($file->getByteSize()))
	->setFileMonogram($file->getMonogram());
	}

	private function parseDimension($string) {
	$string = trim($string);

	if (preg_match('/^(?:\d*\\.)?\d+%?$/', $string)) {
	return $string;
	}

	return null;
	}

	}
	diff --git a/src/infrastructure/markup/PhabricatorMarkupEngine.php b/src/infrastructure/markup/PhabricatorMarkupEngine.php
	index d897314245..cedd0398e3 100644
	--- a/src/infrastructure/markup/PhabricatorMarkupEngine.php
	+++ b/src/infrastructure/markup/PhabricatorMarkupEngine.php
	@@ -1,743 +1,743 @@
	<?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 extends Phobject {

	private $objects = array();
	private $viewer;
	private $contextObject;
	private $version = 21;
	private $engineCaches = array();
	private $auxiliaryConfig = array();

	private static $engineStack = array();


	/* -( 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() {
	self::$engineStack[] = $this;

	try {
	$result = $this->execute();
	} finally {
	array_pop(self::$engineStack);
	}

	return $result;
	}

	public static function isRenderingEmbeddedContent() {
	// See T13678. This prevents cycles when rendering embedded content that
	// itself has remarkup fields.
	return (count(self::$engineStack) > 1);
	}

	private function execute() {
	$keys = array();
	foreach ($this->objects as $key => $info) {
	if (!isset($info['markup'])) {
	$keys[] = $key;
	}
	}

	if (!$keys) {
	return $this;
	}

	$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);

	foreach ($this->auxiliaryConfig as $aux_key => $aux_value) {
	$engines[$key]->setConfig($aux_key, $aux_value);
	}
	}

	// 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(
	pht(
	"Call %s before using results (key = '%s').",
	'addObject()',
	$key));
	}

	if (!isset($this->objects[$key]['output'])) {
	throw new PhutilInvalidStateException('process');
	}
	}


	/**
	* @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);
	}
	}

	$is_readonly = PhabricatorEnv::isReadOnly();

	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]) && !$is_readonly) {
	// 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;
	}

	public function setAuxiliaryConfig($key, $value) {
	// TODO: This is gross and should be removed. Avoid use.
	$this->auxiliaryConfig[$key] = $value;
	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,
	'uri.same-window' => true,
	'uri.base' => PhabricatorEnv::getURI('/'),
	));
	}


	/**
	* @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 'feed':
	$engine = self::newMarkupEngine(array());
	$engine->setConfig('autoplay.disable', true);
	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(pht('Unknown engine ruleset: %s!', $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']);

	$style_map = id(new PhabricatorDefaultSyntaxStyle())
	->getRemarkupStyleMap();
	$engine->setConfig('phutil.codeblock.style-map', $style_map);

	$engine->setConfig('uri.full', $options['uri.full']);

	if (isset($options['uri.base'])) {
	$engine->setConfig('uri.base', $options['uri.base']);
	}

	if (isset($options['uri.same-window'])) {
	$engine->setConfig('uri.same-window', $options['uri.same-window']);
	}

	$rules = array();
	$rules[] = new PhutilRemarkupEscapeRemarkupRule();
	$rules[] = new PhutilRemarkupEvalRule();
	$rules[] = new PhutilRemarkupMonospaceRule();


	$rules[] = new PhutilRemarkupDocumentLinkRule();
	$rules[] = new PhabricatorNavigationRemarkupRule();
	$rules[] = new PhabricatorKeyboardRemarkupRule();
	$rules[] = new PhabricatorConfigRemarkupRule();

	if ($options['youtube']) {
	$rules[] = new PhabricatorYoutubeRemarkupRule();
	}

	$rules[] = new PhabricatorIconRemarkupRule();
	$rules[] = new PhabricatorEmojiRemarkupRule();
	$rules[] = new PhabricatorHandleRemarkupRule();

	$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();
	$rules[] = new PhutilRemarkupHighlightRule();
	$rules[] = new PhutilRemarkupAnchorRule();

	foreach (self::loadCustomInlineRules() as $rule) {
	$rules[] = clone $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) {
	if ($content_block === null) {
	continue;
	}

	if (!strlen($content_block)) {
	continue;
	}

	$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,
	+ PhabricatorEmbedFileRemarkupRule::KEY_ATTACH_INTENT_FILE_PHIDS,
	array());
	foreach ($phids as $phid) {
	$files[$phid] = $phid;
	}
	}

	return array_values($files);
	}

	public static function summarizeSentence($corpus) {
	$corpus = trim($corpus);
	$blocks = preg_split('/\n+/', $corpus, 2);
	$block = head($blocks);

	$sentences = preg_split(
	'/\b([.?!]+)\B/u',
	$block,
	2,
	PREG_SPLIT_DELIM_CAPTURE);

	if (count($sentences) > 1) {
	$result = $sentences[0].$sentences[1];
	} else {
	$result = head($sentences);
	}

	return id(new PhutilUTF8StringTruncator())
	->setMaximumGlyphs(128)
	->truncateString($result);
	}

	/**
	* 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 PhutilClassMapQuery())
	->setAncestorClass('PhabricatorRemarkupCustomInlineRule')
	->execute();
	}

	private static function loadCustomBlockRules() {
	return id(new PhutilClassMapQuery())
	->setAncestorClass('PhabricatorRemarkupCustomBlockRule')
	->execute();
	}

	public static function digestRemarkupContent($object, $content) {
	$parts = array();
	$parts[] = get_class($object);

	if ($object instanceof PhabricatorLiskDAO) {
	$parts[] = $object->getID();
	}

	$parts[] = $content;

	$message = implode("\n", $parts);

	return PhabricatorHash::digestWithNamedKey($message, 'remarkup');
	}

	}
	diff --git a/src/infrastructure/markup/blockrule/PhutilRemarkupBlockRule.php b/src/infrastructure/markup/blockrule/PhutilRemarkupBlockRule.php
	index feac6cffa9..ac3a308d06 100644
	--- a/src/infrastructure/markup/blockrule/PhutilRemarkupBlockRule.php
	+++ b/src/infrastructure/markup/blockrule/PhutilRemarkupBlockRule.php
	@@ -1,170 +1,178 @@
	<?php

	abstract class PhutilRemarkupBlockRule extends Phobject {

	private $engine;
	private $rules = array();

	/**
	* Determine the order in which blocks execute. Blocks with smaller priority
	* numbers execute sooner than blocks with larger priority numbers. The
	* default priority for blocks is `500`.
	*
	* Priorities are used to disambiguate syntax which can match multiple
	* patterns. For example, ` - Lorem ipsum...` may be a code block or a
	* list.
	*
	* @return int Priority at which this block should execute.
	*/
	public function getPriority() {
	return 500;
	}

	final public function getPriorityVector() {
	return id(new PhutilSortVector())
	->addInt($this->getPriority())
	->addString(get_class($this));
	}

	abstract public function markupText($text, $children);

	/**
	* This will get an array of unparsed lines and return the number of lines
	* from the first array value that it can parse.
	*
	* @param array $lines
	* @param int $cursor
	*
	* @return int
	*/
	abstract public function getMatchingLineCount(array $lines, $cursor);

	protected function didMarkupText() {
	return;
	}

	+ public function willMarkupChildBlocks() {
	+ return;
	+ }
	+
	+ public function didMarkupChildBlocks() {
	+ return;
	+ }
	+
	final public function setEngine(PhutilRemarkupEngine $engine) {
	$this->engine = $engine;
	$this->updateRules();
	return $this;
	}

	final protected function getEngine() {
	return $this->engine;
	}

	public function setMarkupRules(array $rules) {
	assert_instances_of($rules, 'PhutilRemarkupRule');
	$this->rules = $rules;
	$this->updateRules();
	return $this;
	}

	private function updateRules() {
	$engine = $this->getEngine();
	if ($engine) {
	$this->rules = msort($this->rules, 'getPriority');
	foreach ($this->rules as $rule) {
	$rule->setEngine($engine);
	}
	}
	return $this;
	}

	final public function getMarkupRules() {
	return $this->rules;
	}

	final public function postprocess() {
	$this->didMarkupText();
	}

	final protected function applyRules($text) {
	foreach ($this->getMarkupRules() as $rule) {
	$text = $rule->apply($text);
	}
	return $text;
	}

	public function supportsChildBlocks() {
	return false;
	}

	public function extractChildText($text) {
	throw new PhutilMethodNotImplementedException();
	}

	protected function renderRemarkupTable(array $out_rows) {
	assert_instances_of($out_rows, 'array');

	if ($this->getEngine()->isTextMode()) {
	$lengths = array();
	foreach ($out_rows as $r => $row) {
	foreach ($row['content'] as $c => $cell) {
	$text = $this->getEngine()->restoreText($cell['content']);
	$lengths[$c][$r] = phutil_utf8_strlen($text);
	}
	}
	$max_lengths = array_map('max', $lengths);

	$out = array();
	foreach ($out_rows as $r => $row) {
	$headings = false;
	foreach ($row['content'] as $c => $cell) {
	$length = $max_lengths[$c] - $lengths[$c][$r];
	$out[] = '\| '.$cell['content'].str_repeat(' ', $length).' ';
	if ($cell['type'] == 'th') {
	$headings = true;
	}
	}
	$out[] = "\|\n";

	if ($headings) {
	foreach ($row['content'] as $c => $cell) {
	$char = ($cell['type'] == 'th' ? '-' : ' ');
	$out[] = '\| '.str_repeat($char, $max_lengths[$c]).' ';
	}
	$out[] = "\|\n";
	}
	}

	return rtrim(implode('', $out), "\n");
	}

	if ($this->getEngine()->isHTMLMailMode()) {
	$table_attributes = array(
	'style' => 'border-collapse: separate;
	border-spacing: 1px;
	background: #d3d3d3;
	margin: 12px 0;',
	);
	$cell_attributes = array(
	'style' => 'background: #ffffff;
	padding: 3px 6px;',
	);
	} else {
	$table_attributes = array(
	'class' => 'remarkup-table',
	);
	$cell_attributes = array();
	}

	$out = array();
	$out[] = "\n";
	foreach ($out_rows as $row) {
	$cells = array();
	foreach ($row['content'] as $cell) {
	$cells[] = phutil_tag(
	$cell['type'],
	$cell_attributes,
	$cell['content']);
	}
	$out[] = phutil_tag($row['type'], array(), $cells);
	$out[] = "\n";
	}

	$table = phutil_tag('table', $table_attributes, $out);
	return phutil_tag_div('remarkup-table-wrap', $table);
	}

	}
	diff --git a/src/infrastructure/markup/blockrule/PhutilRemarkupQuotedBlockRule.php b/src/infrastructure/markup/blockrule/PhutilRemarkupQuotedBlockRule.php
	index 9f2bd7a297..90c9a2c33a 100644
	--- a/src/infrastructure/markup/blockrule/PhutilRemarkupQuotedBlockRule.php
	+++ b/src/infrastructure/markup/blockrule/PhutilRemarkupQuotedBlockRule.php
	@@ -1,110 +1,126 @@
	<?php

	abstract class PhutilRemarkupQuotedBlockRule
	extends PhutilRemarkupBlockRule {

	final public function supportsChildBlocks() {
	return true;
	}

	+ public function willMarkupChildBlocks() {
	+ $engine = $this->getEngine();
	+
	+ $depth = $engine->getQuoteDepth();
	+ $depth = $depth + 1;
	+ $engine->setQuoteDepth($depth);
	+ }
	+
	+ public function didMarkupChildBlocks() {
	+ $engine = $this->getEngine();
	+
	+ $depth = $engine->getQuoteDepth();
	+ $depth = $depth - 1;
	+ $engine->setQuoteDepth($depth);
	+ }
	+
	final protected function normalizeQuotedBody($text) {
	$text = phutil_split_lines($text, true);
	foreach ($text as $key => $line) {
	$text[$key] = substr($line, 1);
	}

	// If every line in the block is empty or begins with at least one leading
	// space, strip the initial space off each line. When we quote text, we
	// normally add "> " (with a space) to the beginning of each line, which
	// can disrupt some other rules. If the block appears to have this space
	// in front of each line, remove it.

	$strip_space = true;
	foreach ($text as $key => $line) {
	$len = strlen($line);

	if (!$len) {
	// We'll still strip spaces if there are some completely empty
	// lines, they may have just had trailing whitespace trimmed.
	continue;
	}

	// If this line is part of a nested quote block, just ignore it when
	// realigning this quote block. It's either an author attribution
	// line with ">>!", or we'll deal with it in a subrule when processing
	// the nested quote block.
	if ($line[0] == '>') {
	continue;
	}

	if ($line[0] == ' ' \|\| $line[0] == "\n") {
	continue;
	}

	// The first character of this line is something other than a space, so
	// we can't strip spaces.
	$strip_space = false;
	break;
	}

	if ($strip_space) {
	foreach ($text as $key => $line) {
	$len = strlen($line);
	if (!$len) {
	continue;
	}

	if ($line[0] !== ' ') {
	continue;
	}

	$text[$key] = substr($line, 1);
	}
	}

	// Strip leading empty lines.
	foreach ($text as $key => $line) {
	if (!strlen(trim($line))) {
	unset($text[$key]);
	} else {
	break;
	}
	}

	return implode('', $text);
	}

	final protected function getQuotedText($text) {
	$text = rtrim($text, "\n");

	$no_whitespace = array(
	// For readability, we render nested quotes as ">> quack",
	// not "> > quack".
	'>' => true,

	// If the line is empty except for a newline, do not add an
	// unnecessary dangling space.
	"\n" => true,
	);

	$text = phutil_split_lines($text, true);
	foreach ($text as $key => $line) {
	$c = null;
	if (isset($line[0])) {
	$c = $line[0];
	} else {
	$c = null;
	}

	if (isset($no_whitespace[$c])) {
	$text[$key] = '>'.$line;
	} else {
	$text[$key] = '> '.$line;
	}
	}
	$text = implode('', $text);

	return $text;
	}

	}
	diff --git a/src/infrastructure/markup/remarkup/PhutilRemarkupEngine.php b/src/infrastructure/markup/remarkup/PhutilRemarkupEngine.php
	index a0a379aaf9..bedbf0bab7 100644
	--- a/src/infrastructure/markup/remarkup/PhutilRemarkupEngine.php
	+++ b/src/infrastructure/markup/remarkup/PhutilRemarkupEngine.php
	@@ -1,357 +1,371 @@
	<?php

	final class PhutilRemarkupEngine extends PhutilMarkupEngine {

	const MODE_DEFAULT = 0;
	const MODE_TEXT = 1;
	const MODE_HTML_MAIL = 2;

	const MAX_CHILD_DEPTH = 32;

	private $blockRules = array();
	private $config = array();
	private $mode;
	private $metadata = array();
	private $states = array();
	private $postprocessRules = array();
	private $storage;

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

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

	public function setMode($mode) {
	$this->mode = $mode;
	return $this;
	}

	public function isTextMode() {
	return $this->mode & self::MODE_TEXT;
	}

	public function isAnchorMode() {
	return $this->getState('toc');
	}

	public function isHTMLMailMode() {
	return $this->mode & self::MODE_HTML_MAIL;
	}

	+ public function getQuoteDepth() {
	+ return $this->getConfig('runtime.quote.depth', 0);
	+ }
	+
	+ public function setQuoteDepth($depth) {
	+ return $this->setConfig('runtime.quote.depth', $depth);
	+ }
	+
	public function setBlockRules(array $rules) {
	assert_instances_of($rules, 'PhutilRemarkupBlockRule');

	$rules = msortv($rules, 'getPriorityVector');

	$this->blockRules = $rules;
	foreach ($this->blockRules as $rule) {
	$rule->setEngine($this);
	}

	$post_rules = array();
	foreach ($this->blockRules as $block_rule) {
	foreach ($block_rule->getMarkupRules() as $rule) {
	$key = $rule->getPostprocessKey();
	if ($key !== null) {
	$post_rules[$key] = $rule;
	}
	}
	}

	$this->postprocessRules = $post_rules;

	return $this;
	}

	public function getTextMetadata($key, $default = null) {
	if (isset($this->metadata[$key])) {
	return $this->metadata[$key];
	}
	return idx($this->metadata, $key, $default);
	}

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

	public function storeText($text) {
	if ($this->isTextMode()) {
	$text = phutil_safe_html($text);
	}
	return $this->storage->store($text);
	}

	public function overwriteStoredText($token, $new_text) {
	if ($this->isTextMode()) {
	$new_text = phutil_safe_html($new_text);
	}
	$this->storage->overwrite($token, $new_text);
	return $this;
	}

	public function markupText($text) {
	return $this->postprocessText($this->preprocessText($text));
	}

	public function pushState($state) {
	if (empty($this->states[$state])) {
	$this->states[$state] = 0;
	}
	$this->states[$state]++;
	return $this;
	}

	public function popState($state) {
	if (empty($this->states[$state])) {
	throw new Exception(pht("State '%s' pushed more than popped!", $state));
	}
	$this->states[$state]--;
	if (!$this->states[$state]) {
	unset($this->states[$state]);
	}
	return $this;
	}

	public function getState($state) {
	return !empty($this->states[$state]);
	}

	public function preprocessText($text) {
	$this->metadata = array();
	$this->storage = new PhutilRemarkupBlockStorage();

	$blocks = $this->splitTextIntoBlocks($text);

	$output = array();
	foreach ($blocks as $block) {
	$output[] = $this->markupBlock($block);
	}
	$output = $this->flattenOutput($output);

	$map = $this->storage->getMap();
	$this->storage = null;
	$metadata = $this->metadata;


	return array(
	'output' => $output,
	'storage' => $map,
	'metadata' => $metadata,
	);
	}

	private function splitTextIntoBlocks($text, $depth = 0) {
	// Apply basic block and paragraph normalization to the text. NOTE: We don't
	// strip trailing whitespace because it is semantic in some contexts,
	// notably inlined diffs that the author intends to show as a code block.
	$text = phutil_split_lines($text, true);
	$block_rules = $this->blockRules;
	$blocks = array();
	$cursor = 0;

	$can_merge = array();
	foreach ($block_rules as $key => $block_rule) {
	if ($block_rule instanceof PhutilRemarkupDefaultBlockRule) {
	$can_merge[$key] = true;
	}
	}

	$last_block = null;
	$last_block_key = -1;

	// See T13487. For very large inputs, block separation can dominate
	// runtime. This is written somewhat clumsily to attempt to handle
	// very large inputs as gracefully as is practical.

	while (isset($text[$cursor])) {
	$starting_cursor = $cursor;
	foreach ($block_rules as $block_key => $block_rule) {
	$num_lines = $block_rule->getMatchingLineCount($text, $cursor);

	if ($num_lines) {
	$current_block = array(
	'start' => $cursor,
	'num_lines' => $num_lines,
	'rule' => $block_rule,
	'empty' => self::isEmptyBlock($text, $cursor, $num_lines),
	'children' => array(),
	'merge' => isset($can_merge[$block_key]),
	);

	$should_merge = self::shouldMergeParagraphBlocks(
	$text,
	$last_block,
	$current_block);

	if ($should_merge) {
	$last_block['num_lines'] =
	($last_block['num_lines'] + $current_block['num_lines']);

	$last_block['empty'] =
	($last_block['empty'] && $current_block['empty']);

	$blocks[$last_block_key] = $last_block;
	} else {
	$blocks[] = $current_block;

	$last_block = $current_block;
	$last_block_key++;
	}

	$cursor += $num_lines;

	break;
	}
	}

	if ($starting_cursor === $cursor) {
	throw new Exception(pht('Block in text did not match any block rule.'));
	}
	}

	// See T13487. It's common for blocks to be small, and this loop seems to
	// measure as faster if we manually concatenate blocks than if we
	// "array_slice()" and "implode()" blocks. This is a bit muddy.

	foreach ($blocks as $key => $block) {
	$min = $block['start'];
	$max = $min + $block['num_lines'];

	$lines = '';
	for ($ii = $min; $ii < $max; $ii++) {
	$lines .= $text[$ii];
	}

	$blocks[$key]['text'] = $lines;
	}

	// Stop splitting child blocks apart if we get too deep. This arrests
	// any blocks which have looping child rules, and stops the stack from
	// exploding if someone writes a hilarious comment with 5,000 levels of
	// quoted text.

	if ($depth < self::MAX_CHILD_DEPTH) {
	foreach ($blocks as $key => $block) {
	$rule = $block['rule'];
	if (!$rule->supportsChildBlocks()) {
	continue;
	}

	list($parent_text, $child_text) = $rule->extractChildText(
	$block['text']);
	$blocks[$key]['text'] = $parent_text;
	$blocks[$key]['children'] = $this->splitTextIntoBlocks(
	$child_text,
	$depth + 1);
	}
	}

	return $blocks;
	}

	private function markupBlock(array $block) {
	+ $rule = $block['rule'];
	+
	+ $rule->willMarkupChildBlocks();
	+
	$children = array();
	foreach ($block['children'] as $child) {
	$children[] = $this->markupBlock($child);
	}

	+ $rule->didMarkupChildBlocks();
	+
	if ($children) {
	$children = $this->flattenOutput($children);
	} else {
	$children = null;
	}

	- return $block['rule']->markupText($block['text'], $children);
	+ return $rule->markupText($block['text'], $children);
	}

	private function flattenOutput(array $output) {
	if ($this->isTextMode()) {
	$output = implode("\n\n", $output)."\n";
	} else {
	$output = phutil_implode_html("\n\n", $output);
	}

	return $output;
	}

	private static function shouldMergeParagraphBlocks(
	$text,
	$last_block,
	$current_block) {

	// If we're at the beginning of the input, we can't merge.
	if ($last_block === null) {
	return false;
	}

	// If the previous block wasn't a default block, we can't merge.
	if (!$last_block['merge']) {
	return false;
	}

	// If the current block isn't a default block, we can't merge.
	if (!$current_block['merge']) {
	return false;
	}

	// If the last block was empty, we definitely want to merge.
	if ($last_block['empty']) {
	return true;
	}

	// If this block is empty, we definitely want to merge.
	if ($current_block['empty']) {
	return true;
	}

	// Check if the last line of the previous block or the first line of this
	// block have any non-whitespace text. If they both do, we're going to
	// merge.

	// If either of them are a blank line or a line with only whitespace, we
	// do not merge: this means we've found a paragraph break.

	$tail = $text[$current_block['start'] - 1];
	$head = $text[$current_block['start']];
	if (strlen(trim($tail)) && strlen(trim($head))) {
	return true;
	}

	return false;
	}

	private static function isEmptyBlock($text, $start, $num_lines) {
	for ($cursor = $start; $cursor < $start + $num_lines; $cursor++) {
	if (strlen(trim($text[$cursor]))) {
	return false;
	}
	}
	return true;
	}

	public function postprocessText(array $dict) {
	$this->metadata = idx($dict, 'metadata', array());

	$this->storage = new PhutilRemarkupBlockStorage();
	$this->storage->setMap(idx($dict, 'storage', array()));

	foreach ($this->blockRules as $block_rule) {
	$block_rule->postprocess();
	}

	foreach ($this->postprocessRules as $rule) {
	$rule->didMarkupText();
	}

	return $this->restoreText(idx($dict, 'output'));
	}

	public function restoreText($text) {
	return $this->storage->restore($text, $this->isTextMode());
	}
	}
	diff --git a/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php b/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php
	index 5ab033d6b1..b0399527b0 100644
	--- a/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php
	+++ b/src/infrastructure/markup/rule/PhabricatorObjectRemarkupRule.php
	@@ -1,430 +1,432 @@
	<?php

	abstract class PhabricatorObjectRemarkupRule extends PhutilRemarkupRule {

	private $referencePattern;
	private $embedPattern;

	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 getObjectNameText(
	$object,
	PhabricatorObjectHandle $handle,
	$id) {
	return $this->getObjectNamePrefix().$id;
	}

	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) {

	$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->getObjectNameText($object, $handle, $id);

	if ($anchor) {
	$href = $href.'#'.$anchor;
	$text = $text.'#'.$anchor;
	}

	if ($this->getEngine()->isTextMode()) {
	return $text.' <'.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->getObjectNameText($object, $handle, $id);
	$status_closed = PhabricatorObjectHandle::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);
	}

	// See T13678. If we're already rendering embedded content, render a
	// default reference instead to avoid cycles.
	if (PhabricatorMarkupEngine::isRenderingEmbeddedContent()) {
	return $this->renderDefaultObjectEmbed($object, $handle);
	}

	return $this->renderObjectEmbed($object, $handle, $options);
	}

	protected function renderObjectEmbed(
	$object,
	PhabricatorObjectHandle $handle,
	$options) {
	return $this->renderDefaultObjectEmbed($object, $handle);
	}

	final protected function renderDefaultObjectEmbed(
	$object,
	PhabricatorObjectHandle $handle) {

	$name = $handle->getFullName();
	$href = $handle->getURI();
	$status_closed = PhabricatorObjectHandle::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 = PhabricatorObjectHandle::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() {
	if ($this->embedPattern === null) {
	$prefix = $this->getObjectNamePrefix();
	$prefix = preg_quote($prefix);
	$id = $this->getObjectIDPattern();

	$this->embedPattern =
	'(\B{'.$prefix.'('.$id.')([,\s](?:[^}\\\\]\|\\\\.)*)?}\B)u';
	}

	return $this->embedPattern;
	}

	private function getObjectReferencePattern() {
	if ($this->referencePattern === null) {
	$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), and from matching "@T1" as a task (it is a user)
	// (see T9479).

	// The "\b" allows us to link "(abcdef)" or similar without linking things
	// in the middle of words.

	$this->referencePattern =
	'((?<![#@-])'.$boundary.$prefix.'('.$id.')(?:#([-\w\d]+))?(?!\w))u';
	}

	return $this->referencePattern;
	}


	/**
	* 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];
	}

	// If we're rendering a table of contents, just render the raw input.
	// This could perhaps be handled more gracefully but it seems unusual to
	// put something like "{P123}" in a header and it's not obvious what users
	// expect? See T8845.
	$engine = $this->getEngine();
	if ($engine->getState('toc')) {
	return $matches[0];
	}

	return $this->markupObject(array(
	'type' => 'embed',
	'id' => $matches[1],
	'options' => idx($matches, 2),
	'original' => $matches[0],
	+ 'quote.depth' => $engine->getQuoteDepth(),
	));
	}

	public function markupObjectReference(array $matches) {
	if (!$this->isFlatText($matches[0])) {
	return $matches[0];
	}

	// If we're rendering a table of contents, just render the monogram.
	$engine = $this->getEngine();
	if ($engine->getState('toc')) {
	return $matches[0];
	}

	return $this->markupObject(array(
	'type' => 'ref',
	'id' => $matches[1],
	'anchor' => idx($matches, 2),
	'original' => $matches[0],
	+ 'quote.depth' => $engine->getQuoteDepth(),
	));
	}

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

	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 20, 5:05 AM (1 d, 2 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 241450
Default Alt Text: (63 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions