No OneTemporary
Actions

Size

146 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/calendar/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	index b2e81b0e8b..e566a77b76 100644
	--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	@@ -1,1447 +1,1446 @@
	<?php

	final class PhabricatorCalendarEvent extends PhabricatorCalendarDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorExtendedPolicyInterface,
	PhabricatorPolicyCodexInterface,
	PhabricatorProjectInterface,
	PhabricatorMarkupInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorSubscribableInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorDestructibleInterface,
	PhabricatorMentionableInterface,
	PhabricatorFlaggableInterface,
	PhabricatorSpacesInterface,
	PhabricatorFulltextInterface,
	PhabricatorConduitResultInterface {

	protected $name;
	protected $hostPHID;
	protected $description;
	protected $isCancelled;
	protected $isAllDay;
	protected $icon;
	protected $mailKey;
	protected $isStub;

	protected $isRecurring = 0;

	protected $seriesParentPHID;
	protected $instanceOfEventPHID;
	protected $sequenceIndex;

	protected $viewPolicy;
	protected $editPolicy;

	protected $spacePHID;

	protected $utcInitialEpoch;
	protected $utcUntilEpoch;
	protected $utcInstanceEpoch;
	protected $parameters = array();

	protected $importAuthorPHID;
	protected $importSourcePHID;
	protected $importUIDIndex;
	protected $importUID;

	private $parentEvent = self::ATTACHABLE;
	private $invitees = self::ATTACHABLE;
	private $importSource = self::ATTACHABLE;
	private $rsvps = self::ATTACHABLE;

	private $viewerTimezone;

	private $isGhostEvent = false;
	private $stubInvitees;

	public static function initializeNewCalendarEvent(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorCalendarApplication'))
	->executeOne();

	$view_default = PhabricatorCalendarEventDefaultViewCapability::CAPABILITY;
	$edit_default = PhabricatorCalendarEventDefaultEditCapability::CAPABILITY;
	$view_policy = $app->getPolicy($view_default);
	$edit_policy = $app->getPolicy($edit_default);

	$now = PhabricatorTime::getNow();

	$default_icon = 'fa-calendar';

	$datetime_defaults = self::newDefaultEventDateTimes(
	$actor,
	$now);
	list($datetime_start, $datetime_end) = $datetime_defaults;

	// When importing events from a context like "bin/calendar reload", we may
	// be acting as the omnipotent user.
	$host_phid = $actor->getPHID();
	if (!$host_phid) {
	$host_phid = $app->getPHID();
	}

	return id(new PhabricatorCalendarEvent())
	->setDescription('')
	->setHostPHID($host_phid)
	->setIsCancelled(0)
	->setIsAllDay(0)
	->setIsStub(0)
	->setIsRecurring(0)
	->setIcon($default_icon)
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->setSpacePHID($actor->getDefaultSpacePHID())
	->attachInvitees(array())
	->setStartDateTime($datetime_start)
	->setEndDateTime($datetime_end)
	->attachImportSource(null)
	->applyViewerTimezone($actor);
	}

	public static function newDefaultEventDateTimes(
	PhabricatorUser $viewer,
	$now) {

	$datetime_start = PhutilCalendarAbsoluteDateTime::newFromEpoch(
	$now,
	$viewer->getTimezoneIdentifier());

	// Advance the time by an hour, then round downwards to the nearest hour.
	// For example, if it is currently 3:25 PM, we suggest a default start time
	// of 4 PM.
	$datetime_start = $datetime_start
	->newRelativeDateTime('PT1H')
	->newAbsoluteDateTime();
	$datetime_start->setMinute(0);
	$datetime_start->setSecond(0);

	// Default the end time to an hour after the start time.
	$datetime_end = $datetime_start
	->newRelativeDateTime('PT1H')
	->newAbsoluteDateTime();

	return array($datetime_start, $datetime_end);
	}

	private function newChild(
	PhabricatorUser $actor,
	$sequence,
	PhutilCalendarDateTime $start = null) {
	if (!$this->isParentEvent()) {
	throw new Exception(
	pht(
	'Unable to generate a new child event for an event which is not '.
	'a recurring parent event!'));
	}

	$series_phid = $this->getSeriesParentPHID();
	if (!$series_phid) {
	$series_phid = $this->getPHID();
	}

	$child = id(new self())
	->setIsCancelled(0)
	->setIsStub(0)
	->setInstanceOfEventPHID($this->getPHID())
	->setSeriesParentPHID($series_phid)
	->setSequenceIndex($sequence)
	->setIsRecurring(true)
	->attachParentEvent($this)
	->attachImportSource(null);

	return $child->copyFromParent($actor, $start);
	}

	protected function readField($field) {
	static $inherit = array(
	'hostPHID' => true,
	'isAllDay' => true,
	'icon' => true,
	'spacePHID' => true,
	'viewPolicy' => true,
	'editPolicy' => true,
	'name' => true,
	'description' => true,
	'isCancelled' => true,
	);

	// Read these fields from the parent event instead of this event. For
	// example, we want any changes to the parent event's name to apply to
	// the child.
	if (isset($inherit[$field])) {
	if ($this->getIsStub()) {
	// TODO: This should be unconditional, but the execution order of
	// CalendarEventQuery and applyViewerTimezone() are currently odd.
	if ($this->parentEvent !== self::ATTACHABLE) {
	return $this->getParentEvent()->readField($field);
	}
	}
	}

	return parent::readField($field);
	}


	public function copyFromParent(
	PhabricatorUser $actor,
	PhutilCalendarDateTime $start = null) {

	if (!$this->isChildEvent()) {
	throw new Exception(
	pht(
	'Unable to copy from parent event: this is not a child event.'));
	}

	$parent = $this->getParentEvent();

	$this
	->setHostPHID($parent->getHostPHID())
	->setIsAllDay($parent->getIsAllDay())
	->setIcon($parent->getIcon())
	->setSpacePHID($parent->getSpacePHID())
	->setViewPolicy($parent->getViewPolicy())
	->setEditPolicy($parent->getEditPolicy())
	->setName($parent->getName())
	->setDescription($parent->getDescription())
	->setIsCancelled($parent->getIsCancelled());

	if ($start) {
	$start_datetime = $start;
	} else {
	$sequence = $this->getSequenceIndex();
	$start_datetime = $parent->newSequenceIndexDateTime($sequence);

	if (!$start_datetime) {
	throw new Exception(
	pht(
	'Sequence "%s" is not valid for event!',
	$sequence));
	}
	}

	$duration = $parent->newDuration();
	$end_datetime = $start_datetime->newRelativeDateTime($duration);

	$this
	->setStartDateTime($start_datetime)
	->setEndDateTime($end_datetime);

	if ($parent->isImportedEvent()) {
	$full_uid = $parent->getImportUID().'/'.$start_datetime->getEpoch();

	// NOTE: We don't attach the import source because this gets called
	// from CalendarEventQuery while building ghosts, before we've loaded
	// and attached sources. Possibly this sequence should be flipped.

	$this
	->setImportAuthorPHID($parent->getImportAuthorPHID())
	->setImportSourcePHID($parent->getImportSourcePHID())
	->setImportUID($full_uid);
	}

	return $this;
	}

	public function isValidSequenceIndex(PhabricatorUser $viewer, $sequence) {
	return (bool)$this->newSequenceIndexDateTime($sequence);
	}

	public function newSequenceIndexDateTime($sequence) {
	$set = $this->newRecurrenceSet();
	if (!$set) {
	return null;
	}

	$limit = $sequence + 1;
	$count = $this->getRecurrenceCount();
	if ($count && ($count < $limit)) {
	return null;
	}

	$instances = $set->getEventsBetween(
	null,
	$this->newUntilDateTime(),
	$limit);

	return idx($instances, $sequence, null);
	}

	public function newStub(PhabricatorUser $actor, $sequence) {
	$stub = $this->newChild($actor, $sequence);

	$stub->setIsStub(1);

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$stub->save();
	unset($unguarded);

	$stub->applyViewerTimezone($actor);

	return $stub;
	}

	public function newGhost(
	PhabricatorUser $actor,
	$sequence,
	PhutilCalendarDateTime $start = null) {

	$ghost = $this->newChild($actor, $sequence, $start);

	$ghost
	->setIsGhostEvent(true)
	->makeEphemeral();

	$ghost->applyViewerTimezone($actor);

	return $ghost;
	}

	public function applyViewerTimezone(PhabricatorUser $viewer) {
	$this->viewerTimezone = $viewer->getTimezoneIdentifier();
	return $this;
	}

	public function getDuration() {
	return ($this->getEndDateTimeEpoch() - $this->getStartDateTimeEpoch());
	}

	public function updateUTCEpochs() {
	// The "intitial" epoch is the start time of the event, in UTC.
	$start_date = $this->newStartDateTime()
	->setViewerTimezone('UTC');
	$start_epoch = $start_date->getEpoch();
	$this->setUTCInitialEpoch($start_epoch);

	// The "until" epoch is the last UTC epoch on which any instance of this
	// event occurs. For infinitely recurring events, it is `null`.

	if (!$this->getIsRecurring()) {
	$end_date = $this->newEndDateTime()
	->setViewerTimezone('UTC');
	$until_epoch = $end_date->getEpoch();
	} else {
	$until_epoch = null;
	$until_date = $this->newUntilDateTime();
	if ($until_date) {
	$until_date->setViewerTimezone('UTC');
	$duration = $this->newDuration();
	$until_epoch = id(new PhutilCalendarRelativeDateTime())
	->setOrigin($until_date)
	->setDuration($duration)
	->getEpoch();
	}
	}
	$this->setUTCUntilEpoch($until_epoch);

	// The "instance" epoch is a property of instances of recurring events.
	// It's the original UTC epoch on which the instance started. Usually that
	// is the same as the start date, but they may be different if the instance
	// has been edited.

	// The ICS format uses this value (original start time) to identify event
	// instances, and must do so because it allows additional arbitrary
	// instances to be added (with "RDATE").

	$instance_epoch = null;
	$instance_date = $this->newInstanceDateTime();
	if ($instance_date) {
	$instance_epoch = $instance_date
	->setViewerTimezone('UTC')
	->getEpoch();
	}
	$this->setUTCInstanceEpoch($instance_epoch);

	return $this;
	}

	public function save() {
	if (!$this->mailKey) {
	$this->mailKey = Filesystem::readRandomCharacters(20);
	}

	$import_uid = $this->getImportUID();
	if ($import_uid !== null) {
	$index = PhabricatorHash::digestForIndex($import_uid);
	} else {
	$index = null;
	}
	$this->setImportUIDIndex($index);

	$this->updateUTCEpochs();

	return parent::save();
	}

	/**
	* Get the event start epoch for evaluating invitee availability.
	*
	* When assessing availability, we pretend events start earlier than they
	* really do. This allows us to mark users away for the entire duration of a
	* series of back-to-back meetings, even if they don't strictly overlap.
	*
	* @return int Event start date for availability caches.
	*/
	public function getStartDateTimeEpochForCache() {
	$epoch = $this->getStartDateTimeEpoch();
	$window = phutil_units('15 minutes in seconds');
	return ($epoch - $window);
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'text',
	'description' => 'text',
	'isCancelled' => 'bool',
	'isAllDay' => 'bool',
	'icon' => 'text32',
	'mailKey' => 'bytes20',
	'isRecurring' => 'bool',
	'seriesParentPHID' => 'phid?',
	'instanceOfEventPHID' => 'phid?',
	'sequenceIndex' => 'uint32?',
	'isStub' => 'bool',
	'utcInitialEpoch' => 'epoch',
	'utcUntilEpoch' => 'epoch?',
	'utcInstanceEpoch' => 'epoch?',

	'importAuthorPHID' => 'phid?',
	'importSourcePHID' => 'phid?',
	'importUIDIndex' => 'bytes12?',
	'importUID' => 'text?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_instance' => array(
	'columns' => array('instanceOfEventPHID', 'sequenceIndex'),
	'unique' => true,
	),
	'key_epoch' => array(
	'columns' => array('utcInitialEpoch', 'utcUntilEpoch'),
	),
	'key_rdate' => array(
	'columns' => array('instanceOfEventPHID', 'utcInstanceEpoch'),
	'unique' => true,
	),
	'key_series' => array(
	'columns' => array('seriesParentPHID', 'utcInitialEpoch'),
	),
	),
	self::CONFIG_SERIALIZATION => array(
	'parameters' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorCalendarEventPHIDType::TYPECONST);
	}

	public function getMonogram() {
	return 'E'.$this->getID();
	}

	public function getInvitees() {
	if ($this->getIsGhostEvent() \|\| $this->getIsStub()) {
	if ($this->stubInvitees === null) {
	$this->stubInvitees = $this->newStubInvitees();
	}
	return $this->stubInvitees;
	}

	return $this->assertAttached($this->invitees);
	}

	public function getInviteeForPHID($phid) {
	$invitees = $this->getInvitees();
	$invitees = mpull($invitees, null, 'getInviteePHID');
	return idx($invitees, $phid);
	}

	public static function getFrequencyMap() {
	return array(
	PhutilCalendarRecurrenceRule::FREQUENCY_DAILY => array(
	'label' => pht('Daily'),
	),
	PhutilCalendarRecurrenceRule::FREQUENCY_WEEKLY => array(
	'label' => pht('Weekly'),
	),
	PhutilCalendarRecurrenceRule::FREQUENCY_MONTHLY => array(
	'label' => pht('Monthly'),
	),
	PhutilCalendarRecurrenceRule::FREQUENCY_YEARLY => array(
	'label' => pht('Yearly'),
	),
	);
	}

	private function newStubInvitees() {
	$parent = $this->getParentEvent();

	$parent_invitees = $parent->getInvitees();
	$stub_invitees = array();

	foreach ($parent_invitees as $invitee) {
	$stub_invitee = id(new PhabricatorCalendarEventInvitee())
	->setInviteePHID($invitee->getInviteePHID())
	->setInviterPHID($invitee->getInviterPHID())
	->setStatus(PhabricatorCalendarEventInvitee::STATUS_INVITED);

	$stub_invitees[] = $stub_invitee;
	}

	return $stub_invitees;
	}

	public function attachInvitees(array $invitees) {
	$this->invitees = $invitees;
	return $this;
	}

	public function getInviteePHIDsForEdit() {
	$invitees = array();

	foreach ($this->getInvitees() as $invitee) {
	if ($invitee->isUninvited()) {
	continue;
	}
	$invitees[] = $invitee->getInviteePHID();
	}

	return $invitees;
	}

	public function getUserInviteStatus($phid) {
	$invitees = $this->getInvitees();
	$invitees = mpull($invitees, null, 'getInviteePHID');

	$invited = idx($invitees, $phid);
	if (!$invited) {
	return PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
	}

	$invited = $invited->getStatus();
	return $invited;
	}

	public function getIsUserAttending($phid) {
	$attending_status = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;

	$old_status = $this->getUserInviteStatus($phid);
	$is_attending = ($old_status == $attending_status);

	return $is_attending;
	}

	public function getIsGhostEvent() {
	return $this->isGhostEvent;
	}

	public function setIsGhostEvent($is_ghost_event) {
	$this->isGhostEvent = $is_ghost_event;
	return $this;
	}

	public function getURI() {
	if ($this->getIsGhostEvent()) {
	$base = $this->getParentEvent()->getURI();
	$sequence = $this->getSequenceIndex();
	return "{$base}/{$sequence}/";
	}

	return '/'.$this->getMonogram();
	}

	public function getParentEvent() {
	return $this->assertAttached($this->parentEvent);
	}

	public function attachParentEvent(PhabricatorCalendarEvent $event = null) {
	$this->parentEvent = $event;
	return $this;
	}

	public function isParentEvent() {
	return ($this->getIsRecurring() && !$this->getInstanceOfEventPHID());
	}

	public function isChildEvent() {
	return ($this->instanceOfEventPHID !== null);
	}

	public function renderEventDate(
	PhabricatorUser $viewer,
	$show_end) {

	$start = $this->newStartDateTime();
	$end = $this->newEndDateTime();

	$min_date = $start->newPHPDateTime();
	$max_date = $end->newPHPDateTime();

	if ($this->getIsAllDay()) {
	// Subtract one second since the stored date is exclusive.
	$max_date = $max_date->modify('-1 second');
	}

	if ($show_end) {
	$min_day = $min_date->format('Y m d');
	$max_day = $max_date->format('Y m d');

	$show_end_date = ($min_day != $max_day);
	} else {
	$show_end_date = false;
	}

	$min_epoch = $min_date->format('U');
	$max_epoch = $max_date->format('U');

	if ($this->getIsAllDay()) {
	if ($show_end_date) {
	return pht(
	'%s - %s, All Day',
	phabricator_date($min_epoch, $viewer),
	phabricator_date($max_epoch, $viewer));
	} else {
	return pht(
	'%s, All Day',
	phabricator_date($min_epoch, $viewer));
	}
	} else if ($show_end_date) {
	return pht(
	'%s - %s',
	phabricator_datetime($min_epoch, $viewer),
	phabricator_datetime($max_epoch, $viewer));
	} else if ($show_end) {
	return pht(
	'%s - %s',
	phabricator_datetime($min_epoch, $viewer),
	phabricator_time($max_epoch, $viewer));
	} else {
	return pht(
	'%s',
	phabricator_datetime($min_epoch, $viewer));
	}
	}


	public function getDisplayIcon(PhabricatorUser $viewer) {
	if ($this->getIsCancelled()) {
	return 'fa-times';
	}

	if ($viewer->isLoggedIn()) {
	$viewer_phid = $viewer->getPHID();
	if ($this->isRSVPInvited($viewer_phid)) {
	return 'fa-users';
	} else {
	$status = $this->getUserInviteStatus($viewer_phid);
	switch ($status) {
	case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
	return 'fa-check-circle';
	case PhabricatorCalendarEventInvitee::STATUS_INVITED:
	return 'fa-user-plus';
	case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
	return 'fa-times-circle';
	}
	}
	}

	if ($this->isImportedEvent()) {
	return 'fa-download';
	}

	return $this->getIcon();
	}

	public function getDisplayIconColor(PhabricatorUser $viewer) {
	if ($this->getIsCancelled()) {
	return 'red';
	}

	if ($this->isImportedEvent()) {
	return 'orange';
	}

	if ($viewer->isLoggedIn()) {
	$viewer_phid = $viewer->getPHID();
	if ($this->isRSVPInvited($viewer_phid)) {
	return 'green';
	}

	$status = $this->getUserInviteStatus($viewer_phid);
	switch ($status) {
	case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
	return 'green';
	case PhabricatorCalendarEventInvitee::STATUS_INVITED:
	return 'green';
	case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
	return 'grey';
	}
	}

	return 'bluegrey';
	}

	public function getDisplayIconLabel(PhabricatorUser $viewer) {
	if ($this->getIsCancelled()) {
	return pht('Cancelled');
	}

	if ($viewer->isLoggedIn()) {
	$status = $this->getUserInviteStatus($viewer->getPHID());
	switch ($status) {
	case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
	return pht('Attending');
	case PhabricatorCalendarEventInvitee::STATUS_INVITED:
	return pht('Invited');
	case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
	return pht('Declined');
	}
	}

	return null;
	}

	public function getICSFilename() {
	return $this->getMonogram().'.ics';
	}

	public function newIntermediateEventNode(
	PhabricatorUser $viewer,
	array $children) {

	$base_uri = new PhutilURI(PhabricatorEnv::getProductionURI('/'));
	$domain = $base_uri->getDomain();

	// NOTE: For recurring events, all of the events in the series have the
	// same UID (the UID of the parent). The child event instances are
	// differentiated by the "RECURRENCE-ID" field.
	if ($this->isChildEvent()) {
	$parent = $this->getParentEvent();
	$instance_datetime = PhutilCalendarAbsoluteDateTime::newFromEpoch(
	$this->getUTCInstanceEpoch());
	$recurrence_id = $instance_datetime->getISO8601();
	$rrule = null;
	} else {
	$parent = $this;
	$recurrence_id = null;
	$rrule = $this->newRecurrenceRule();
	}
	$uid = $parent->getPHID().'@'.$domain;

	$created = $this->getDateCreated();
	$created = PhutilCalendarAbsoluteDateTime::newFromEpoch($created);

	$modified = $this->getDateModified();
	$modified = PhutilCalendarAbsoluteDateTime::newFromEpoch($modified);

	$date_start = $this->newStartDateTime();
	$date_end = $this->newEndDateTime();

	if ($this->getIsAllDay()) {
	$date_start->setIsAllDay(true);
	$date_end->setIsAllDay(true);
	}

	$host_phid = $this->getHostPHID();

	$invitees = $this->getInvitees();
	foreach ($invitees as $key => $invitee) {
	if ($invitee->isUninvited()) {
	unset($invitees[$key]);
	}
	}

	$phids = array();
	$phids[] = $host_phid;
	foreach ($invitees as $invitee) {
	$phids[] = $invitee->getInviteePHID();
	}

	$handles = $viewer->loadHandles($phids);

	$host_handle = $handles[$host_phid];
	$host_name = $host_handle->getFullName();

	// NOTE: Gmail shows "Who: Unknown Organizer*" if the organizer URI does
	// not look like an email address. Use a synthetic address so it shows
	// the host name instead.
	$install_uri = PhabricatorEnv::getProductionURI('/');
	$install_uri = new PhutilURI($install_uri);

	// This should possibly use "metamta.reply-handler-domain" instead, but
	// we do not currently accept mail for users anyway, and that option may
	// not be configured.
	$mail_domain = $install_uri->getDomain();
	$host_uri = "mailto:{$host_phid}@{$mail_domain}";

	$organizer = id(new PhutilCalendarUserNode())
	->setName($host_name)
	->setURI($host_uri);

	$attendees = array();
	foreach ($invitees as $invitee) {
	$invitee_phid = $invitee->getInviteePHID();
	$invitee_handle = $handles[$invitee_phid];
	$invitee_name = $invitee_handle->getFullName();
	$invitee_uri = $invitee_handle->getURI();
	$invitee_uri = PhabricatorEnv::getURI($invitee_uri);

	switch ($invitee->getStatus()) {
	case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
	$status = PhutilCalendarUserNode::STATUS_ACCEPTED;
	break;
	case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
	$status = PhutilCalendarUserNode::STATUS_DECLINED;
	break;
	case PhabricatorCalendarEventInvitee::STATUS_INVITED:
	default:
	$status = PhutilCalendarUserNode::STATUS_INVITED;
	break;
	}

	$attendees[] = id(new PhutilCalendarUserNode())
	->setName($invitee_name)
	->setURI($invitee_uri)
	->setStatus($status);
	}

	// TODO: Use $children to generate EXDATE/RDATE information.

	$node = id(new PhutilCalendarEventNode())
	->setUID($uid)
	->setName($this->getName())
	->setDescription($this->getDescription())
	->setCreatedDateTime($created)
	->setModifiedDateTime($modified)
	->setStartDateTime($date_start)
	->setEndDateTime($date_end)
	->setOrganizer($organizer)
	->setAttendees($attendees);

	if ($rrule) {
	$node->setRecurrenceRule($rrule);
	}

	if ($recurrence_id) {
	$node->setRecurrenceID($recurrence_id);
	}

	return $node;
	}

	public function newStartDateTime() {
	$datetime = $this->getParameter('startDateTime');
	return $this->newDateTimeFromDictionary($datetime);
	}

	public function getStartDateTimeEpoch() {
	return $this->newStartDateTime()->getEpoch();
	}

	public function newEndDateTimeForEdit() {
	$datetime = $this->getParameter('endDateTime');
	return $this->newDateTimeFromDictionary($datetime);
	}

	public function newEndDateTime() {
	$datetime = $this->newEndDateTimeForEdit();

	// If this is an all day event, we move the end date time forward to the
	// first second of the following day. This is consistent with what users
	// expect: an all day event from "Nov 1" to "Nov 1" lasts the entire day.

	// For imported events, the end date is already stored with this
	// adjustment.

	if ($this->getIsAllDay() && !$this->isImportedEvent()) {
	$datetime = $datetime
	->newAbsoluteDateTime()
	->setHour(0)
	->setMinute(0)
	->setSecond(0)
	->newRelativeDateTime('P1D')
	->newAbsoluteDateTime();
	}

	return $datetime;
	}

	public function getEndDateTimeEpoch() {
	return $this->newEndDateTime()->getEpoch();
	}

	public function newUntilDateTime() {
	$datetime = $this->getParameter('untilDateTime');
	if ($datetime) {
	return $this->newDateTimeFromDictionary($datetime);
	}

	return null;
	}

	public function getUntilDateTimeEpoch() {
	$datetime = $this->newUntilDateTime();

	if (!$datetime) {
	return null;
	}

	return $datetime->getEpoch();
	}

	public function newDuration() {
	return id(new PhutilCalendarDuration())
	->setSeconds($this->getDuration());
	}

	public function newInstanceDateTime() {
	if (!$this->getIsRecurring()) {
	return null;
	}

	$index = $this->getSequenceIndex();
	if (!$index) {
	return null;
	}

	return $this->newSequenceIndexDateTime($index);
	}

	private function newDateTimeFromEpoch($epoch) {
	$datetime = PhutilCalendarAbsoluteDateTime::newFromEpoch($epoch);

	if ($this->getIsAllDay()) {
	$datetime->setIsAllDay(true);
	}

	return $this->newDateTimeFromDateTime($datetime);
	}

	private function newDateTimeFromDictionary(array $dict) {
	$datetime = PhutilCalendarAbsoluteDateTime::newFromDictionary($dict);
	return $this->newDateTimeFromDateTime($datetime);
	}

	private function newDateTimeFromDateTime(PhutilCalendarDateTime $datetime) {
	$viewer_timezone = $this->viewerTimezone;
	if ($viewer_timezone) {
	$datetime->setViewerTimezone($viewer_timezone);
	}

	return $datetime;
	}

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

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

	public function setStartDateTime(PhutilCalendarDateTime $datetime) {
	return $this->setParameter(
	'startDateTime',
	$datetime->newAbsoluteDateTime()->toDictionary());
	}

	public function setEndDateTime(PhutilCalendarDateTime $datetime) {
	return $this->setParameter(
	'endDateTime',
	$datetime->newAbsoluteDateTime()->toDictionary());
	}

	public function setUntilDateTime(PhutilCalendarDateTime $datetime = null) {
	if ($datetime) {
	$value = $datetime->newAbsoluteDateTime()->toDictionary();
	} else {
	$value = null;
	}

	return $this->setParameter('untilDateTime', $value);
	}

	public function setRecurrenceRule(PhutilCalendarRecurrenceRule $rrule) {
	return $this->setParameter(
	'recurrenceRule',
	$rrule->toDictionary());
	}

	public function newRecurrenceRule() {
	if ($this->isChildEvent()) {
	return $this->getParentEvent()->newRecurrenceRule();
	}

	if (!$this->getIsRecurring()) {
	return null;
	}

	$dict = $this->getParameter('recurrenceRule');
	if (!$dict) {
	return null;
	}

	$rrule = PhutilCalendarRecurrenceRule::newFromDictionary($dict);

	$start = $this->newStartDateTime();
	$rrule->setStartDateTime($start);

	$until = $this->newUntilDateTime();
	if ($until) {
	$rrule->setUntil($until);
	}

	$count = $this->getRecurrenceCount();
	if ($count) {
	$rrule->setCount($count);
	}

	return $rrule;
	}

	public function getRecurrenceCount() {
	$count = (int)$this->getParameter('recurrenceCount');

	if (!$count) {
	return null;
	}

	return $count;
	}

	public function newRecurrenceSet() {
	if ($this->isChildEvent()) {
	return $this->getParentEvent()->newRecurrenceSet();
	}

	$set = new PhutilCalendarRecurrenceSet();

	if ($this->viewerTimezone) {
	$set->setViewerTimezone($this->viewerTimezone);
	}

	$rrule = $this->newRecurrenceRule();
	if (!$rrule) {
	return null;
	}

	$set->addSource($rrule);

	return $set;
	}

	public function isImportedEvent() {
	return (bool)$this->getImportSourcePHID();
	}

	public function getImportSource() {
	return $this->assertAttached($this->importSource);
	}

	public function attachImportSource(
	PhabricatorCalendarImport $import = null) {
	$this->importSource = $import;
	return $this;
	}

	public function loadForkTarget(PhabricatorUser $viewer) {
	if (!$this->getIsRecurring()) {
	// Can't fork an event which isn't recurring.
	return null;
	}

	if ($this->isChildEvent()) {
	// If this is a child event, this is the fork target.
	return $this;
	}

	if (!$this->isValidSequenceIndex($viewer, 1)) {
	// This appears to be a "recurring" event with no valid instances: for
	// example, its "until" date is before the second instance would occur.
	// This can happen if we already forked the event or if users entered
	// silly stuff. Just edit the event directly without forking anything.
	return null;
	}


	$next_event = id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withInstanceSequencePairs(
	array(
	array($this->getPHID(), 1),
	))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();

	if (!$next_event) {
	$next_event = $this->newStub($viewer, 1);
	}

	return $next_event;
	}

	public function loadFutureEvents(PhabricatorUser $viewer) {
	// NOTE: If you can't edit some of the future events, we just
	// don't try to update them. This seems like it's probably what
	// users are likely to expect.

	// NOTE: This only affects events that are currently in the same
	// series, not all events that were ever in the original series.
	// We could use series PHIDs instead of parent PHIDs to affect more
	// events if this turns out to be counterintuitive. Other
	// applications differ in their behavior.

	return id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withParentEventPHIDs(array($this->getPHID()))
	->withUTCInitialEpochBetween($this->getUTCInitialEpoch(), null)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->execute();
	}

	public function getNotificationPHIDs() {
	$phids = array();
	if ($this->getPHID()) {
	$phids[] = $this->getPHID();
	}

	if ($this->getSeriesParentPHID()) {
	$phids[] = $this->getSeriesParentPHID();
	}

	return $phids;
	}

	public function getRSVPs($phid) {
	return $this->assertAttachedKey($this->rsvps, $phid);
	}

	public function attachRSVPs(array $rsvps) {
	$this->rsvps = $rsvps;
	return $this;
	}

	public function isRSVPInvited($phid) {
	$status_invited = PhabricatorCalendarEventInvitee::STATUS_INVITED;
	return ($this->getRSVPStatus($phid) == $status_invited);
	}

	public function hasRSVPAuthority($phid, $other_phid) {
	foreach ($this->getRSVPs($phid) as $rsvp) {
	if ($rsvp->getInviteePHID() == $other_phid) {
	return true;
	}
	}

	return false;
	}

	public function getRSVPStatus($phid) {
	// Check for an individual invitee record first.
	$invitees = $this->invitees;
	$invitees = mpull($invitees, null, 'getInviteePHID');
	$invitee = idx($invitees, $phid);
	if ($invitee) {
	return $invitee->getStatus();
	}

	// If we don't have one, try to find an invited status for the user's
	// projects.
	$status_invited = PhabricatorCalendarEventInvitee::STATUS_INVITED;
	foreach ($this->getRSVPs($phid) as $rsvp) {
	if ($rsvp->getStatus() == $status_invited) {
	return $status_invited;
	}
	}

	return PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
	}



	/* -( Markup Interface )--------------------------------------------------- */


	/**
	* @task markup
	*/
	public function getMarkupFieldKey($field) {
	- $hash = PhabricatorHash::digest($this->getMarkupText($field));
	- $id = $this->getID();
	- return "calendar:T{$id}:{$field}:{$hash}";
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}


	/**
	* @task markup
	*/
	public function getMarkupText($field) {
	return $this->getDescription();
	}


	/**
	* @task markup
	*/
	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newCalendarMarkupEngine();
	}


	/**
	* @task markup
	*/
	public function didMarkupText(
	$field,
	$output,
	PhutilMarkupEngine $engine) {
	return $output;
	}


	/**
	* @task markup
	*/
	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}

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


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	if ($this->isImportedEvent()) {
	return PhabricatorPolicies::POLICY_NOONE;
	} else {
	return $this->getEditPolicy();
	}
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	if ($this->isImportedEvent()) {
	return false;
	}

	// The host of an event can always view and edit it.
	$user_phid = $this->getHostPHID();
	if ($user_phid) {
	$viewer_phid = $viewer->getPHID();
	if ($viewer_phid == $user_phid) {
	return true;
	}
	}

	if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
	$status = $this->getUserInviteStatus($viewer->getPHID());
	if ($status == PhabricatorCalendarEventInvitee::STATUS_INVITED \|\|
	$status == PhabricatorCalendarEventInvitee::STATUS_ATTENDING \|\|
	$status == PhabricatorCalendarEventInvitee::STATUS_DECLINED) {
	return true;
	}
	}

	return false;
	}


	/* -( PhabricatorExtendedPolicyInterface )--------------------------------- */


	public function getExtendedPolicy($capability, PhabricatorUser $viewer) {
	$extended = array();

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	$import_source = $this->getImportSource();
	if ($import_source) {
	$extended[] = array(
	$import_source,
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}
	break;
	}

	return $extended;
	}

	/* -( PhabricatorPolicyCodexInterface )------------------------------------ */

	public function newPolicyCodex() {
	return new PhabricatorCalendarEventPolicyCodex();
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PhabricatorCalendarEventEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PhabricatorCalendarEventTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}

	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {
	return ($phid == $this->getHostPHID());
	}

	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	public function getUsersToNotifyOfTokenGiven() {
	return array($this->getHostPHID());
	}

	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$invitees = id(new PhabricatorCalendarEventInvitee())->loadAllWhere(
	'eventPHID = %s',
	$this->getPHID());
	foreach ($invitees as $invitee) {
	$invitee->delete();
	}

	$notifications = id(new PhabricatorCalendarNotification())->loadAllWhere(
	'eventPHID = %s',
	$this->getPHID());
	foreach ($notifications as $notification) {
	$notification->delete();
	}

	$this->delete();
	$this->saveTransaction();
	}

	/* -( PhabricatorSpacesInterface )----------------------------------------- */


	public function getSpacePHID() {
	return $this->spacePHID;
	}


	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new PhabricatorCalendarEventFulltextEngine();
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('name')
	->setType('string')
	->setDescription(pht('The name of the event.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('description')
	->setType('string')
	->setDescription(pht('The event description.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('isAllDay')
	->setType('bool')
	->setDescription(pht('True if the event is an all day event.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('startDateTime')
	->setType('datetime')
	->setDescription(pht('Start date and time of the event.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('endDateTime')
	->setType('datetime')
	->setDescription(pht('End date and time of the event.')),
	);
	}

	public function getFieldValuesForConduit() {
	$start_datetime = $this->newStartDateTime();
	$end_datetime = $this->newEndDateTime();

	return array(
	'name' => $this->getName(),
	'description' => $this->getDescription(),
	'isAllDay' => (bool)$this->getIsAllDay(),
	'startDateTime' => $this->getConduitDateTime($start_datetime),
	'endDateTime' => $this->getConduitDateTime($end_datetime),
	);
	}

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

	private function getConduitDateTime($datetime) {
	if (!$datetime) {
	return null;
	}

	$epoch = $datetime->getEpoch();

	// TODO: Possibly pass the actual viewer in from the Conduit stuff, or
	// retain it when setting the viewer timezone?
	$viewer = id(new PhabricatorUser())
	->overrideTimezoneIdentifier($this->viewerTimezone);

	return array(
	'epoch' => (int)$epoch,
	'display' => array(
	'default' => phabricator_datetime($epoch, $viewer),
	),
	'iso8601' => $datetime->getISO8601(),
	'timezone' => $this->viewerTimezone,
	);
	}

	}
	diff --git a/src/applications/differential/storage/DifferentialInlineComment.php b/src/applications/differential/storage/DifferentialInlineComment.php
	index c27d59bbe3..bdc231671f 100644
	--- a/src/applications/differential/storage/DifferentialInlineComment.php
	+++ b/src/applications/differential/storage/DifferentialInlineComment.php
	@@ -1,284 +1,284 @@
	<?php

	final class DifferentialInlineComment
	extends Phobject
	implements PhabricatorInlineCommentInterface {

	private $proxy;
	private $syntheticAuthor;
	private $isGhost;

	public function __construct() {
	$this->proxy = new DifferentialTransactionComment();
	}

	public function __clone() {
	$this->proxy = clone $this->proxy;
	}

	public function getTransactionCommentForSave() {
	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorOldWorldContentSource::SOURCECONST);

	$this->proxy
	->setViewPolicy('public')
	->setEditPolicy($this->getAuthorPHID())
	->setContentSource($content_source)
	->attachIsHidden(false)
	->setCommentVersion(1);

	return $this->proxy;
	}

	public function openTransaction() {
	$this->proxy->openTransaction();
	}

	public function saveTransaction() {
	$this->proxy->saveTransaction();
	}

	public function save() {
	$this->getTransactionCommentForSave()->save();

	return $this;
	}

	public function delete() {
	$this->proxy->delete();

	return $this;
	}

	public function supportsHiding() {
	if ($this->getSyntheticAuthor()) {
	return false;
	}
	return true;
	}

	public function isHidden() {
	if (!$this->supportsHiding()) {
	return false;
	}
	return $this->proxy->getIsHidden();
	}

	public function getID() {
	return $this->proxy->getID();
	}

	public function getPHID() {
	return $this->proxy->getPHID();
	}

	public static function newFromModernComment(
	DifferentialTransactionComment $comment) {

	$obj = new DifferentialInlineComment();
	$obj->proxy = $comment;

	return $obj;
	}

	public function setSyntheticAuthor($synthetic_author) {
	$this->syntheticAuthor = $synthetic_author;
	return $this;
	}

	public function getSyntheticAuthor() {
	return $this->syntheticAuthor;
	}

	public function isCompatible(PhabricatorInlineCommentInterface $comment) {
	return
	($this->getAuthorPHID() === $comment->getAuthorPHID()) &&
	($this->getSyntheticAuthor() === $comment->getSyntheticAuthor()) &&
	($this->getContent() === $comment->getContent());
	}

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

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

	public function isDraft() {
	return !$this->proxy->getTransactionPHID();
	}

	public function setChangesetID($id) {
	$this->proxy->setChangesetID($id);
	return $this;
	}

	public function getChangesetID() {
	return $this->proxy->getChangesetID();
	}

	public function setIsNewFile($is_new) {
	$this->proxy->setIsNewFile($is_new);
	return $this;
	}

	public function getIsNewFile() {
	return $this->proxy->getIsNewFile();
	}

	public function setLineNumber($number) {
	$this->proxy->setLineNumber($number);
	return $this;
	}

	public function getLineNumber() {
	return $this->proxy->getLineNumber();
	}

	public function setLineLength($length) {
	$this->proxy->setLineLength($length);
	return $this;
	}

	public function getLineLength() {
	return $this->proxy->getLineLength();
	}

	public function setCache($cache) {
	return $this;
	}

	public function getCache() {
	return null;
	}

	public function setAuthorPHID($phid) {
	$this->proxy->setAuthorPHID($phid);
	return $this;
	}

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

	public function setRevision(DifferentialRevision $revision) {
	$this->proxy->setRevisionPHID($revision->getPHID());
	return $this;
	}

	public function getRevisionPHID() {
	return $this->proxy->getRevisionPHID();
	}

	// Although these are purely transitional, they're also extra dumb.

	public function setRevisionID($revision_id) {
	$revision = id(new DifferentialRevision())->load($revision_id);
	return $this->setRevision($revision);
	}

	public function getRevisionID() {
	$phid = $this->proxy->getRevisionPHID();
	if (!$phid) {
	return null;
	}

	$revision = id(new DifferentialRevision())->loadOneWhere(
	'phid = %s',
	$phid);
	if (!$revision) {
	return null;
	}
	return $revision->getID();
	}

	// When setting a comment ID, we also generate a phantom transaction PHID for
	// the future transaction.

	public function setCommentID($id) {
	$this->proxy->setTransactionPHID(
	PhabricatorPHID::generateNewPHID(
	PhabricatorApplicationTransactionTransactionPHIDType::TYPECONST,
	DifferentialRevisionPHIDType::TYPECONST));
	return $this;
	}

	public function setReplyToCommentPHID($phid) {
	$this->proxy->setReplyToCommentPHID($phid);
	return $this;
	}

	public function getReplyToCommentPHID() {
	return $this->proxy->getReplyToCommentPHID();
	}

	public function setHasReplies($has_replies) {
	$this->proxy->setHasReplies($has_replies);
	return $this;
	}

	public function getHasReplies() {
	return $this->proxy->getHasReplies();
	}

	public function setIsDeleted($is_deleted) {
	$this->proxy->setIsDeleted($is_deleted);
	return $this;
	}

	public function getIsDeleted() {
	return $this->proxy->getIsDeleted();
	}

	public function setFixedState($state) {
	$this->proxy->setFixedState($state);
	return $this;
	}

	public function getFixedState() {
	return $this->proxy->getFixedState();
	}

	public function setIsGhost($is_ghost) {
	$this->isGhost = $is_ghost;
	return $this;
	}

	public function getIsGhost() {
	return $this->isGhost;
	}

	public function makeEphemeral() {
	$this->proxy->makeEphemeral();
	return $this;
	}


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


	public function getMarkupFieldKey($field) {
	- // We can't use ID because synthetic comments don't have it.
	- return 'DI:'.PhabricatorHash::digest($this->getContent());
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newDifferentialMarkupEngine();
	}

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

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

	public function shouldUseMarkupCache($field) {
	// Only cache submitted comments.
	return ($this->getID() && !$this->isDraft());
	}

	}
	diff --git a/src/applications/legalpad/storage/LegalpadDocumentBody.php b/src/applications/legalpad/storage/LegalpadDocumentBody.php
	index a3fdf20f5f..001e38ebf3 100644
	--- a/src/applications/legalpad/storage/LegalpadDocumentBody.php
	+++ b/src/applications/legalpad/storage/LegalpadDocumentBody.php
	@@ -1,77 +1,77 @@
	<?php

	final class LegalpadDocumentBody extends LegalpadDAO
	implements
	PhabricatorMarkupInterface {

	const MARKUP_FIELD_TEXT = 'markup:text ';

	protected $phid;
	protected $creatorPHID;
	protected $documentPHID;
	protected $version;
	protected $title;
	protected $text;

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'version' => 'uint32',
	'title' => 'text255',
	'text' => 'text?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_document' => array(
	'columns' => array('documentPHID', 'version'),
	'unique' => true,
	),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorPHIDConstants::PHID_TYPE_LEGB);
	}

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


	public function getMarkupFieldKey($field) {
	- $hash = PhabricatorHash::digest($this->getMarkupText($field));
	- return 'LEGB:'.$hash;
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newMarkupEngine(array());
	}

	public function getMarkupText($field) {
	switch ($field) {
	case self::MARKUP_FIELD_TEXT:
	$text = $this->getText();
	break;
	default:
	throw new Exception(pht('Unknown field: %s', $field));
	break;
	}

	return $text;
	}

	public function didMarkupText($field, $output, PhutilMarkupEngine $engine) {
	require_celerity_resource('phabricator-remarkup-css');
	return phutil_tag(
	'div',
	array(
	'class' => 'phabricator-remarkup',
	),
	$output);
	}

	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}

	}
	diff --git a/src/applications/maniphest/storage/ManiphestTask.php b/src/applications/maniphest/storage/ManiphestTask.php
	index ebcdef691d..16937da2f2 100644
	--- a/src/applications/maniphest/storage/ManiphestTask.php
	+++ b/src/applications/maniphest/storage/ManiphestTask.php
	@@ -1,591 +1,590 @@
	<?php

	final class ManiphestTask extends ManiphestDAO
	implements
	PhabricatorSubscribableInterface,
	PhabricatorMarkupInterface,
	PhabricatorPolicyInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorFlaggableInterface,
	PhabricatorMentionableInterface,
	PhrequentTrackableInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorDestructibleInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorProjectInterface,
	PhabricatorSpacesInterface,
	PhabricatorConduitResultInterface,
	PhabricatorFulltextInterface,
	DoorkeeperBridgedObjectInterface,
	PhabricatorEditEngineSubtypeInterface,
	PhabricatorEditEngineLockableInterface {

	const MARKUP_FIELD_DESCRIPTION = 'markup:desc';

	protected $authorPHID;
	protected $ownerPHID;

	protected $status;
	protected $priority;
	protected $subpriority = 0;

	protected $title = '';
	protected $originalTitle = '';
	protected $description = '';
	protected $originalEmailSource;
	protected $mailKey;
	protected $viewPolicy = PhabricatorPolicies::POLICY_USER;
	protected $editPolicy = PhabricatorPolicies::POLICY_USER;

	protected $ownerOrdering;
	protected $spacePHID;
	protected $bridgedObjectPHID;
	protected $properties = array();
	protected $points;
	protected $subtype;

	private $subscriberPHIDs = self::ATTACHABLE;
	private $groupByProjectPHID = self::ATTACHABLE;
	private $customFields = self::ATTACHABLE;
	private $edgeProjectPHIDs = self::ATTACHABLE;
	private $bridgedObject = self::ATTACHABLE;

	public static function initializeNewTask(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorManiphestApplication'))
	->executeOne();

	$view_policy = $app->getPolicy(ManiphestDefaultViewCapability::CAPABILITY);
	$edit_policy = $app->getPolicy(ManiphestDefaultEditCapability::CAPABILITY);

	return id(new ManiphestTask())
	->setStatus(ManiphestTaskStatus::getDefaultStatus())
	->setPriority(ManiphestTaskPriority::getDefaultPriority())
	->setAuthorPHID($actor->getPHID())
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->setSpacePHID($actor->getDefaultSpacePHID())
	->setSubtype(PhabricatorEditEngineSubtype::SUBTYPE_DEFAULT)
	->attachProjectPHIDs(array())
	->attachSubscriberPHIDs(array());
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'properties' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'ownerPHID' => 'phid?',
	'status' => 'text12',
	'priority' => 'uint32',
	'title' => 'sort',
	'originalTitle' => 'text',
	'description' => 'text',
	'mailKey' => 'bytes20',
	'ownerOrdering' => 'text64?',
	'originalEmailSource' => 'text255?',
	'subpriority' => 'double',
	'points' => 'double?',
	'bridgedObjectPHID' => 'phid?',
	'subtype' => 'text64',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'priority' => array(
	'columns' => array('priority', 'status'),
	),
	'status' => array(
	'columns' => array('status'),
	),
	'ownerPHID' => array(
	'columns' => array('ownerPHID', 'status'),
	),
	'authorPHID' => array(
	'columns' => array('authorPHID', 'status'),
	),
	'ownerOrdering' => array(
	'columns' => array('ownerOrdering'),
	),
	'priority_2' => array(
	'columns' => array('priority', 'subpriority'),
	),
	'key_dateCreated' => array(
	'columns' => array('dateCreated'),
	),
	'key_dateModified' => array(
	'columns' => array('dateModified'),
	),
	'key_title' => array(
	'columns' => array('title(64)'),
	),
	'key_bridgedobject' => array(
	'columns' => array('bridgedObjectPHID'),
	'unique' => true,
	),
	'key_subtype' => array(
	'columns' => array('subtype'),
	),
	),
	) + parent::getConfiguration();
	}

	public function loadDependsOnTaskPHIDs() {
	return PhabricatorEdgeQuery::loadDestinationPHIDs(
	$this->getPHID(),
	ManiphestTaskDependsOnTaskEdgeType::EDGECONST);
	}

	public function loadDependedOnByTaskPHIDs() {
	return PhabricatorEdgeQuery::loadDestinationPHIDs(
	$this->getPHID(),
	ManiphestTaskDependedOnByTaskEdgeType::EDGECONST);
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(ManiphestTaskPHIDType::TYPECONST);
	}

	public function getSubscriberPHIDs() {
	return $this->assertAttached($this->subscriberPHIDs);
	}

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

	public function attachProjectPHIDs(array $phids) {
	$this->edgeProjectPHIDs = $phids;
	return $this;
	}

	public function attachSubscriberPHIDs(array $phids) {
	$this->subscriberPHIDs = $phids;
	return $this;
	}

	public function setOwnerPHID($phid) {
	$this->ownerPHID = nonempty($phid, null);
	return $this;
	}

	public function setTitle($title) {
	$this->title = $title;
	if (!$this->getID()) {
	$this->originalTitle = $title;
	}
	return $this;
	}

	public function getMonogram() {
	return 'T'.$this->getID();
	}

	public function getURI() {
	return '/'.$this->getMonogram();
	}

	public function attachGroupByProjectPHID($phid) {
	$this->groupByProjectPHID = $phid;
	return $this;
	}

	public function getGroupByProjectPHID() {
	return $this->assertAttached($this->groupByProjectPHID);
	}

	public function save() {
	if (!$this->mailKey) {
	$this->mailKey = Filesystem::readRandomCharacters(20);
	}

	$result = parent::save();

	return $result;
	}

	public function isClosed() {
	return ManiphestTaskStatus::isClosedStatus($this->getStatus());
	}

	public function isLocked() {
	return ManiphestTaskStatus::isLockedStatus($this->getStatus());
	}

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

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

	public function getCoverImageFilePHID() {
	return idx($this->properties, 'cover.filePHID');
	}

	public function getCoverImageThumbnailPHID() {
	return idx($this->properties, 'cover.thumbnailPHID');
	}

	public function getWorkboardOrderVectors() {
	return array(
	PhabricatorProjectColumn::ORDER_PRIORITY => array(
	(int)-$this->getPriority(),
	(double)-$this->getSubpriority(),
	(int)-$this->getID(),
	),
	);
	}

	private function comparePriorityTo(ManiphestTask $other) {
	$upri = $this->getPriority();
	$vpri = $other->getPriority();

	if ($upri != $vpri) {
	return ($upri - $vpri);
	}

	$usub = $this->getSubpriority();
	$vsub = $other->getSubpriority();

	if ($usub != $vsub) {
	return ($usub - $vsub);
	}

	$uid = $this->getID();
	$vid = $other->getID();

	if ($uid != $vid) {
	return ($uid - $vid);
	}

	return 0;
	}

	public function isLowerPriorityThan(ManiphestTask $other) {
	return ($this->comparePriorityTo($other) < 0);
	}

	public function isHigherPriorityThan(ManiphestTask $other) {
	return ($this->comparePriorityTo($other) > 0);
	}

	public function getWorkboardProperties() {
	return array(
	'status' => $this->getStatus(),
	'points' => (double)$this->getPoints(),
	);
	}


	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {
	return ($phid == $this->getOwnerPHID());
	}


	/* -( Markup Interface )--------------------------------------------------- */


	/**
	* @task markup
	*/
	public function getMarkupFieldKey($field) {
	- $hash = PhabricatorHash::digest($this->getMarkupText($field));
	- $id = $this->getID();
	- return "maniphest:T{$id}:{$field}:{$hash}";
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}


	/**
	* @task markup
	*/
	public function getMarkupText($field) {
	return $this->getDescription();
	}


	/**
	* @task markup
	*/
	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newManiphestMarkupEngine();
	}


	/**
	* @task markup
	*/
	public function didMarkupText(
	$field,
	$output,
	PhutilMarkupEngine $engine) {
	return $output;
	}


	/**
	* @task markup
	*/
	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}


	/* -( Policy Interface )--------------------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_INTERACT,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_INTERACT:
	if ($this->isLocked()) {
	return PhabricatorPolicies::POLICY_NOONE;
	} else {
	return $this->getViewPolicy();
	}
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $user) {
	// The owner of a task can always view and edit it.
	$owner_phid = $this->getOwnerPHID();
	if ($owner_phid) {
	$user_phid = $user->getPHID();
	if ($user_phid == $owner_phid) {
	return true;
	}
	}

	return false;
	}

	public function describeAutomaticCapability($capability) {
	return pht('The owner of a task can always view and edit it.');
	}


	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	public function getUsersToNotifyOfTokenGiven() {
	// Sort of ambiguous who this was intended for; just let them both know.
	return array_filter(
	array_unique(
	array(
	$this->getAuthorPHID(),
	$this->getOwnerPHID(),
	)));
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('maniphest.fields');
	}

	public function getCustomFieldBaseClass() {
	return 'ManiphestCustomField';
	}

	public function getCustomFields() {
	return $this->assertAttached($this->customFields);
	}

	public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
	$this->customFields = $fields;
	return $this;
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();
	$this->saveTransaction();
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new ManiphestTransactionEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new ManiphestTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}


	/* -( PhabricatorSpacesInterface )----------------------------------------- */


	public function getSpacePHID() {
	return $this->spacePHID;
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('title')
	->setType('string')
	->setDescription(pht('The title of the task.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('description')
	->setType('remarkup')
	->setDescription(pht('The task description.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('authorPHID')
	->setType('phid')
	->setDescription(pht('Original task author.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('ownerPHID')
	->setType('phid?')
	->setDescription(pht('Current task owner, if task is assigned.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('status')
	->setType('map<string, wild>')
	->setDescription(pht('Information about task status.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('priority')
	->setType('map<string, wild>')
	->setDescription(pht('Information about task priority.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('points')
	->setType('points')
	->setDescription(pht('Point value of the task.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('subtype')
	->setType('string')
	->setDescription(pht('Subtype of the task.')),
	);
	}

	public function getFieldValuesForConduit() {
	$status_value = $this->getStatus();
	$status_info = array(
	'value' => $status_value,
	'name' => ManiphestTaskStatus::getTaskStatusName($status_value),
	'color' => ManiphestTaskStatus::getStatusColor($status_value),
	);

	$priority_value = (int)$this->getPriority();
	$priority_info = array(
	'value' => $priority_value,
	'subpriority' => (double)$this->getSubpriority(),
	'name' => ManiphestTaskPriority::getTaskPriorityName($priority_value),
	'color' => ManiphestTaskPriority::getTaskPriorityColor($priority_value),
	);

	return array(
	'name' => $this->getTitle(),
	'description' => array(
	'raw' => $this->getDescription(),
	),
	'authorPHID' => $this->getAuthorPHID(),
	'ownerPHID' => $this->getOwnerPHID(),
	'status' => $status_info,
	'priority' => $priority_info,
	'points' => $this->getPoints(),
	'subtype' => $this->getSubtype(),
	);
	}

	public function getConduitSearchAttachments() {
	return array(
	id(new PhabricatorBoardColumnsSearchEngineAttachment())
	->setAttachmentKey('columns'),
	);
	}


	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new ManiphestTaskFulltextEngine();
	}


	/* -( DoorkeeperBridgedObjectInterface )----------------------------------- */


	public function getBridgedObject() {
	return $this->assertAttached($this->bridgedObject);
	}

	public function attachBridgedObject(
	DoorkeeperExternalObject $object = null) {
	$this->bridgedObject = $object;
	return $this;
	}


	/* -( PhabricatorEditEngineSubtypeInterface )------------------------------ */


	public function getEditEngineSubtype() {
	return $this->getSubtype();
	}

	public function setEditEngineSubtype($value) {
	return $this->setSubtype($value);
	}

	public function newEditEngineSubtypeMap() {
	$config = PhabricatorEnv::getEnvConfig('maniphest.subtypes');
	return PhabricatorEditEngineSubtype::newSubtypeMap($config);
	}


	/* -( PhabricatorEditEngineLockableInterface )----------------------------- */


	public function newEditEngineLock() {
	return new ManiphestTaskEditEngineLock();
	}

	}
	diff --git a/src/applications/phame/storage/PhameBlog.php b/src/applications/phame/storage/PhameBlog.php
	index 32cb6db543..bd4954d0ab 100644
	--- a/src/applications/phame/storage/PhameBlog.php
	+++ b/src/applications/phame/storage/PhameBlog.php
	@@ -1,407 +1,407 @@
	<?php

	final class PhameBlog extends PhameDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorMarkupInterface,
	PhabricatorSubscribableInterface,
	PhabricatorFlaggableInterface,
	PhabricatorProjectInterface,
	PhabricatorDestructibleInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorConduitResultInterface,
	PhabricatorFulltextInterface {

	const MARKUP_FIELD_DESCRIPTION = 'markup:description';

	protected $name;
	protected $subtitle;
	protected $description;
	protected $domain;
	protected $domainFullURI;
	protected $parentSite;
	protected $parentDomain;
	protected $configData;
	protected $creatorPHID;
	protected $viewPolicy;
	protected $editPolicy;
	protected $status;
	protected $mailKey;
	protected $profileImagePHID;
	protected $headerImagePHID;

	private $profileImageFile = self::ATTACHABLE;
	private $headerImageFile = self::ATTACHABLE;

	const STATUS_ACTIVE = 'active';
	const STATUS_ARCHIVED = 'archived';

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'configData' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'text64',
	'subtitle' => 'text64',
	'description' => 'text',
	'domain' => 'text128?',
	'domainFullURI' => 'text128?',
	'parentSite' => 'text128?',
	'parentDomain' => 'text128?',
	'status' => 'text32',
	'mailKey' => 'bytes20',
	'profileImagePHID' => 'phid?',
	'headerImagePHID' => 'phid?',

	// T6203/NULLABILITY
	// These policies should always be non-null.
	'editPolicy' => 'policy?',
	'viewPolicy' => 'policy?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'domain' => array(
	'columns' => array('domain'),
	'unique' => true,
	),
	),
	) + parent::getConfiguration();
	}

	public function save() {
	if (!$this->getMailKey()) {
	$this->setMailKey(Filesystem::readRandomCharacters(20));
	}
	return parent::save();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorPhameBlogPHIDType::TYPECONST);
	}

	public static function initializeNewBlog(PhabricatorUser $actor) {
	$blog = id(new PhameBlog())
	->setCreatorPHID($actor->getPHID())
	->setStatus(self::STATUS_ACTIVE)
	->setViewPolicy(PhabricatorPolicies::getMostOpenPolicy())
	->setEditPolicy(PhabricatorPolicies::POLICY_USER);
	return $blog;
	}

	public function isArchived() {
	return ($this->getStatus() == self::STATUS_ARCHIVED);
	}

	public static function getStatusNameMap() {
	return array(
	self::STATUS_ACTIVE => pht('Active'),
	self::STATUS_ARCHIVED => pht('Archived'),
	);
	}

	/**
	* Makes sure a given custom blog uri is properly configured in DNS
	* to point at this Phabricator instance. If there is an error in
	* the configuration, return a string describing the error and how
	* to fix it. If there is no error, return an empty string.
	*
	* @return string
	*/
	public function validateCustomDomain($domain_full_uri) {
	$example_domain = 'http://blog.example.com/';
	$label = pht('Invalid');

	// note this "uri" should be pretty busted given the desired input
	// so just use it to test if there's a protocol specified
	$uri = new PhutilURI($domain_full_uri);
	$domain = $uri->getDomain();
	$protocol = $uri->getProtocol();
	$path = $uri->getPath();
	$supported_protocols = array('http', 'https');

	if (!in_array($protocol, $supported_protocols)) {
	return array(
	$label,
	pht(
	'The custom domain should include a valid protocol in the URI '.
	'(for example, "%s"). Valid protocols are "http" or "https".',
	$example_domain),
	);
	}

	if (strlen($path) && $path != '/') {
	return array(
	$label,
	pht(
	'The custom domain should not specify a path (hosting a Phame '.
	'blog at a path is currently not supported). Instead, just provide '.
	'the bare domain name (for example, "%s").',
	$example_domain),
	);
	}

	if (strpos($domain, '.') === false) {
	return array(
	$label,
	pht(
	'The custom domain should contain at least one dot (.) because '.
	'some browsers fail to set cookies on domains without a dot. '.
	'Instead, use a normal looking domain name like "%s".',
	$example_domain),
	);
	}

	if (!PhabricatorEnv::getEnvConfig('policy.allow-public')) {
	$href = PhabricatorEnv::getProductionURI(
	'/config/edit/policy.allow-public/');
	return array(
	pht('Fix Configuration'),
	pht(
	'For custom domains to work, this Phabricator instance must be '.
	'configured to allow the public access policy. Configure this '.
	'setting %s, or ask an administrator to configure this setting. '.
	'The domain can be specified later once this setting has been '.
	'changed.',
	phutil_tag(
	'a',
	array('href' => $href),
	pht('here'))),
	);
	}

	return null;
	}

	public function getLiveURI() {
	if (strlen($this->getDomain())) {
	return $this->getExternalLiveURI();
	} else {
	return $this->getInternalLiveURI();
	}
	}

	public function getExternalLiveURI() {
	$uri = new PhutilURI($this->getDomainFullURI());
	PhabricatorEnv::requireValidRemoteURIForLink($uri);
	return (string)$uri;
	}

	public function getExternalParentURI() {
	$uri = $this->getParentDomain();
	PhabricatorEnv::requireValidRemoteURIForLink($uri);
	return (string)$uri;
	}

	public function getInternalLiveURI() {
	return '/phame/live/'.$this->getID().'/';
	}

	public function getViewURI() {
	return '/phame/blog/view/'.$this->getID().'/';
	}

	public function getManageURI() {
	return '/phame/blog/manage/'.$this->getID().'/';
	}

	public function getProfileImageURI() {
	return $this->getProfileImageFile()->getBestURI();
	}

	public function attachProfileImageFile(PhabricatorFile $file) {
	$this->profileImageFile = $file;
	return $this;
	}

	public function getProfileImageFile() {
	return $this->assertAttached($this->profileImageFile);
	}

	public function getHeaderImageURI() {
	return $this->getHeaderImageFile()->getBestURI();
	}

	public function attachHeaderImageFile(PhabricatorFile $file) {
	$this->headerImageFile = $file;
	return $this;
	}

	public function getHeaderImageFile() {
	return $this->assertAttached($this->headerImageFile);
	}


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


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}


	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $user) {
	$can_edit = PhabricatorPolicyCapability::CAN_EDIT;

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	// Users who can edit or post to a blog can always view it.
	if (PhabricatorPolicyFilter::hasCapability($user, $this, $can_edit)) {
	return true;
	}
	break;
	}

	return false;
	}


	public function describeAutomaticCapability($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return pht(
	'Users who can edit a blog can always view it.');
	}

	return null;
	}


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


	public function getMarkupFieldKey($field) {
	- $hash = PhabricatorHash::digest($this->getMarkupText($field));
	- return $this->getPHID().':'.$field.':'.$hash;
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}


	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newPhameMarkupEngine();
	}


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


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

	public function shouldUseMarkupCache($field) {
	return (bool)$this->getPHID();
	}

	/* -( PhabricatorDestructibleInterface )----------------------------------- */

	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();

	$posts = id(new PhamePostQuery())
	->setViewer($engine->getViewer())
	->withBlogPHIDs(array($this->getPHID()))
	->execute();
	foreach ($posts as $post) {
	$engine->destroyObject($post);
	}
	$this->delete();

	$this->saveTransaction();
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PhameBlogEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PhameBlogTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {
	return $timeline;
	}


	/* -( PhabricatorSubscribableInterface Implementation )-------------------- */


	public function isAutomaticallySubscribed($phid) {
	return false;
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('name')
	->setType('string')
	->setDescription(pht('The name of the blog.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('description')
	->setType('string')
	->setDescription(pht('Blog description.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('status')
	->setType('string')
	->setDescription(pht('Archived or active status.')),
	);
	}

	public function getFieldValuesForConduit() {
	return array(
	'name' => $this->getName(),
	'description' => $this->getDescription(),
	'status' => $this->getStatus(),
	);
	}

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


	/* -( PhabricatorFulltextInterface )--------------------------------------- */

	public function newFulltextEngine() {
	return new PhameBlogFulltextEngine();
	}

	}
	diff --git a/src/applications/phame/storage/PhamePost.php b/src/applications/phame/storage/PhamePost.php
	index 6e9e005bfa..f87a37e7a4 100644
	--- a/src/applications/phame/storage/PhamePost.php
	+++ b/src/applications/phame/storage/PhamePost.php
	@@ -1,389 +1,389 @@
	<?php

	final class PhamePost extends PhameDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorMarkupInterface,
	PhabricatorFlaggableInterface,
	PhabricatorProjectInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorSubscribableInterface,
	PhabricatorDestructibleInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorConduitResultInterface,
	PhabricatorFulltextInterface {

	const MARKUP_FIELD_BODY = 'markup:body';
	const MARKUP_FIELD_SUMMARY = 'markup:summary';

	protected $bloggerPHID;
	protected $title;
	protected $subtitle;
	protected $phameTitle;
	protected $body;
	protected $visibility;
	protected $configData;
	protected $datePublished;
	protected $blogPHID;
	protected $mailKey;
	protected $headerImagePHID;

	private $blog = self::ATTACHABLE;
	private $headerImageFile = self::ATTACHABLE;

	public static function initializePost(
	PhabricatorUser $blogger,
	PhameBlog $blog) {

	$post = id(new PhamePost())
	->setBloggerPHID($blogger->getPHID())
	->setBlogPHID($blog->getPHID())
	->attachBlog($blog)
	->setDatePublished(PhabricatorTime::getNow())
	->setVisibility(PhameConstants::VISIBILITY_PUBLISHED);

	return $post;
	}

	public function attachBlog(PhameBlog $blog) {
	$this->blog = $blog;
	return $this;
	}

	public function getBlog() {
	return $this->assertAttached($this->blog);
	}

	public function getMonogram() {
	return 'J'.$this->getID();
	}

	public function getLiveURI() {
	$blog = $this->getBlog();
	$is_draft = $this->isDraft();
	$is_archived = $this->isArchived();
	if (strlen($blog->getDomain()) && !$is_draft && !$is_archived) {
	return $this->getExternalLiveURI();
	} else {
	return $this->getInternalLiveURI();
	}
	}

	public function getExternalLiveURI() {
	$id = $this->getID();
	$slug = $this->getSlug();
	$path = "/post/{$id}/{$slug}/";

	$domain = $this->getBlog()->getDomain();

	return (string)id(new PhutilURI('http://'.$domain))
	->setPath($path);
	}

	public function getInternalLiveURI() {
	$id = $this->getID();
	$slug = $this->getSlug();
	$blog_id = $this->getBlog()->getID();
	return "/phame/live/{$blog_id}/post/{$id}/{$slug}/";
	}

	public function getViewURI() {
	$id = $this->getID();
	$slug = $this->getSlug();
	return "/phame/post/view/{$id}/{$slug}/";
	}

	public function getBestURI($is_live, $is_external) {
	if ($is_live) {
	if ($is_external) {
	return $this->getExternalLiveURI();
	} else {
	return $this->getInternalLiveURI();
	}
	} else {
	return $this->getViewURI();
	}
	}

	public function getEditURI() {
	return '/phame/post/edit/'.$this->getID().'/';
	}

	public function isDraft() {
	return ($this->getVisibility() == PhameConstants::VISIBILITY_DRAFT);
	}

	public function isArchived() {
	return ($this->getVisibility() == PhameConstants::VISIBILITY_ARCHIVED);
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'configData' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'title' => 'text255',
	'subtitle' => 'text64',
	'phameTitle' => 'sort64?',
	'visibility' => 'uint32',
	'mailKey' => 'bytes20',
	'headerImagePHID' => 'phid?',

	// T6203/NULLABILITY
	// These seem like they should always be non-null?
	'blogPHID' => 'phid?',
	'body' => 'text?',
	'configData' => 'text?',

	// T6203/NULLABILITY
	// This one probably should be nullable?
	'datePublished' => 'epoch',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'bloggerPosts' => array(
	'columns' => array(
	'bloggerPHID',
	'visibility',
	'datePublished',
	'id',
	),
	),
	),
	) + parent::getConfiguration();
	}

	public function save() {
	if (!$this->getMailKey()) {
	$this->setMailKey(Filesystem::readRandomCharacters(20));
	}
	return parent::save();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorPhamePostPHIDType::TYPECONST);
	}

	public function getSlug() {
	return PhabricatorSlug::normalizeProjectSlug($this->getTitle());
	}

	public function getHeaderImageURI() {
	return $this->getHeaderImageFile()->getBestURI();
	}

	public function attachHeaderImageFile(PhabricatorFile $file) {
	$this->headerImageFile = $file;
	return $this;
	}

	public function getHeaderImageFile() {
	return $this->assertAttached($this->headerImageFile);
	}


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


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	// Draft posts are visible only to the author. Published posts are visible
	// to whoever the blog is visible to.

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	if (!$this->isDraft() && !$this->isArchived() && $this->getBlog()) {
	return $this->getBlog()->getViewPolicy();
	} else if ($this->getBlog()) {
	return $this->getBlog()->getEditPolicy();
	} else {
	return PhabricatorPolicies::POLICY_NOONE;
	}
	break;
	case PhabricatorPolicyCapability::CAN_EDIT:
	if ($this->getBlog()) {
	return $this->getBlog()->getEditPolicy();
	} else {
	return PhabricatorPolicies::POLICY_NOONE;
	}
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $user) {
	// A blog post's author can always view it.

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	case PhabricatorPolicyCapability::CAN_EDIT:
	return ($user->getPHID() == $this->getBloggerPHID());
	}
	}

	public function describeAutomaticCapability($capability) {
	return pht('The author of a blog post can always view and edit it.');
	}


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


	public function getMarkupFieldKey($field) {
	- $hash = PhabricatorHash::digest($this->getMarkupText($field));
	- return $this->getPHID().':'.$field.':'.$hash;
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newPhameMarkupEngine();
	}

	public function getMarkupText($field) {
	switch ($field) {
	case self::MARKUP_FIELD_BODY:
	return $this->getBody();
	case self::MARKUP_FIELD_SUMMARY:
	return PhabricatorMarkupEngine::summarize($this->getBody());
	}
	}

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

	public function shouldUseMarkupCache($field) {
	return (bool)$this->getPHID();
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PhamePostEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PhamePostTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();
	$this->saveTransaction();
	}


	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	public function getUsersToNotifyOfTokenGiven() {
	return array(
	$this->getBloggerPHID(),
	);
	}


	/* -( PhabricatorSubscribableInterface Implementation )-------------------- */


	public function isAutomaticallySubscribed($phid) {
	return ($this->bloggerPHID == $phid);
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('title')
	->setType('string')
	->setDescription(pht('Title of the post.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('slug')
	->setType('string')
	->setDescription(pht('Slug for the post.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('blogPHID')
	->setType('phid')
	->setDescription(pht('PHID of the blog that the post belongs to.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('authorPHID')
	->setType('phid')
	->setDescription(pht('PHID of the author of the post.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('body')
	->setType('string')
	->setDescription(pht('Body of the post.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('datePublished')
	->setType('epoch?')
	->setDescription(pht('Publish date, if the post has been published.')),

	);
	}

	public function getFieldValuesForConduit() {
	if ($this->isDraft()) {
	$date_published = null;
	} else if ($this->isArchived()) {
	$date_published = null;
	} else {
	$date_published = (int)$this->getDatePublished();
	}

	return array(
	'title' => $this->getTitle(),
	'slug' => $this->getSlug(),
	'blogPHID' => $this->getBlogPHID(),
	'authorPHID' => $this->getBloggerPHID(),
	'body' => $this->getBody(),
	'datePublished' => $date_published,
	);
	}

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


	/* -( PhabricatorFulltextInterface )--------------------------------------- */

	public function newFulltextEngine() {
	return new PhamePostFulltextEngine();
	}

	}
	diff --git a/src/applications/pholio/storage/PholioImage.php b/src/applications/pholio/storage/PholioImage.php
	index e81c71a05a..70f6e8b8c4 100644
	--- a/src/applications/pholio/storage/PholioImage.php
	+++ b/src/applications/pholio/storage/PholioImage.php
	@@ -1,122 +1,122 @@
	<?php

	final class PholioImage extends PholioDAO
	implements
	PhabricatorMarkupInterface,
	PhabricatorPolicyInterface {

	const MARKUP_FIELD_DESCRIPTION = 'markup:description';

	protected $mockID;
	protected $filePHID;
	protected $name = '';
	protected $description = '';
	protected $sequence;
	protected $isObsolete = 0;
	protected $replacesImagePHID = null;

	private $inlineComments = self::ATTACHABLE;
	private $file = self::ATTACHABLE;
	private $mock = self::ATTACHABLE;

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'mockID' => 'id?',
	'name' => 'text128',
	'description' => 'text',
	'sequence' => 'uint32',
	'isObsolete' => 'bool',
	'replacesImagePHID' => 'phid?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'keyPHID' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'mockID' => array(
	'columns' => array('mockID', 'isObsolete', 'sequence'),
	),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(PholioImagePHIDType::TYPECONST);
	}

	public function attachFile(PhabricatorFile $file) {
	$this->file = $file;
	return $this;
	}

	public function getFile() {
	$this->assertAttached($this->file);
	return $this->file;
	}

	public function attachMock(PholioMock $mock) {
	$this->mock = $mock;
	return $this;
	}

	public function getMock() {
	$this->assertAttached($this->mock);
	return $this->mock;
	}


	public function attachInlineComments(array $inline_comments) {
	assert_instances_of($inline_comments, 'PholioTransactionComment');
	$this->inlineComments = $inline_comments;
	return $this;
	}

	public function getInlineComments() {
	$this->assertAttached($this->inlineComments);
	return $this->inlineComments;
	}


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


	public function getMarkupFieldKey($field) {
	- $hash = PhabricatorHash::digest($this->getMarkupText($field));
	- return 'M:'.$hash;
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newMarkupEngine(array());
	}

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

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

	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}

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

	public function getCapabilities() {
	return $this->getMock()->getCapabilities();
	}

	public function getPolicy($capability) {
	return $this->getMock()->getPolicy($capability);
	}

	// really the mock controls who can see an image
	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return $this->getMock()->hasAutomaticCapability($capability, $viewer);
	}

	}
	diff --git a/src/applications/pholio/storage/PholioMock.php b/src/applications/pholio/storage/PholioMock.php
	index 00e8efd981..7f58a95511 100644
	--- a/src/applications/pholio/storage/PholioMock.php
	+++ b/src/applications/pholio/storage/PholioMock.php
	@@ -1,323 +1,323 @@
	<?php

	final class PholioMock extends PholioDAO
	implements
	PhabricatorMarkupInterface,
	PhabricatorPolicyInterface,
	PhabricatorSubscribableInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorFlaggableInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorProjectInterface,
	PhabricatorDestructibleInterface,
	PhabricatorSpacesInterface,
	PhabricatorMentionableInterface,
	PhabricatorFulltextInterface {

	const MARKUP_FIELD_DESCRIPTION = 'markup:description';

	const STATUS_OPEN = 'open';
	const STATUS_CLOSED = 'closed';

	protected $authorPHID;
	protected $viewPolicy;
	protected $editPolicy;

	protected $name;
	protected $originalName;
	protected $description;
	protected $coverPHID;
	protected $mailKey;
	protected $status;
	protected $spacePHID;

	private $images = self::ATTACHABLE;
	private $allImages = self::ATTACHABLE;
	private $coverFile = self::ATTACHABLE;
	private $tokenCount = self::ATTACHABLE;

	public static function initializeNewMock(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorPholioApplication'))
	->executeOne();

	$view_policy = $app->getPolicy(PholioDefaultViewCapability::CAPABILITY);
	$edit_policy = $app->getPolicy(PholioDefaultEditCapability::CAPABILITY);

	return id(new PholioMock())
	->setAuthorPHID($actor->getPHID())
	->attachImages(array())
	->setStatus(self::STATUS_OPEN)
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->setSpacePHID($actor->getDefaultSpacePHID());
	}

	public function getMonogram() {
	return 'M'.$this->getID();
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'text128',
	'description' => 'text',
	'originalName' => 'text128',
	'mailKey' => 'bytes20',
	'status' => 'text12',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'authorPHID' => array(
	'columns' => array('authorPHID'),
	),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID('MOCK');
	}

	public function save() {
	if (!$this->getMailKey()) {
	$this->setMailKey(Filesystem::readRandomCharacters(20));
	}
	return parent::save();
	}

	/**
	* These should be the images currently associated with the Mock.
	*/
	public function attachImages(array $images) {
	assert_instances_of($images, 'PholioImage');
	$this->images = $images;
	return $this;
	}

	public function getImages() {
	$this->assertAttached($this->images);
	return $this->images;
	}

	/**
	* These should be all images associated with the Mock. This includes
	* images which have been removed and / or replaced from the Mock.
	*/
	public function attachAllImages(array $images) {
	assert_instances_of($images, 'PholioImage');
	$this->allImages = $images;
	return $this;
	}

	public function getAllImages() {
	$this->assertAttached($this->images);
	return $this->allImages;
	}

	public function attachCoverFile(PhabricatorFile $file) {
	$this->coverFile = $file;
	return $this;
	}

	public function getCoverFile() {
	$this->assertAttached($this->coverFile);
	return $this->coverFile;
	}

	public function getTokenCount() {
	$this->assertAttached($this->tokenCount);
	return $this->tokenCount;
	}

	public function attachTokenCount($count) {
	$this->tokenCount = $count;
	return $this;
	}

	public function getImageHistorySet($image_id) {
	$images = $this->getAllImages();
	$images = mpull($images, null, 'getID');
	$selected_image = $images[$image_id];

	$replace_map = mpull($images, null, 'getReplacesImagePHID');
	$phid_map = mpull($images, null, 'getPHID');

	// find the earliest image
	$image = $selected_image;
	while (isset($phid_map[$image->getReplacesImagePHID()])) {
	$image = $phid_map[$image->getReplacesImagePHID()];
	}

	// now build history moving forward
	$history = array($image->getID() => $image);
	while (isset($replace_map[$image->getPHID()])) {
	$image = $replace_map[$image->getPHID()];
	$history[$image->getID()] = $image;
	}

	return $history;
	}

	public function getStatuses() {
	$options = array();
	$options[self::STATUS_OPEN] = pht('Open');
	$options[self::STATUS_CLOSED] = pht('Closed');
	return $options;
	}

	public function isClosed() {
	return ($this->getStatus() == 'closed');
	}


	/* -( PhabricatorSubscribableInterface Implementation )-------------------- */


	public function isAutomaticallySubscribed($phid) {
	return ($this->authorPHID == $phid);
	}


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


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return ($viewer->getPHID() == $this->getAuthorPHID());
	}

	public function describeAutomaticCapability($capability) {
	return pht("A mock's owner can always view and edit it.");
	}


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


	public function getMarkupFieldKey($field) {
	- $hash = PhabricatorHash::digest($this->getMarkupText($field));
	- return 'M:'.$hash;
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newMarkupEngine(array());
	}

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

	return null;
	}

	public function didMarkupText($field, $output, PhutilMarkupEngine $engine) {
	require_celerity_resource('phabricator-remarkup-css');
	return phutil_tag(
	'div',
	array(
	'class' => 'phabricator-remarkup',
	),
	$output);
	}

	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PholioMockEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PholioTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	PholioMockQuery::loadImages(
	$request->getUser(),
	array($this),
	$need_inline_comments = true);
	$timeline->setMock($this);
	return $timeline;
	}

	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	public function getUsersToNotifyOfTokenGiven() {
	return array(
	$this->getAuthorPHID(),
	);
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$images = id(new PholioImage())->loadAllWhere(
	'mockID = %d',
	$this->getID());
	foreach ($images as $image) {
	$image->delete();
	}

	$this->delete();
	$this->saveTransaction();
	}


	/* -( PhabricatorSpacesInterface )----------------------------------------- */


	public function getSpacePHID() {
	return $this->spacePHID;
	}


	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new PholioMockFulltextEngine();
	}


	}
	diff --git a/src/applications/phriction/storage/PhrictionContent.php b/src/applications/phriction/storage/PhrictionContent.php
	index 3a2e20aa29..0492534797 100644
	--- a/src/applications/phriction/storage/PhrictionContent.php
	+++ b/src/applications/phriction/storage/PhrictionContent.php
	@@ -1,131 +1,127 @@
	<?php

	/**
	* @task markup Markup Interface
	*/
	final class PhrictionContent extends PhrictionDAO
	implements PhabricatorMarkupInterface {

	const MARKUP_FIELD_BODY = 'markup:body';

	protected $id;
	protected $documentID;
	protected $version;
	protected $authorPHID;

	protected $title;
	protected $slug;
	protected $content;
	protected $description;

	protected $changeType;
	protected $changeRef;

	private $renderedTableOfContents;

	public function renderContent(PhabricatorUser $viewer) {
	return PhabricatorMarkupEngine::renderOneObject(
	$this,
	self::MARKUP_FIELD_BODY,
	$viewer,
	$this);
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_COLUMN_SCHEMA => array(
	'version' => 'uint32',
	'title' => 'sort',
	'slug' => 'text128',
	'content' => 'text',
	'changeType' => 'uint32',
	'changeRef' => 'uint32?',

	// T6203/NULLABILITY
	// This should just be empty if not provided?
	'description' => 'text?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'documentID' => array(
	'columns' => array('documentID', 'version'),
	'unique' => true,
	),
	'authorPHID' => array(
	'columns' => array('authorPHID'),
	),
	'slug' => array(
	'columns' => array('slug'),
	),
	),
	) + parent::getConfiguration();
	}


	/* -( Markup Interface )--------------------------------------------------- */


	/**
	* @task markup
	*/
	public function getMarkupFieldKey($field) {
	- if ($this->shouldUseMarkupCache($field)) {
	- $id = $this->getID();
	- } else {
	- $id = PhabricatorHash::digest($this->getMarkupText($field));
	- }
	- return "phriction:{$field}:{$id}";
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}


	/**
	* @task markup
	*/
	public function getMarkupText($field) {
	return $this->getContent();
	}


	/**
	* @task markup
	*/
	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newPhrictionMarkupEngine();
	}


	/**
	* @task markup
	*/
	public function didMarkupText(
	$field,
	$output,
	PhutilMarkupEngine $engine) {

	$this->renderedTableOfContents =
	PhutilRemarkupHeaderBlockRule::renderTableOfContents($engine);

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

	/**
	* @task markup
	*/
	public function getRenderedTableOfContents() {
	return $this->renderedTableOfContents;
	}


	/**
	* @task markup
	*/
	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}


	}
	diff --git a/src/applications/ponder/storage/PonderAnswer.php b/src/applications/ponder/storage/PonderAnswer.php
	index 76c9057497..f9e3e8eb8d 100644
	--- a/src/applications/ponder/storage/PonderAnswer.php
	+++ b/src/applications/ponder/storage/PonderAnswer.php
	@@ -1,234 +1,233 @@
	<?php

	final class PonderAnswer extends PonderDAO
	implements
	PhabricatorApplicationTransactionInterface,
	PhabricatorMarkupInterface,
	PhabricatorPolicyInterface,
	PhabricatorFlaggableInterface,
	PhabricatorSubscribableInterface,
	PhabricatorDestructibleInterface {

	const MARKUP_FIELD_CONTENT = 'markup:content';

	protected $authorPHID;
	protected $questionID;

	protected $content;
	protected $mailKey;
	protected $status;
	protected $voteCount;

	private $question = self::ATTACHABLE;
	private $comments;

	public static function initializeNewAnswer(
	PhabricatorUser $actor,
	PonderQuestion $question) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorPonderApplication'))
	->executeOne();

	return id(new PonderAnswer())
	->setQuestionID($question->getID())
	->setContent('')
	->attachQuestion($question)
	->setAuthorPHID($actor->getPHID())
	->setVoteCount(0)
	->setStatus(PonderAnswerStatus::ANSWER_STATUS_VISIBLE);

	}

	public function attachQuestion(PonderQuestion $question = null) {
	$this->question = $question;
	return $this;
	}

	public function getQuestion() {
	return $this->assertAttached($this->question);
	}

	public function getURI() {
	return '/Q'.$this->getQuestionID().'#A'.$this->getID();
	}

	public function setComments($comments) {
	$this->comments = $comments;
	return $this;
	}

	public function getComments() {
	return $this->comments;
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'voteCount' => 'sint32',
	'content' => 'text',
	'status' => 'text32',
	'mailKey' => 'bytes20',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'key_oneanswerperquestion' => array(
	'columns' => array('questionID', 'authorPHID'),
	'unique' => true,
	),
	'questionID' => array(
	'columns' => array('questionID'),
	),
	'authorPHID' => array(
	'columns' => array('authorPHID'),
	),
	'status' => array(
	'columns' => array('status'),
	),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(PonderAnswerPHIDType::TYPECONST);
	}

	public function getMarkupField() {
	return self::MARKUP_FIELD_CONTENT;
	}

	public function save() {
	if (!$this->getMailKey()) {
	$this->setMailKey(Filesystem::readRandomCharacters(20));
	}
	return parent::save();
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PonderAnswerEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PonderAnswerTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}


	// Markup interface

	public function getMarkupFieldKey($field) {
	- $hash = PhabricatorHash::digest($this->getMarkupText($field));
	- $id = $this->getID();
	- return "ponder:A{$id}:{$field}:{$hash}";
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}

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

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::getEngine();
	}

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

	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}


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


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getQuestion()->getPolicy($capability);
	case PhabricatorPolicyCapability::CAN_EDIT:
	$app = PhabricatorApplication::getByClass(
	'PhabricatorPonderApplication');
	return $app->getPolicy(PonderModerateCapability::CAPABILITY);
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	if ($this->getAuthorPHID() == $viewer->getPHID()) {
	return true;
	}
	return $this->getQuestion()->hasAutomaticCapability(
	$capability,
	$viewer);
	case PhabricatorPolicyCapability::CAN_EDIT:
	return ($this->getAuthorPHID() == $viewer->getPHID());
	}
	}


	public function describeAutomaticCapability($capability) {
	$out = array();
	$out[] = pht('The author of an answer can always view and edit it.');
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	$out[] = pht(
	'The user who asks a question can always view the answers.');
	$out[] = pht(
	'A moderator can always view the answers.');
	break;
	}
	return $out;
	}


	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {
	return ($phid == $this->getAuthorPHID());
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();
	$this->saveTransaction();
	}

	}
	diff --git a/src/applications/ponder/storage/PonderQuestion.php b/src/applications/ponder/storage/PonderQuestion.php
	index d302bbfc29..6594219f5a 100644
	--- a/src/applications/ponder/storage/PonderQuestion.php
	+++ b/src/applications/ponder/storage/PonderQuestion.php
	@@ -1,296 +1,295 @@
	<?php

	final class PonderQuestion extends PonderDAO
	implements
	PhabricatorApplicationTransactionInterface,
	PhabricatorMarkupInterface,
	PhabricatorSubscribableInterface,
	PhabricatorFlaggableInterface,
	PhabricatorPolicyInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorProjectInterface,
	PhabricatorDestructibleInterface,
	PhabricatorSpacesInterface,
	PhabricatorFulltextInterface {

	const MARKUP_FIELD_CONTENT = 'markup:content';

	protected $title;
	protected $phid;

	protected $authorPHID;
	protected $status;
	protected $content;
	protected $answerWiki;
	protected $contentSource;
	protected $viewPolicy;
	protected $spacePHID;

	protected $answerCount;
	protected $mailKey;

	private $answers;
	private $comments;

	private $projectPHIDs = self::ATTACHABLE;

	public static function initializeNewQuestion(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorPonderApplication'))
	->executeOne();

	$view_policy = $app->getPolicy(
	PonderDefaultViewCapability::CAPABILITY);

	return id(new PonderQuestion())
	->setAuthorPHID($actor->getPHID())
	->setViewPolicy($view_policy)
	->setStatus(PonderQuestionStatus::STATUS_OPEN)
	->setAnswerCount(0)
	->setAnswerWiki('')
	->setSpacePHID($actor->getDefaultSpacePHID());
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'title' => 'text255',
	'status' => 'text32',
	'content' => 'text',
	'answerWiki' => 'text',
	'answerCount' => 'uint32',
	'mailKey' => 'bytes20',

	// T6203/NULLABILITY
	// This should always exist.
	'contentSource' => 'text?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'authorPHID' => array(
	'columns' => array('authorPHID'),
	),
	'status' => array(
	'columns' => array('status'),
	),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(PonderQuestionPHIDType::TYPECONST);
	}

	public function setContentSource(PhabricatorContentSource $content_source) {
	$this->contentSource = $content_source->serialize();
	return $this;
	}

	public function getContentSource() {
	return PhabricatorContentSource::newFromSerialized($this->contentSource);
	}

	public function setComments($comments) {
	$this->comments = $comments;
	return $this;
	}

	public function getComments() {
	return $this->comments;
	}

	public function attachAnswers(array $answers) {
	assert_instances_of($answers, 'PonderAnswer');
	$this->answers = $answers;
	return $this;
	}

	public function getAnswers() {
	return $this->answers;
	}

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

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

	public function getMarkupField() {
	return self::MARKUP_FIELD_CONTENT;
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PonderQuestionEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PonderQuestionTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}


	// Markup interface

	public function getMarkupFieldKey($field) {
	- $hash = PhabricatorHash::digest($this->getMarkupText($field));
	- $id = $this->getID();
	- return "ponder:Q{$id}:{$field}:{$hash}";
	+ $content = $this->getMarkupText($field);
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}

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

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::getEngine();
	}

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

	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}

	public function save() {
	if (!$this->getMailKey()) {
	$this->setMailKey(Filesystem::readRandomCharacters(20));
	}
	return parent::save();
	}

	public function getOriginalTitle() {
	// TODO: Make this actually save/return the original title.
	return $this->getTitle();
	}

	public function getFullTitle() {
	$id = $this->getID();
	$title = $this->getTitle();
	return "Q{$id}: {$title}";
	}


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

	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	$app = PhabricatorApplication::getByClass(
	'PhabricatorPonderApplication');
	return $app->getPolicy(PonderModerateCapability::CAPABILITY);
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
	if (PhabricatorPolicyFilter::hasCapability(
	$viewer, $this, PhabricatorPolicyCapability::CAN_EDIT)) {
	return true;
	}
	}
	return ($viewer->getPHID() == $this->getAuthorPHID());
	}


	public function describeAutomaticCapability($capability) {
	$out = array();
	$out[] = pht('The user who asked a question can always view and edit it.');
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	$out[] = pht(
	'A moderator can always view the question.');
	break;
	}
	return $out;
	}


	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {
	return ($phid == $this->getAuthorPHID());
	}


	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	public function getUsersToNotifyOfTokenGiven() {
	return array(
	$this->getAuthorPHID(),
	);
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */

	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$answers = id(new PonderAnswer())->loadAllWhere(
	'questionID = %d',
	$this->getID());
	foreach ($answers as $answer) {
	$engine->destroyObject($answer);
	}

	$this->delete();
	$this->saveTransaction();
	}


	/* -( PhabricatorSpacesInterface )----------------------------------------- */


	public function getSpacePHID() {
	return $this->spacePHID;
	}


	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new PonderQuestionFulltextEngine();
	}

	}
	diff --git a/src/applications/releeph/field/specification/ReleephFieldSpecification.php b/src/applications/releeph/field/specification/ReleephFieldSpecification.php
	index df458ced56..ff95ed6514 100644
	--- a/src/applications/releeph/field/specification/ReleephFieldSpecification.php
	+++ b/src/applications/releeph/field/specification/ReleephFieldSpecification.php
	@@ -1,263 +1,265 @@
	<?php

	abstract class ReleephFieldSpecification
	extends PhabricatorCustomField
	implements PhabricatorMarkupInterface {

	// TODO: This is temporary, until ReleephFieldSpecification is more conformant
	// to PhabricatorCustomField.
	private $requestValue;

	public function readValueFromRequest(AphrontRequest $request) {
	$this->requestValue = $request->getStr($this->getRequiredStorageKey());
	return $this;
	}

	public function shouldAppearInPropertyView() {
	return true;
	}

	public function renderPropertyViewLabel() {
	return $this->getName();
	}

	public function renderPropertyViewValue(array $handles) {
	$key = $this->getRequiredStorageKey();
	$value = $this->getReleephRequest()->getDetail($key);
	if ($value === '') {
	return null;
	}
	return $value;
	}

	abstract public function getName();

	/* -( Storage )------------------------------------------------------------ */

	public function getStorageKey() {
	return null;
	}

	public function getRequiredStorageKey() {
	$key = $this->getStorageKey();
	if ($key === null) {
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}
	if (strpos($key, '.') !== false) {
	/**
	* Storage keys are reused for form controls, and periods in form control
	* names break HTML forms.
	*/
	throw new Exception(pht("You can't use '%s' in storage keys!", '.'));
	}
	return $key;
	}

	public function shouldAppearInEditView() {
	return $this->isEditable();
	}

	final public function isEditable() {
	return $this->getStorageKey() !== null;
	}

	final public function getValue() {
	if ($this->requestValue !== null) {
	return $this->requestValue;
	}

	$key = $this->getRequiredStorageKey();
	return $this->getReleephRequest()->getDetail($key);
	}

	final public function setValue($value) {
	$key = $this->getRequiredStorageKey();
	return $this->getReleephRequest()->setDetail($key, $value);
	}

	/**
	* @throws ReleephFieldParseException, to show an error.
	*/
	public function validate($value) {
	return;
	}

	/**
	* Turn values as they are stored in a ReleephRequest into a text that can be
	* rendered as a transactions old/new values.
	*/
	public function normalizeForTransactionView(
	PhabricatorApplicationTransaction $xaction,
	$value) {

	return $value;
	}


	/* -( Conduit )------------------------------------------------------------ */

	public function getKeyForConduit() {
	return $this->getRequiredStorageKey();
	}

	public function getValueForConduit() {
	return $this->getValue();
	}

	public function setValueFromConduitAPIRequest(ConduitAPIRequest $request) {
	$value = idx(
	$request->getValue('fields', array()),
	$this->getRequiredStorageKey());
	$this->validate($value);
	$this->setValue($value);
	return $this;
	}


	/* -( Arcanist )----------------------------------------------------------- */

	public function renderHelpForArcanist() {
	return '';
	}


	/* -( Context )------------------------------------------------------------ */

	private $releephProject;
	private $releephBranch;
	private $releephRequest;
	private $user;

	final public function setReleephProject(ReleephProject $rp) {
	$this->releephProject = $rp;
	return $this;
	}

	final public function setReleephBranch(ReleephBranch $rb) {
	$this->releephRequest = $rb;
	return $this;
	}

	final public function setReleephRequest(ReleephRequest $rr) {
	$this->releephRequest = $rr;
	return $this;
	}

	final public function setUser(PhabricatorUser $user) {
	$this->user = $user;
	return $this;
	}

	final public function getReleephProject() {
	if (!$this->releephProject) {
	return $this->getReleephBranch()->getProduct();
	}
	return $this->releephProject;
	}

	final public function getReleephBranch() {
	if (!$this->releephBranch) {
	return $this->getReleephRequest()->getBranch();
	}
	return $this->releephBranch;
	}

	final public function getReleephRequest() {
	if (!$this->releephRequest) {
	return $this->getObject();
	}
	return $this->releephRequest;
	}

	final public function getUser() {
	if (!$this->user) {
	return $this->getViewer();
	}
	return $this->user;
	}

	/* -( Commit Messages )---------------------------------------------------- */

	public function shouldAppearOnCommitMessage() {
	return false;
	}

	public function renderLabelForCommitMessage() {
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}

	public function renderValueForCommitMessage() {
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}

	public function shouldAppearOnRevertMessage() {
	return false;
	}

	public function renderLabelForRevertMessage() {
	return $this->renderLabelForCommitMessage();
	}

	public function renderValueForRevertMessage() {
	return $this->renderValueForCommitMessage();
	}


	/* -( Markup Interface )--------------------------------------------------- */

	const MARKUP_FIELD_GENERIC = 'releeph:generic-markup-field';

	private $engine;

	/**
	* @{class:ReleephFieldSpecification} implements much of
	* @{interface:PhabricatorMarkupInterface} for you. If you return true from
	* `shouldMarkup()`, and implement `getMarkupText()` then your text will be
	* rendered through the Phabricator markup pipeline.
	*
	* Output is retrievable with `getMarkupEngineOutput()`.
	*/
	public function shouldMarkup() {
	return false;
	}

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

	final public function getMarkupEngineOutput() {
	return $this->engine->getOutput($this, self::MARKUP_FIELD_GENERIC);
	}

	final public function setMarkupEngine(PhabricatorMarkupEngine $engine) {
	$this->engine = $engine;
	$engine->addObject($this, self::MARKUP_FIELD_GENERIC);
	return $this;
	}

	final public function getMarkupFieldKey($field) {
	- return sprintf(
	+ $content = sprintf(
	'%s:%s:%s:%s',
	$this->getReleephRequest()->getPHID(),
	$this->getStorageKey(),
	$field,
	- PhabricatorHash::digest($this->getMarkupText($field)));
	+ $this->getMarkupText($field));
	+
	+ return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}

	final public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newDifferentialMarkupEngine();
	}

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

	return $output;
	}

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

	}
	diff --git a/src/infrastructure/markup/PhabricatorMarkupEngine.php b/src/infrastructure/markup/PhabricatorMarkupEngine.php
	index 3fbf29c294..ad380414f6 100644
	--- a/src/infrastructure/markup/PhabricatorMarkupEngine.php
	+++ b/src/infrastructure/markup/PhabricatorMarkupEngine.php
	@@ -1,697 +1,712 @@
	<?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 $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 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();
	}

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

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jul 27, 9:11 PM (1 w, 11 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 186190
Default Alt Text: (146 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions