No OneTemporary
Actions

Size

42 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/feed/story/PhabricatorFeedStory.php b/src/applications/feed/story/PhabricatorFeedStory.php
	index 8a15301216..c3984573c7 100644
	--- a/src/applications/feed/story/PhabricatorFeedStory.php
	+++ b/src/applications/feed/story/PhabricatorFeedStory.php
	@@ -1,483 +1,483 @@
	<?php

	/**
	* Manages rendering and aggregation of a story. A story is an event (like a
	* user adding a comment) which may be represented in different forms on
	* different channels (like feed, notifications and realtime alerts).
	*
	* @task load Loading Stories
	* @task policy Policy Implementation
	*/
	abstract class PhabricatorFeedStory
	extends Phobject
	implements
	PhabricatorPolicyInterface,
	PhabricatorMarkupInterface {

	private $data;
	private $hasViewed;
	private $hovercard = false;
	private $renderingTarget = PhabricatorApplicationTransaction::TARGET_HTML;

	private $handles = array();
	private $objects = array();
	private $projectPHIDs = array();
	private $markupFieldOutput = array();

	/* -( Loading Stories )---------------------------------------------------- */


	/**
	* Given @{class:PhabricatorFeedStoryData} rows, load them into objects and
	* construct appropriate @{class:PhabricatorFeedStory} wrappers for each
	* data row.
	*
	* @param list<dict> List of @{class:PhabricatorFeedStoryData} rows from the
	* database.
	* @return list<PhabricatorFeedStory> List of @{class:PhabricatorFeedStory}
	* objects.
	* @task load
	*/
	public static function loadAllFromRows(array $rows, PhabricatorUser $viewer) {
	$stories = array();

	$data = id(new PhabricatorFeedStoryData())->loadAllFromArray($rows);
	foreach ($data as $story_data) {
	$class = $story_data->getStoryType();

	try {
	$ok =
	class_exists($class) &&
	is_subclass_of($class, __CLASS__);
	} catch (PhutilMissingSymbolException $ex) {
	$ok = false;
	}

	// If the story type isn't a valid class or isn't a subclass of
	// PhabricatorFeedStory, decline to load it.
	if (!$ok) {
	continue;
	}

	$key = $story_data->getChronologicalKey();
	$stories[$key] = newv($class, array($story_data));
	}

	$object_phids = array();
	$key_phids = array();
	foreach ($stories as $key => $story) {
	$phids = array();
	foreach ($story->getRequiredObjectPHIDs() as $phid) {
	$phids[$phid] = true;
	}
	if ($story->getPrimaryObjectPHID()) {
	$phids[$story->getPrimaryObjectPHID()] = true;
	}
	$key_phids[$key] = $phids;
	$object_phids += $phids;
	}

	$object_query = id(new PhabricatorObjectQuery())
	->setViewer($viewer)
	->withPHIDs(array_keys($object_phids));

	$objects = $object_query->execute();

	foreach ($key_phids as $key => $phids) {
	if (!$phids) {
	continue;
	}
	$story_objects = array_select_keys($objects, array_keys($phids));
	if (count($story_objects) != count($phids)) {
	// An object this story requires either does not exist or is not visible
	// to the user. Decline to render the story.
	unset($stories[$key]);
	unset($key_phids[$key]);
	continue;
	}

	$stories[$key]->setObjects($story_objects);
	}

	// If stories are about PhabricatorProjectInterface objects, load the
	// projects the objects are a part of so we can render project tags
	// on the stories.

	$project_phids = array();
	foreach ($objects as $object) {
	if ($object instanceof PhabricatorProjectInterface) {
	$project_phids[$object->getPHID()] = array();
	}
	}

	if ($project_phids) {
	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(array_keys($project_phids))
	->withEdgeTypes(
	array(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	));
	$edge_query->execute();
	foreach ($project_phids as $phid => $ignored) {
	$project_phids[$phid] = $edge_query->getDestinationPHIDs(array($phid));
	}
	}

	$handle_phids = array();
	foreach ($stories as $key => $story) {
	foreach ($story->getRequiredHandlePHIDs() as $phid) {
	$key_phids[$key][$phid] = true;
	}
	if ($story->getAuthorPHID()) {
	$key_phids[$key][$story->getAuthorPHID()] = true;
	}

	$object_phid = $story->getPrimaryObjectPHID();
	$object_project_phids = idx($project_phids, $object_phid, array());
	$story->setProjectPHIDs($object_project_phids);
	foreach ($object_project_phids as $dst) {
	$key_phids[$key][$dst] = true;
	}

	$handle_phids += $key_phids[$key];
	}

	// NOTE: This setParentQuery() is a little sketchy. Ideally, this whole
	// method should be inside FeedQuery and it should be the parent query of
	// both subqueries. We're just trying to share the workspace cache.

	$handles = id(new PhabricatorHandleQuery())
	->setViewer($viewer)
	->setParentQuery($object_query)
	->withPHIDs(array_keys($handle_phids))
	->execute();

	foreach ($key_phids as $key => $phids) {
	if (!$phids) {
	continue;
	}
	$story_handles = array_select_keys($handles, array_keys($phids));
	$stories[$key]->setHandles($story_handles);
	}

	// Load and process story markup blocks.

	$engine = new PhabricatorMarkupEngine();
	$engine->setViewer($viewer);
	foreach ($stories as $story) {
	foreach ($story->getFieldStoryMarkupFields() as $field) {
	$engine->addObject($story, $field);
	}
	}

	$engine->process();

	foreach ($stories as $story) {
	foreach ($story->getFieldStoryMarkupFields() as $field) {
	$story->setMarkupFieldOutput(
	$field,
	$engine->getOutput($story, $field));
	}
	}

	return $stories;
	}

	public function setMarkupFieldOutput($field, $output) {
	$this->markupFieldOutput[$field] = $output;
	return $this;
	}

	public function getMarkupFieldOutput($field) {
	if (!array_key_exists($field, $this->markupFieldOutput)) {
	throw new Exception(
	pht(
	'Trying to retrieve markup field key "%s", but this feed story '.
	'did not request it be rendered.',
	$field));
	}

	return $this->markupFieldOutput[$field];
	}

	public function setHovercard($hover) {
	$this->hovercard = $hover;
	return $this;
	}

	public function setRenderingTarget($target) {
	$this->validateRenderingTarget($target);
	$this->renderingTarget = $target;
	return $this;
	}

	public function getRenderingTarget() {
	return $this->renderingTarget;
	}

	private function validateRenderingTarget($target) {
	switch ($target) {
	case PhabricatorApplicationTransaction::TARGET_HTML:
	case PhabricatorApplicationTransaction::TARGET_TEXT:
	break;
	default:
	throw new Exception(pht('Unknown rendering target: %s', $target));
	break;
	}
	}

	public function setObjects(array $objects) {
	$this->objects = $objects;
	return $this;
	}

	public function getObject($phid) {
	$object = idx($this->objects, $phid);
	if (!$object) {
	throw new Exception(
	pht(
	"Story is asking for an object it did not request ('%s')!",
	$phid));
	}
	return $object;
	}

	public function getPrimaryObject() {
	$phid = $this->getPrimaryObjectPHID();
	if (!$phid) {
	throw new Exception(pht('Story has no primary object!'));
	}
	return $this->getObject($phid);
	}

	public function getPrimaryObjectPHID() {
	return null;
	}

	final public function __construct(PhabricatorFeedStoryData $data) {
	$this->data = $data;
	}

	abstract public function renderView();
	public function renderAsTextForDoorkeeper(
	DoorkeeperFeedStoryPublisher $publisher) {

	// TODO: This (and text rendering) should be properly abstract and
	// universal. However, this is far less bad than it used to be, and we
	// need to clean up more old feed code to really make this reasonable.

	return pht(
	'(Unable to render story of class %s for Doorkeeper.)',
	get_class($this));
	}

	public function getRequiredHandlePHIDs() {
	return array();
	}

	public function getRequiredObjectPHIDs() {
	return array();
	}

	public function setHasViewed($has_viewed) {
	$this->hasViewed = $has_viewed;
	return $this;
	}

	public function getHasViewed() {
	return $this->hasViewed;
	}

	final public function setHandles(array $handles) {
	assert_instances_of($handles, 'PhabricatorObjectHandle');
	$this->handles = $handles;
	return $this;
	}

	final protected function getObjects() {
	return $this->objects;
	}

	final protected function getHandles() {
	return $this->handles;
	}

	final protected function getHandle($phid) {
	if (isset($this->handles[$phid])) {
	if ($this->handles[$phid] instanceof PhabricatorObjectHandle) {
	return $this->handles[$phid];
	}
	}

	$handle = new PhabricatorObjectHandle();
	$handle->setPHID($phid);
	$handle->setName(pht("Unloaded Object '%s'", $phid));

	return $handle;
	}

	final public function getStoryData() {
	return $this->data;
	}

	final public function getEpoch() {
	return $this->getStoryData()->getEpoch();
	}

	final public function getChronologicalKey() {
	return $this->getStoryData()->getChronologicalKey();
	}

	final public function getValue($key, $default = null) {
	return $this->getStoryData()->getValue($key, $default);
	}

	final public function getAuthorPHID() {
	return $this->getStoryData()->getAuthorPHID();
	}

	final protected function renderHandleList(array $phids) {
	$items = array();
	foreach ($phids as $phid) {
	$items[] = $this->linkTo($phid);
	}
	$list = null;
	switch ($this->getRenderingTarget()) {
	case PhabricatorApplicationTransaction::TARGET_TEXT:
	$list = implode(', ', $items);
	break;
	case PhabricatorApplicationTransaction::TARGET_HTML:
	$list = phutil_implode_html(', ', $items);
	break;
	}
	return $list;
	}

	final protected function linkTo($phid) {
	$handle = $this->getHandle($phid);

	switch ($this->getRenderingTarget()) {
	case PhabricatorApplicationTransaction::TARGET_TEXT:
	return $handle->getLinkName();
	}

	return $handle->renderLink();
	}

	final protected function renderString($str) {
	switch ($this->getRenderingTarget()) {
	case PhabricatorApplicationTransaction::TARGET_TEXT:
	return $str;
	case PhabricatorApplicationTransaction::TARGET_HTML:
	return phutil_tag('strong', array(), $str);
	}
	}

	final public function renderSummary($text, $len = 128) {
	if ($len) {
	$text = id(new PhutilUTF8StringTruncator())
	->setMaximumGlyphs($len)
	->truncateString($text);
	}
	switch ($this->getRenderingTarget()) {
	case PhabricatorApplicationTransaction::TARGET_HTML:
	$text = phutil_escape_html_newlines($text);
	break;
	}
	return $text;
	}

	public function getNotificationAggregations() {
	return array();
	}

	protected function newStoryView() {
	$view = id(new PHUIFeedStoryView())
	->setChronologicalKey($this->getChronologicalKey())
	->setEpoch($this->getEpoch())
	->setViewed($this->getHasViewed());

	$project_phids = $this->getProjectPHIDs();
	if ($project_phids) {
	$view->setTags($this->renderHandleList($project_phids));
	}

	return $view;
	}

	public function setProjectPHIDs(array $phids) {
	$this->projectPHIDs = $phids;
	return $this;
	}

	public function getProjectPHIDs() {
	return $this->projectPHIDs;
	}

	public function getFieldStoryMarkupFields() {
	return array();
	}


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

	public function getPHID() {
	return null;
	}

	/**
	* @task policy
	*/
	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}


	/**
	* @task policy
	*/
	public function getPolicy($capability) {
	// NOTE: We enforce that a user can see all the objects a story is about
	// when loading it, so we don't need to perform a equivalent secondary
	// policy check later.
	return PhabricatorPolicies::getMostOpenPolicy();
	}


	/**
	* @task policy
	*/
	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return false;
	}


	/* -( PhabricatorMarkupInterface Implementation )--------------------------- */


	public function getMarkupFieldKey($field) {
	return 'feed:'.$this->getChronologicalKey().':'.$field;
	}

	public function newMarkupEngine($field) {
	- return PhabricatorMarkupEngine::getEngine();
	+ return PhabricatorMarkupEngine::getEngine('feed');
	}

	public function getMarkupText($field) {
	throw new PhutilMethodNotImplementedException();
	}

	public function didMarkupText(
	$field,
	$output,
	PhutilMarkupEngine $engine) {
	return $output;
	}

	public function shouldUseMarkupCache($field) {
	return true;
	}

	}
	diff --git a/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php b/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php
	index 0fb2243d89..e054c2acd9 100644
	--- a/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php
	+++ b/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php
	@@ -1,297 +1,303 @@
	<?php

	final class PhabricatorEmbedFileRemarkupRule
	extends PhabricatorObjectRemarkupRule {

	const KEY_EMBED_FILE_PHIDS = 'phabricator.embedded-file-phids';

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

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

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

	$phids_key = self::KEY_EMBED_FILE_PHIDS;
	$phids = $engine->getTextMetadata($phids_key, array());
	foreach (mpull($objects, 'getPHID') as $phid) {
	$phids[] = $phid;
	}
	$engine->setTextMetadata($phids_key, $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();
	} 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;
	}
	}

	if (isset($options['alt'])) {
	$attrs['alt'] = $options['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(),
	'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;
	+ }
	+
	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' => $file->getMimeType(),
	)));
	}

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

	return id(new PhabricatorFileLinkView())
	->setFilePHID($file->getPHID())
	->setFileName($this->assertFlatText($options['name']))
	->setFileDownloadURI($file->getDownloadURI())
	->setFileViewURI($file->getBestURI())
	->setFileViewable((bool)$options['viewable'])
	->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 6f13525c76..3ce5578f82 100644
	--- a/src/infrastructure/markup/PhabricatorMarkupEngine.php
	+++ b/src/infrastructure/markup/PhabricatorMarkupEngine.php
	@@ -1,693 +1,697 @@
	<?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 = 16;
	private $engineCaches = array();
	private $auxiliaryConfig = 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() {
	$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);

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


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

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

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

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

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 1, 8:32 AM (1 d, 6 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 430309
Default Alt Text: (42 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions