No OneTemporary
Actions

Size

56 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/search/engine/PhabricatorSearchEngineAPIMethod.php b/src/applications/search/engine/PhabricatorSearchEngineAPIMethod.php
	index f0e4f02672..7757e27d68 100644
	--- a/src/applications/search/engine/PhabricatorSearchEngineAPIMethod.php
	+++ b/src/applications/search/engine/PhabricatorSearchEngineAPIMethod.php
	@@ -1,605 +1,610 @@
	<?php

	abstract class PhabricatorSearchEngineAPIMethod
	extends ConduitAPIMethod {

	abstract public function newSearchEngine();

	final public function getQueryMaps($query) {
	$maps = $this->getCustomQueryMaps($query);

	// Make sure we emit empty maps as objects, not lists.
	foreach ($maps as $key => $map) {
	if (!$map) {
	$maps[$key] = (object)$map;
	}
	}

	if (!$maps) {
	$maps = (object)$maps;
	}

	return $maps;
	}

	protected function getCustomQueryMaps($query) {
	return array();
	}

	public function getApplication() {
	$engine = $this->newSearchEngine();
	$class = $engine->getApplicationClassName();
	return PhabricatorApplication::getByClass($class);
	}

	public function getMethodStatus() {
	return self::METHOD_STATUS_UNSTABLE;
	}

	public function getMethodStatusDescription() {
	return pht(
	'ApplicationSearch methods are fairly stable, but were introduced '.
	'relatively recently and may continue to evolve as more applications '.
	'adopt them.');
	}

	final protected function defineParamTypes() {
	return array(
	'queryKey' => 'optional string',
	'constraints' => 'optional map<string, wild>',
	'attachments' => 'optional map<string, bool>',
	'order' => 'optional order',
	) + $this->getPagerParamTypes();
	}

	final protected function defineReturnType() {
	return 'map<string, wild>';
	}

	final protected function execute(ConduitAPIRequest $request) {
	$engine = $this->newSearchEngine()
	->setViewer($request->getUser());

	return $engine->buildConduitResponse($request, $this);
	}

	final public function getMethodDescription() {
	return pht(
	'This is a standard ApplicationSearch method which will let you '.
	'list, query, or search for objects. For documentation on these '.
	'endpoints, see [[ %s \| Conduit API: Using Search Endpoints ]].',
	PhabricatorEnv::getDoclink('Conduit API: Using Edit Endpoints'));
	}

	final public function getMethodDocumentation() {
	$viewer = $this->getViewer();

	$engine = $this->newSearchEngine()
	->setViewer($viewer);

	$query = $engine->newQuery();

	$out = array();

	$out[] = $this->buildQueriesBox($engine);
	$out[] = $this->buildConstraintsBox($engine);
	$out[] = $this->buildOrderBox($engine, $query);
	$out[] = $this->buildFieldsBox($engine);
	$out[] = $this->buildAttachmentsBox($engine);
	$out[] = $this->buildPagingBox($engine);

	return $out;
	}

	private function buildQueriesBox(
	PhabricatorApplicationSearchEngine $engine) {
	$viewer = $this->getViewer();

	$info = pht(<<<EOTEXT
	You can choose a builtin or saved query as a starting point for filtering
	results by selecting it with `queryKey`. If you don't specify a `queryKey`,
	the query will start with no constraints.

	For example, many applications have builtin queries like `"active"` or
	`"open"` to find only active or enabled results. To use a `queryKey`, specify
	it like this:

	```lang=json, name="Selecting a Builtin Query"
	{
	...
	"queryKey": "active",
	...
	}
	```

	The table below shows the keys to use to select builtin queries and your
	saved queries, but you can also use any query you run via the web UI as a
	starting point. You can find the key for a query by examining the URI after
	running a normal search.

	You can use these keys to select builtin queries and your configured saved
	queries:
	EOTEXT
	);

	$named_queries = $engine->loadAllNamedQueries();

	$rows = array();
	foreach ($named_queries as $named_query) {
	$builtin = $named_query->getIsBuiltin()
	? pht('Builtin')
	: pht('Custom');

	$rows[] = array(
	$named_query->getQueryKey(),
	$named_query->getQueryName(),
	$builtin,
	);
	}

	$table = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	pht('Query Key'),
	pht('Name'),
	pht('Builtin'),
	))
	->setColumnClasses(
	array(
	'prewrap',
	'pri wide',
	null,
	));

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Builtin and Saved Queries'))
	->setCollapsed(true)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($this->buildRemarkup($info))
	->appendChild($table);
	}

	private function buildConstraintsBox(
	PhabricatorApplicationSearchEngine $engine) {

	$info = pht(<<<EOTEXT
	You can apply custom constraints by passing a dictionary in `constraints`.
	This will let you search for specific sets of results (for example, you may
	want show only results with a certain state, status, or owner).


	If you specify both a `queryKey` and `constraints`, the builtin or saved query
	will be applied first as a starting point, then any additional values in
	`constraints` will be applied, overwriting the defaults from the original query.

	Specify constraints like this:

	```lang=json, name="Example Custom Constraints"
	{
	...
	"constraints": {
	"authors": ["PHID-USER-1111", "PHID-USER-2222"],
	"statuses": ["open", "closed"],
	...
	},
	...
	}
	```

	This API endpoint supports these constraints:
	EOTEXT
	);

	$fields = $engine->getSearchFieldsForConduit();

	// As a convenience, put these fields at the very top, even if the engine
	// specifies and alternate display order for the web UI. These fields are
	// very important in the API and nearly useless in the web UI.
	$fields = array_select_keys(
	$fields,
	array('ids', 'phids')) + $fields;

	$rows = array();
	foreach ($fields as $field) {
	$key = $field->getConduitKey();
	$label = $field->getLabel();

	$type_object = $field->getConduitParameterType();
	if ($type_object) {
	$type = $type_object->getTypeName();
	$description = $field->getDescription();
	} else {
	$type = null;
	$description = phutil_tag('em', array(), pht('Not supported.'));
	}

	$rows[] = array(
	$key,
	$label,
	$type,
	$description,
	);
	}

	$table = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	pht('Key'),
	pht('Label'),
	pht('Type'),
	pht('Description'),
	))
	->setColumnClasses(
	array(
	'prewrap',
	'pri',
	'prewrap',
	'wide',
	));

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Custom Query Constraints'))
	->setCollapsed(true)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($this->buildRemarkup($info))
	->appendChild($table);
	}

	private function buildOrderBox(
	PhabricatorApplicationSearchEngine $engine,
	$query) {

	$orders_info = pht(<<<EOTEXT
	Use `order` to choose an ordering for the results.

	Either specify a single key from the builtin orders (these are a set of
	meaningful, high-level, human-readable orders) or specify a custom list of
	low-level columns.

	To use a high-level order, choose a builtin order from the table below
	and specify it like this:

	```lang=json, name="Choosing a Result Order"
	{
	...
	"order": "newest",
	...
	}
	```

	These builtin orders are available:
	EOTEXT
	);

	$orders = $query->getBuiltinOrders();

	$rows = array();
	foreach ($orders as $key => $order) {
	$rows[] = array(
	$key,
	$order['name'],
	implode(', ', $order['vector']),
	);
	}

	$orders_table = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	pht('Key'),
	pht('Description'),
	pht('Columns'),
	))
	->setColumnClasses(
	array(
	'pri',
	'',
	'wide',
	));

	$columns_info = pht(<<<EOTEXT
	You can choose a low-level column order instead. To do this, provide a list
	of columns instead of a single key. This is an advanced feature.

	In a custom column order:

	- each column may only be specified once;
	- each column may be prefixed with `-` to invert the order;
	- the last column must be a unique column, usually `id`; and
	- no column other than the last may be unique.

	To use a low-level order, choose a sequence of columns and specify them like
	this:

	```lang=json, name="Using a Custom Order"
	{
	...
	"order": ["color", "-name", "id"],
	...
	}
	```

	These low-level columns are available:
	EOTEXT
	);

	$columns = $query->getOrderableColumns();
	$rows = array();
	foreach ($columns as $key => $column) {
	$rows[] = array(
	$key,
	idx($column, 'unique') ? pht('Yes') : pht('No'),
	);
	}

	$columns_table = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	pht('Key'),
	pht('Unique'),
	))
	->setColumnClasses(
	array(
	'pri',
	'wide',
	));


	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Result Ordering'))
	->setCollapsed(true)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($this->buildRemarkup($orders_info))
	->appendChild($orders_table)
	->appendChild($this->buildRemarkup($columns_info))
	->appendChild($columns_table);
	}

	private function buildFieldsBox(
	PhabricatorApplicationSearchEngine $engine) {

	$info = pht(<<<EOTEXT
	Objects matching your query are returned as a list of dictionaries in the
	`data` property of the results. Each dictionary has some metadata and a
	`fields` key, which contains the information abou the object that most callers
	will be interested in.

	For example, the results may look something like this:

	```lang=json, name="Example Results"
	{
	...
	"data": [
	{
	"id": 123,
	"phid": "PHID-WXYZ-1111",
	"fields": {
	"name": "First Example Object",
	"authorPHID": "PHID-USER-2222"
	}
	},
	{
	"id": 124,
	"phid": "PHID-WXYZ-3333",
	"fields": {
	"name": "Second Example Object",
	"authorPHID": "PHID-USER-4444"
	}
	},
	...
	]
	...
	}
	```

	This result structure is standardized across all search methods, but the
	available fields differ from application to application.

	These are the fields available on this object type:
	EOTEXT
	);

	$specs = $engine->getAllConduitFieldSpecifications();

	$rows = array();
	foreach ($specs as $key => $spec) {
	$type = $spec->getType();
	$description = $spec->getDescription();
	$rows[] = array(
	$key,
	$type,
	$description,
	);
	}

	$table = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	pht('Key'),
	pht('Type'),
	pht('Description'),
	))
	->setColumnClasses(
	array(
	'pri',
	'mono',
	'wide',
	));

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Object Fields'))
	->setCollapsed(true)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($this->buildRemarkup($info))
	->appendChild($table);
	}

	private function buildAttachmentsBox(
	PhabricatorApplicationSearchEngine $engine) {

	$info = pht(<<<EOTEXT
	By default, only basic information about objects is returned. If you want
	more extensive information, you can use available `attachments` to get more
	information in the results (like subscribers and projects).

	Generally, requesting more information means the query executes more slowly
	and returns more data (in some cases, much more data). You should normally
	request only the data you need.

	To request extra data, specify which attachments you want in the `attachments`
	parameter:

	```lang=json, name="Example Attachments Request"
	{
	...
	"attachments": {
	"subscribers": true
	},
	...
	}
	```

	This example specifies that results should include information about
	subscribers. In the return value, each object will now have this information
	filled out in the corresponding `attachments` value:

	```lang=json, name="Example Attachments Result"
	{
	...
	"data": [
	{
	...
	"attachments": {
	"subscribers": {
	"subscriberPHIDs": [
	"PHID-WXYZ-2222",
	],
	"subscriberCount": 1,
	"viewerIsSubscribed": false
	}
	},
	...
	},
	...
	],
	...
	}
	```

	These attachments are available:
	EOTEXT
	);

	$attachments = $engine->getConduitSearchAttachments();

	$rows = array();
	foreach ($attachments as $key => $attachment) {
	$rows[] = array(
	$key,
	$attachment->getAttachmentName(),
	$attachment->getAttachmentDescription(),
	);
	}

	$table = id(new AphrontTableView($rows))
	->setNoDataString(pht('This call does not support any attachments.'))
	->setHeaders(
	array(
	pht('Key'),
	pht('Name'),
	pht('Description'),
	))
	->setColumnClasses(
	array(
	'prewrap',
	'pri',
	'wide',
	));

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Attachments'))
	->setCollapsed(true)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($this->buildRemarkup($info))
	->appendChild($table);
	}

	private function buildPagingBox(
	PhabricatorApplicationSearchEngine $engine) {

	$info = pht(<<<EOTEXT
	Queries are limited to returning 100 results at a time. If you want fewer
	results than this, you can use `limit` to specify a smaller limit.

	If you want more results, you'll need to make additional queries to retrieve
	more pages of results.

	The result structure contains a `cursor` key with information you'll need in
	order to fetch the next page of results. After an initial query, it will
	usually look something like this:

	```lang=json, name="Example Cursor Result"
	{
	...
	"cursor": {
	"limit": 100,
	"after": "1234",
	"before": null,
	"order": null
	}
	...
	}
	```

	The `limit` and `order` fields are describing the effective limit and order the
	query was executed with, and are usually not of much interest. The `after` and
	`before` fields give you cursors which you can pass when making another API
	call in order to get the next (or previous) page of results.

	To get the next page of results, repeat your API call with all the same
	parameters as the original call, but pass the `after` cursor you received from
	the first call in the `after` parameter when making the second call.

	If you do things correctly, you should get the second page of results, and
	a cursor structure like this:

	```lang=json, name="Second Result Page"
	{
	...
	"cursor": {
	"limit": 5,
	"after": "4567",
	"before": "7890",
	"order": null
	}
	...
	}
	```

	You can now continue to the third page of results by passing the new `after`
	cursor to the `after` parameter in your third call, or return to the previous
	page of results by passing the `before` cursor to the `before` parameter. This
	might be useful if you are rendering a web UI for a user and want to provide
	"Next Page" and "Previous Page" links.

	If `after` is `null`, there is no next page of results available. Likewise,
	if `before` is `null`, there are no previous results available.
	EOTEXT
	);

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Paging and Limits'))
	->setCollapsed(true)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($this->buildRemarkup($info));
	}

	private function buildRemarkup($remarkup) {
	$viewer = $this->getViewer();

	$view = new PHUIRemarkupView($viewer, $remarkup);

	+ $view->setRemarkupOptions(
	+ array(
	+ PHUIRemarkupView::OPTION_PRESERVE_LINEBREAKS => false,
	+ ));
	+
	return id(new PHUIBoxView())
	->appendChild($view)
	->addPadding(PHUI::PADDING_LARGE);
	}
	}
	diff --git a/src/applications/transactions/view/PhabricatorApplicationEditHTTPParameterHelpView.php b/src/applications/transactions/view/PhabricatorApplicationEditHTTPParameterHelpView.php
	index b0abe516de..d21e2105fb 100644
	--- a/src/applications/transactions/view/PhabricatorApplicationEditHTTPParameterHelpView.php
	+++ b/src/applications/transactions/view/PhabricatorApplicationEditHTTPParameterHelpView.php
	@@ -1,319 +1,326 @@
	<?php

	/**
	* Renders the "HTTP Parameters" help page for edit engines.
	*
	* This page has a ton of text and specialized rendering on it, this class
	* just pulls it out of the main @{class:PhabricatorEditEngine}.
	*/
	final class PhabricatorApplicationEditHTTPParameterHelpView
	extends AphrontView {

	private $object;
	private $fields;

	public function setObject($object) {
	$this->object = $object;
	return $this;
	}

	public function getObject() {
	return $this->object;
	}

	public function setFields(array $fields) {
	$this->fields = $fields;
	return $this;
	}

	public function getFields() {
	return $this->fields;
	}

	public function render() {
	$object = $this->getObject();
	$fields = $this->getFields();

	$uri = 'https://your.install.com/application/edit/';

	// Remove fields which do not expose an HTTP parameter type.
	$types = array();
	foreach ($fields as $key => $field) {
	if (!$field->shouldGenerateTransactionsFromSubmit()) {
	unset($fields[$key]);
	continue;
	}

	$type = $field->getHTTPParameterType();
	if ($type === null) {
	unset($fields[$key]);
	continue;
	}

	$types[$type->getTypeName()] = $type;
	}

	$intro = pht(<<<EOTEXT
	When creating objects in the web interface, you can use HTTP parameters to
	prefill fields in the form. This allows you to quickly create a link to a
	form with some of the fields already filled in with default values.

	To prefill a form, start by finding the URI for the form you want to prefill.
	Do this by navigating to the relevant application, clicking the "Create" button
	for the type of object you want to create, and then copying the URI out of your
	browser's address bar. It will usually look something like this:

	```
	%s
	```

	However, `your.install.com` will be the domain where your copy of Phabricator
	is installed, and `application/` will be the URI for an application. Some
	applications have multiple forms for creating objects or URIs that look a little
	different than this example, so the URI may not look exactly like this.

	To prefill the form, add properly encoded HTTP parameters to the URI. You
	should end up with something like this:

	```
	%s?title=Platyplus&body=Ornithopter
	```

	If the form has `title` and `body` fields of the correct types, visiting this
	link will prefill those fields with the values "Platypus" and "Ornithopter"
	respectively.

	The rest of this document shows which parameters you can add to this form and
	how to format them.


	Supported Fields
	----------------

	This form supports these fields:

	EOTEXT
	,
	$uri,
	$uri);

	$rows = array();
	foreach ($fields as $field) {
	$rows[] = array(
	$field->getLabel(),
	head($field->getAllReadValueFromRequestKeys()),
	$field->getHTTPParameterType()->getTypeName(),
	$field->getDescription(),
	);
	}

	$main_table = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	pht('Label'),
	pht('Key'),
	pht('Type'),
	pht('Description'),
	))
	->setColumnClasses(
	array(
	'pri',
	null,
	null,
	'wide',
	));

	$aliases_text = pht(<<<EOTEXT
	Aliases
	-------

	Aliases are alternate recognized keys for a field. For example, a field with
	a complex key like `examplePHIDs` might be have a simple version of that key
	as an alias, like `example`.

	Aliases work just like the primary key when prefilling forms. They make it
	easier to remember and use HTTP parameters by providing more natural ways to do
	some prefilling.

	For example, if a field has `examplePHIDs` as a key but has aliases `example`
	and `examples`, these three URIs will all do the same thing:

	```
	%s?examplePHIDs=...
	%s?examples=...
	%s?example=...
	```

	If a URI specifies multiple default values for a field, the value using the
	primary key has precedence. Generally, you can not mix different aliases in
	a single URI.

	EOTEXT
	,
	$uri,
	$uri,
	$uri);

	$rows = array();
	foreach ($fields as $field) {
	$aliases = array_slice($field->getAllReadValueFromRequestKeys(), 1);
	if (!$aliases) {
	continue;
	}
	$rows[] = array(
	$field->getLabel(),
	$field->getKey(),
	implode(', ', $aliases),
	);
	}

	$alias_table = id(new AphrontTableView($rows))
	->setNoDataString(pht('This object has no fields with aliases.'))
	->setHeaders(
	array(
	pht('Label'),
	pht('Key'),
	pht('Aliases'),
	))
	->setColumnClasses(
	array(
	'pri',
	null,
	'wide',
	));

	$template_text = pht(<<<EOTEXT
	Template Objects
	----------------

	Instead of specifying each field value individually, you can specify another
	object to use as a template. Some of the initial fields will be copied from the
	template object.

	Specify a template object with the `template` parameter. You can use an ID,
	PHID, or monogram (for objects which have monograms). For example, you might
	use URIs like these:

	```
	%s?template=123
	%s?template=PHID-WXYZ-abcdef...
	%s?template=T123
	```

	You can combine the `template` parameter with HTTP parameters: the template
	object will be copied first, then any HTTP parameters will be read.

	When using `template`, these fields will be copied:
	EOTEXT
	,
	$uri,
	$uri,
	$uri);

	$yes = id(new PHUIIconView())->setIcon('fa-check-circle green');
	$no = id(new PHUIIconView())->setIcon('fa-times grey');

	$rows = array();
	foreach ($fields as $field) {
	$rows[] = array(
	$field->getLabel(),
	$field->getIsCopyable() ? $yes : $no,
	);
	}

	$template_table = id(new AphrontTableView($rows))
	->setNoDataString(
	pht('None of the fields on this object support templating.'))
	->setHeaders(
	array(
	pht('Field'),
	pht('Will Copy'),
	))
	->setColumnClasses(
	array(
	'pri',
	'wide',
	));

	$select_text = pht(<<<EOTEXT
	Select Fields
	-------------

	Some fields support selection from a specific set of values. When prefilling
	these fields, use the value in the Value column to select the appropriate
	setting.

	EOTEXT
	);

	$rows = array();
	foreach ($fields as $field) {
	if (!($field instanceof PhabricatorSelectEditField)) {
	continue;
	}

	$options = $field->getOptions();
	$label = $field->getLabel();
	foreach ($options as $option_key => $option_value) {
	if (strlen($option_key)) {
	$option_display = $option_key;
	} else {
	$option_display = phutil_tag('em', array(), pht('<empty>'));
	}

	$rows[] = array(
	$label,
	$option_display,
	$option_value,
	);
	$label = null;
	}
	}

	$select_table = id(new AphrontTableView($rows))
	->setNoDataString(pht('This object has no select fields.'))
	->setHeaders(
	array(
	pht('Field'),
	pht('Value'),
	pht('Label'),
	))
	->setColumnClasses(
	array(
	'pri',
	null,
	'wide',
	));

	$types_text = pht(<<<EOTEXT
	Field Types
	-----------

	Fields in this form have the types described in the table below. This table
	shows how to format values for each field type.
	EOTEXT
	);

	$types_table = id(new PhabricatorHTTPParameterTypeTableView())
	->setHTTPParameterTypes($types);

	return array(
	$this->renderInstructions($intro),
	$main_table,
	$this->renderInstructions($aliases_text),
	$alias_table,
	$this->renderInstructions($template_text),
	$template_table,
	$this->renderInstructions($select_text),
	$select_table,
	$this->renderInstructions($types_text),
	$types_table,
	);
	}

	protected function renderInstructions($corpus) {
	$viewer = $this->getUser();
	- return new PHUIRemarkupView($viewer, $corpus);
	+ $view = new PHUIRemarkupView($viewer, $corpus);
	+
	+ $view->setRemarkupOptions(
	+ array(
	+ PHUIRemarkupView::OPTION_PRESERVE_LINEBREAKS => false,
	+ ));
	+
	+ return $view;
	}

	}
	diff --git a/src/infrastructure/markup/PhabricatorMarkupEngine.php b/src/infrastructure/markup/PhabricatorMarkupEngine.php
	index 92e027f86d..dc3809f873 100644
	--- a/src/infrastructure/markup/PhabricatorMarkupEngine.php
	+++ b/src/infrastructure/markup/PhabricatorMarkupEngine.php
	@@ -1,658 +1,659 @@
	<?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 = 15;
	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,
	));
	}


	/**
	* @task engine
	*/
	public static function newFeedMarkupEngine() {
	return self::newMarkupEngine(
	array(
	'macros' => false,
	'youtube' => false,
	));
	}

	/**
	* @task engine
	*/
	public static function newCalendarMarkupEngine() {
	return self::newMarkupEngine(array(
	));
	}


	/**
	* @task engine
	*/
	public static function newDifferentialMarkupEngine(array $options = array()) {
	return self::newMarkupEngine(array(
	'differential.diff' => idx($options, 'differential.diff'),
	));
	}


	/**
	* @task engine
	*/
	public static function newDiffusionMarkupEngine(array $options = array()) {
	return self::newMarkupEngine(array(
	'header.generate-toc' => true,
	));
	}

	/**
	* @task engine
	*/
	public static function getEngine($ruleset = 'default') {
	static $engines = array();
	if (isset($engines[$ruleset])) {
	return $engines[$ruleset];
	}

	$engine = null;
	switch ($ruleset) {
	case 'default':
	$engine = self::newMarkupEngine(array());
	break;
	case 'nolinebreaks':
	$engine = self::newMarkupEngine(array());
	$engine->setConfig('preserve-linebreaks', false);
	break;
	case 'diffusion-readme':
	$engine = self::newMarkupEngine(array());
	$engine->setConfig('preserve-linebreaks', false);
	$engine->setConfig('header.generate-toc', true);
	break;
	case 'diviner':
	$engine = self::newMarkupEngine(array());
	$engine->setConfig('preserve-linebreaks', false);
	// $engine->setConfig('diviner.renderer', new DivinerDefaultRenderer());
	$engine->setConfig('header.generate-toc', true);
	break;
	case 'extract':
	// Engine used for reference/edge extraction. Turn off anything which
	// is slow and doesn't change reference extraction.
	$engine = self::newMarkupEngine(array());
	$engine->setConfig('pygments.enabled', false);
	break;
	default:
	throw new Exception(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']);

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


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

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

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

	}
	diff --git a/src/infrastructure/markup/PhabricatorMarkupOneOff.php b/src/infrastructure/markup/PhabricatorMarkupOneOff.php
	index 0bfba1722f..6bffcf7e2b 100644
	--- a/src/infrastructure/markup/PhabricatorMarkupOneOff.php
	+++ b/src/infrastructure/markup/PhabricatorMarkupOneOff.php
	@@ -1,87 +1,101 @@
	<?php

	/**
	* DEPRECATED. Use @{class:PHUIRemarkupView}.
	*/
	final class PhabricatorMarkupOneOff
	extends Phobject
	implements PhabricatorMarkupInterface {

	private $content;
	private $preserveLinebreaks;
	private $engineRuleset;
	+ private $engine;
	private $disableCache;

	public function setEngineRuleset($engine_ruleset) {
	$this->engineRuleset = $engine_ruleset;
	return $this;
	}

	public function getEngineRuleset() {
	return $this->engineRuleset;
	}

	public function setPreserveLinebreaks($preserve_linebreaks) {
	$this->preserveLinebreaks = $preserve_linebreaks;
	return $this;
	}

	public function setContent($content) {
	$this->content = $content;
	return $this;
	}

	public function getContent() {
	return $this->content;
	}

	+ public function setEngine(PhutilMarkupEngine $engine) {
	+ $this->engine = $engine;
	+ return $this;
	+ }
	+
	+ public function getEngine() {
	+ return $this->engine;
	+ }
	+
	public function setDisableCache($disable_cache) {
	$this->disableCache = $disable_cache;
	return $this;
	}

	public function getDisableCache() {
	return $this->disableCache;
	}

	public function getMarkupFieldKey($field) {
	return PhabricatorHash::digestForIndex($this->getContent()).':oneoff';
	}

	public function newMarkupEngine($field) {
	+ if ($this->engine) {
	+ return $this->engine;
	+ }
	+
	if ($this->engineRuleset) {
	return PhabricatorMarkupEngine::getEngine($this->engineRuleset);
	} else if ($this->preserveLinebreaks) {
	return PhabricatorMarkupEngine::getEngine();
	} else {
	return PhabricatorMarkupEngine::getEngine('nolinebreaks');
	}
	}

	public function getMarkupText($field) {
	return $this->getContent();
	}

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

	require_celerity_resource('phabricator-remarkup-css');
	return phutil_tag(
	'div',
	array(
	'class' => 'phabricator-remarkup',
	),
	$output);
	}

	public function shouldUseMarkupCache($field) {
	if ($this->getDisableCache()) {
	return false;
	}

	return true;
	}

	}
	diff --git a/src/infrastructure/markup/view/PHUIRemarkupView.php b/src/infrastructure/markup/view/PHUIRemarkupView.php
	index 0a07e64a87..e30c09ce7c 100644
	--- a/src/infrastructure/markup/view/PHUIRemarkupView.php
	+++ b/src/infrastructure/markup/view/PHUIRemarkupView.php
	@@ -1,64 +1,96 @@
	<?php

	/**
	* Simple API for rendering blocks of Remarkup.
	*
	* Example usage:
	*
	* $fancy_text = new PHUIRemarkupView($viewer, $raw_remarkup);
	* $view->appendChild($fancy_text);
	*
	*/
	final class PHUIRemarkupView extends AphrontView {

	private $corpus;
	- private $markupType;
	private $contextObject;
	+ private $options;

	- const DOCUMENT = 'document';
	+ // TODO: In the long run, rules themselves should define available options.
	+ // For now, just define constants here so we can more easily replace things
	+ // later once this is cleaned up.
	+ const OPTION_PRESERVE_LINEBREAKS = 'preserve-linebreaks';

	public function __construct(PhabricatorUser $viewer, $corpus) {
	$this->setUser($viewer);
	$this->corpus = $corpus;
	}

	- private function setMarkupType($type) {
	- $this->markupType($type);
	- return $this;
	- }
	-
	public function setContextObject($context_object) {
	$this->contextObject = $context_object;
	return $this;
	}

	public function getContextObject() {
	return $this->contextObject;
	}

	+ public function setRemarkupOption($key, $value) {
	+ $this->options[$key] = $value;
	+ return $this;
	+ }
	+
	+ public function setRemarkupOptions(array $options) {
	+ foreach ($options as $key => $value) {
	+ $this->setRemarkupOption($key, $value);
	+ }
	+ return $this;
	+ }
	+
	public function render() {
	- $viewer = $this->getUser();
	+ $viewer = $this->getViewer();
	$corpus = $this->corpus;
	$context = $this->getContextObject();

	+ $options = $this->options;
	+
	+ $oneoff = id(new PhabricatorMarkupOneOff())
	+ ->setContent($corpus);
	+
	+ if ($options) {
	+ $oneoff->setEngine($this->getEngine());
	+ } else {
	+ $oneoff->setPreserveLinebreaks(true);
	+ }
	+
	$content = PhabricatorMarkupEngine::renderOneObject(
	- id(new PhabricatorMarkupOneOff())
	- ->setPreserveLinebreaks(true)
	- ->setContent($corpus),
	+ $oneoff,
	'default',
	$viewer,
	$context);

	- if ($this->markupType == self::DOCUMENT) {
	- return phutil_tag(
	- 'div',
	- array(
	- 'class' => 'phabricator-remarkup phui-document-view',
	- ),
	- $content);
	+ return $content;
	+ }
	+
	+ private function getEngine() {
	+ $options = $this->options;
	+ $viewer = $this->getViewer();
	+
	+ $viewer_key = $viewer->getCacheFragment();
	+
	+ ksort($options);
	+ $engine_key = serialize($options);
	+ $engine_key = PhabricatorHash::digestForIndex($engine_key);
	+
	+ $cache = PhabricatorCaches::getRequestCache();
	+ $cache_key = "remarkup.engine({$viewer}, {$engine_key})";
	+
	+ $engine = $cache->getKey($cache_key);
	+ if (!$engine) {
	+ $engine = PhabricatorMarkupEngine::newMarkupEngine($options);
	+ $cache->setKey($cache_key, $engine);
	}

	- return $content;
	+ return $engine;
	}

	}
	diff --git a/src/view/form/AphrontFormView.php b/src/view/form/AphrontFormView.php
	index ecd4c1206e..3c92f72c88 100644
	--- a/src/view/form/AphrontFormView.php
	+++ b/src/view/form/AphrontFormView.php
	@@ -1,169 +1,180 @@
	<?php

	final class AphrontFormView extends AphrontView {

	private $action;
	private $method = 'POST';
	private $header;
	private $data = array();
	private $encType;
	private $workflow;
	private $id;
	private $shaded = false;
	private $sigils = array();
	private $metadata;
	private $controls = array();
	private $fullWidth = false;

	public function setMetadata($metadata) {
	$this->metadata = $metadata;
	return $this;
	}

	public function getMetadata() {
	return $this->metadata;
	}

	public function setID($id) {
	$this->id = $id;
	return $this;
	}

	public function setAction($action) {
	$this->action = $action;
	return $this;
	}

	public function setMethod($method) {
	$this->method = $method;
	return $this;
	}

	public function setEncType($enc_type) {
	$this->encType = $enc_type;
	return $this;
	}

	public function setShaded($shaded) {
	$this->shaded = $shaded;
	return $this;
	}

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

	public function setWorkflow($workflow) {
	$this->workflow = $workflow;
	return $this;
	}

	public function addSigil($sigil) {
	$this->sigils[] = $sigil;
	return $this;
	}

	public function setFullWidth($full_width) {
	$this->fullWidth = $full_width;
	return $this;
	}

	public function getFullWidth() {
	return $this->fullWidth;
	}

	public function appendInstructions($text) {
	return $this->appendChild(
	phutil_tag(
	'div',
	array(
	'class' => 'aphront-form-instructions',
	),
	$text));
	}

	public function appendRemarkupInstructions($remarkup) {
	- return $this->appendInstructions(
	- new PHUIRemarkupView($this->getViewer(), $remarkup));
	+ $view = $this->newInstructionsRemarkupView($remarkup);
	+ return $this->appendInstructions($view);
	+ }
	+
	+ public function newInstructionsRemarkupView($remarkup) {
	+ $viewer = $this->getViewer();
	+ $view = new PHUIRemarkupView($viewer, $remarkup);
	+
	+ $view->setRemarkupOptions(
	+ array(
	+ PHUIRemarkupView::OPTION_PRESERVE_LINEBREAKS => false,
	+ ));

	+ return $view;
	}

	public function buildLayoutView() {
	foreach ($this->controls as $control) {
	$control->setViewer($this->getViewer());
	$control->willRender();
	}

	return id(new PHUIFormLayoutView())
	->setFullWidth($this->getFullWidth())
	->appendChild($this->renderDataInputs())
	->appendChild($this->renderChildren());
	}


	/**
	* Append a control to the form.
	*
	* This method behaves like @{method:appendChild}, but it only takes
	* controls. It will propagate some information from the form to the
	* control to simplify rendering.
	*
	* @param AphrontFormControl Control to append.
	* @return this
	*/
	public function appendControl(AphrontFormControl $control) {
	$this->controls[] = $control;
	return $this->appendChild($control);
	}


	public function render() {
	require_celerity_resource('phui-form-view-css');

	$layout = $this->buildLayoutView();

	if (!$this->hasViewer()) {
	throw new Exception(
	pht(
	'You must pass the user to %s.',
	__CLASS__));
	}

	$sigils = $this->sigils;
	if ($this->workflow) {
	$sigils[] = 'workflow';
	}

	return phabricator_form(
	$this->getViewer(),
	array(
	'class' => $this->shaded ? 'phui-form-shaded' : null,
	'action' => $this->action,
	'method' => $this->method,
	'enctype' => $this->encType,
	'sigil' => $sigils ? implode(' ', $sigils) : null,
	'meta' => $this->metadata,
	'id' => $this->id,
	),
	$layout->render());
	}

	private function renderDataInputs() {
	$inputs = array();
	foreach ($this->data as $key => $value) {
	if ($value === null) {
	continue;
	}
	$inputs[] = phutil_tag(
	'input',
	array(
	'type' => 'hidden',
	'name' => $key,
	'value' => $value,
	));
	}
	return $inputs;
	}

	}
	diff --git a/src/view/form/PHUIFormLayoutView.php b/src/view/form/PHUIFormLayoutView.php
	index ffc0eb31d5..682c6c62cf 100644
	--- a/src/view/form/PHUIFormLayoutView.php
	+++ b/src/view/form/PHUIFormLayoutView.php
	@@ -1,60 +1,57 @@
	<?php

	/**
	* This provides the layout of an AphrontFormView without actually providing
	* the <form /> tag. Useful on its own for creating forms in other forms (like
	* dialogs) or forms which aren't submittable.
	*/
	final class PHUIFormLayoutView extends AphrontView {

	private $classes = array();
	private $fullWidth;

	public function setFullWidth($width) {
	$this->fullWidth = $width;
	return $this;
	}

	public function addClass($class) {
	$this->classes[] = $class;
	return $this;
	}

	public function appendInstructions($text) {
	return $this->appendChild(
	phutil_tag(
	'div',
	array(
	'class' => 'aphront-form-instructions',
	),
	$text));
	}

	public function appendRemarkupInstructions($remarkup) {
	- if ($this->getUser() === null) {
	- throw new PhutilInvalidStateException('setUser');
	- }
	-
	- $viewer = $this->getUser();
	- $instructions = new PHUIRemarkupView($viewer, $remarkup);
	+ $view = id(new AphrontFormView())
	+ ->setViewer($this->getViewer())
	+ ->newInstructionsRemarkupView($remarkup);

	- return $this->appendInstructions($instructions);
	+ return $this->appendInstructions($view);
	}

	public function render() {
	$classes = $this->classes;
	$classes[] = 'phui-form-view';

	if ($this->fullWidth) {
	$classes[] = 'phui-form-full-width';
	}

	return phutil_tag(
	'div',
	array(
	'class' => implode(' ', $classes),
	),
	$this->renderChildren());

	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jul 27, 2:00 PM (1 w, 5 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 185782
Default Alt Text: (56 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions