No OneTemporary
Actions

Size

82 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php b/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
	index d374dc4a05..054f48a282 100644
	--- a/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
	+++ b/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
	@@ -1,605 +1,605 @@
	<?php

	final class PhabricatorCalendarEventEditController
	extends PhabricatorCalendarController {

	private $id;

	public function willProcessRequest(array $data) {
	$this->id = idx($data, 'id');
	}

	public function isCreate() {
	return !$this->id;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getViewer();
	$user_phid = $viewer->getPHID();
	$error_name = true;
	$error_recurrence_end_date = null;
	$error_start_date = true;
	$error_end_date = true;
	$validation_exception = null;

	$is_recurring_id = celerity_generate_unique_node_id();
	$recurrence_end_date_id = celerity_generate_unique_node_id();
	$frequency_id = celerity_generate_unique_node_id();
	$all_day_id = celerity_generate_unique_node_id();
	$start_date_id = celerity_generate_unique_node_id();
	$end_date_id = celerity_generate_unique_node_id();

	$next_workflow = $request->getStr('next');
	$uri_query = $request->getStr('query');

	if ($this->isCreate()) {
	$mode = $request->getStr('mode');
	$event = PhabricatorCalendarEvent::initializeNewCalendarEvent(
	$viewer,
	$mode);

	$create_start_year = $request->getInt('year');
	$create_start_month = $request->getInt('month');
	$create_start_day = $request->getInt('day');
	$create_start_time = $request->getStr('time');

	if ($create_start_year) {
	$start = AphrontFormDateControlValue::newFromParts(
	$viewer,
	$create_start_year,
	$create_start_month,
	$create_start_day,
	$create_start_time);
	if (!$start->isValid()) {
	return new Aphront400Response();
	}
	$start_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$start->getEpoch());

	$end = clone $start_value->getDateTime();
	$end->modify('+1 hour');
	$end_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$end->format('U'));

	} else {
	list($start_value, $end_value) = $this->getDefaultTimeValues($viewer);
	}

	$recurrence_end_date_value = clone $end_value;
	$recurrence_end_date_value->setOptional(true);

	$submit_label = pht('Create');
	$page_title = pht('Create Event');
	$redirect = 'created';
	$subscribers = array();
	$invitees = array($user_phid);
	$cancel_uri = $this->getApplicationURI();
	} else {
	$event = id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withIDs(array($this->id))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();

	if (!$event) {
	return new Aphront404Response();
	}

	if ($request->getURIData('sequence')) {
	$index = $request->getURIData('sequence');

	$result = $this->getEventAtIndexForGhostPHID(
	$viewer,
	$event->getPHID(),
	$index);

	if ($result) {
	return id(new AphrontRedirectResponse())
	->setURI('/calendar/event/edit/'.$result->getID().'/');
	}

	$event = $this->createEventFromGhost(
	$viewer,
	$event,
	$index);

	return id(new AphrontRedirectResponse())
	->setURI('/calendar/event/edit/'.$event->getID().'/');
	}

	$end_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$event->getDateTo());
	$start_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$event->getDateFrom());
	$recurrence_end_date_value = id(clone $end_value)
	->setOptional(true);

	$submit_label = pht('Update');
	$page_title = pht('Update Event');

	$subscribers = PhabricatorSubscribersQuery::loadSubscribersForPHID(
	$event->getPHID());

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

	$cancel_uri = '/'.$event->getMonogram();
	}

	$name = $event->getName();
	$description = $event->getDescription();
	$is_all_day = $event->getIsAllDay();
	$is_recurring = $event->getIsRecurring();
	$is_parent = $event->getIsRecurrenceParent();
	$frequency = idx($event->getRecurrenceFrequency(), 'rule');
	$icon = $event->getIcon();

	$current_policies = id(new PhabricatorPolicyQuery())
	->setViewer($viewer)
	->setObject($event)
	->execute();

	if ($request->isFormPost()) {
	$xactions = array();
	$name = $request->getStr('name');

	$start_value = AphrontFormDateControlValue::newFromRequest(
	$request,
	'start');
	$end_value = AphrontFormDateControlValue::newFromRequest(
	$request,
	'end');
	$recurrence_end_date_value = AphrontFormDateControlValue::newFromRequest(
	$request,
	'recurrenceEndDate');
	$recurrence_end_date_value->setOptional(true);
	$description = $request->getStr('description');
	$subscribers = $request->getArr('subscribers');
	$edit_policy = $request->getStr('editPolicy');
	$view_policy = $request->getStr('viewPolicy');
	$is_recurring = $request->getStr('isRecurring') ? 1 : 0;
	$frequency = $request->getStr('frequency');
	$is_all_day = $request->getStr('isAllDay');
	$icon = $request->getStr('icon');

	$invitees = $request->getArr('invitees');
	$new_invitees = $this->getNewInviteeList($invitees, $event);
	$status_attending = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;
	if ($this->isCreate()) {
	$status = idx($new_invitees, $viewer->getPHID());
	if ($status) {
	$new_invitees[$viewer->getPHID()] = $status_attending;
	}
	}

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_NAME)
	->setNewValue($name);

	if ($is_recurring && $this->isCreate()) {
	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_RECURRING)
	->setNewValue($is_recurring);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_FREQUENCY)
	->setNewValue(array('rule' => $frequency));

	if (!$recurrence_end_date_value->isDisabled()) {
	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE)
	->setNewValue($recurrence_end_date_value);
	}
	}

	if (($is_recurring && $this->isCreate()) \|\| !$is_parent) {
	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_ALL_DAY)
	->setNewValue($is_all_day);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_ICON)
	->setNewValue($icon);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_START_DATE)
	->setNewValue($start_value);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_END_DATE)
	->setNewValue($end_value);
	}


	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setNewValue(array('=' => array_fuse($subscribers)));

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_INVITE)
	->setNewValue($new_invitees);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION)
	->setNewValue($description);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
	->setNewValue($request->getStr('viewPolicy'));

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDIT_POLICY)
	->setNewValue($request->getStr('editPolicy'));

	$editor = id(new PhabricatorCalendarEventEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true);

	try {
	$xactions = $editor->applyTransactions($event, $xactions);
	$response = id(new AphrontRedirectResponse());
	switch ($next_workflow) {
	case 'day':
	if (!$uri_query) {
	$uri_query = 'month';
	}
	$year = $start_value->getDateTime()->format('Y');
	$month = $start_value->getDateTime()->format('m');
	$day = $start_value->getDateTime()->format('d');
	$response->setURI(
	'/calendar/query/'.$uri_query.'/'.$year.'/'.$month.'/'.$day.'/');
	break;
	default:
	$response->setURI('/E'.$event->getID());
	break;
	}
	return $response;
	} catch (PhabricatorApplicationTransactionValidationException $ex) {
	$validation_exception = $ex;
	$error_name = $ex->getShortMessage(
	PhabricatorCalendarEventTransaction::TYPE_NAME);
	$error_start_date = $ex->getShortMessage(
	PhabricatorCalendarEventTransaction::TYPE_START_DATE);
	$error_end_date = $ex->getShortMessage(
	PhabricatorCalendarEventTransaction::TYPE_END_DATE);
	$error_recurrence_end_date = $ex->getShortMessage(
	PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE);

	$event->setViewPolicy($view_policy);
	$event->setEditPolicy($edit_policy);
	}
	}

	$is_recurring_checkbox = null;
	$recurrence_end_date_control = null;
	$recurrence_frequency_select = null;

	$all_day_checkbox = null;
	$start_control = null;
	$end_control = null;

	$recurring_date_edit_label = null;

	$name = id(new AphrontFormTextControl())
	->setLabel(pht('Name'))
	->setName('name')
	->setValue($name)
	->setError($error_name);

	if ($this->isCreate()) {
	Javelin::initBehavior('recurring-edit', array(
	'isRecurring' => $is_recurring_id,
	'frequency' => $frequency_id,
	'recurrenceEndDate' => $recurrence_end_date_id,
	));

	$is_recurring_checkbox = id(new AphrontFormCheckboxControl())
	->addCheckbox(
	'isRecurring',
	1,
	pht('Recurring Event'),
	$is_recurring,
	$is_recurring_id);

	$recurrence_end_date_control = id(new AphrontFormDateControl())
	->setUser($viewer)
	->setName('recurrenceEndDate')
	->setLabel(pht('Recurrence End Date'))
	->setError($error_recurrence_end_date)
	->setValue($recurrence_end_date_value)
	->setID($recurrence_end_date_id)
	->setIsTimeDisabled(true)
	->setIsDisabled($recurrence_end_date_value->isDisabled())
	->setAllowNull(true);

	$recurrence_frequency_select = id(new AphrontFormSelectControl())
	->setName('frequency')
	->setOptions(array(
	- 'daily' => pht('Daily'),
	- 'weekly' => pht('Weekly'),
	- 'monthly' => pht('Monthly'),
	- 'yearly' => pht('Yearly'),
	+ PhabricatorCalendarEvent::FREQUENCY_DAILY => pht('Daily'),
	+ PhabricatorCalendarEvent::FREQUENCY_WEEKLY => pht('Weekly'),
	+ PhabricatorCalendarEvent::FREQUENCY_MONTHLY => pht('Monthly'),
	+ PhabricatorCalendarEvent::FREQUENCY_YEARLY => pht('Yearly'),
	))
	->setValue($frequency)
	->setLabel(pht('Recurring Event Frequency'))
	->setID($frequency_id)
	->setDisabled(!$is_recurring);
	}

	if ($this->isCreate() \|\| (!$is_parent && !$this->isCreate())) {
	Javelin::initBehavior('event-all-day', array(
	'allDayID' => $all_day_id,
	'startDateID' => $start_date_id,
	'endDateID' => $end_date_id,
	));

	$all_day_checkbox = id(new AphrontFormCheckboxControl())
	->addCheckbox(
	'isAllDay',
	1,
	pht('All Day Event'),
	$is_all_day,
	$all_day_id);

	$start_control = id(new AphrontFormDateControl())
	->setUser($viewer)
	->setName('start')
	->setLabel(pht('Start'))
	->setError($error_start_date)
	->setValue($start_value)
	->setID($start_date_id)
	->setIsTimeDisabled($is_all_day)
	->setEndDateID($end_date_id);

	$end_control = id(new AphrontFormDateControl())
	->setUser($viewer)
	->setName('end')
	->setLabel(pht('End'))
	->setError($error_end_date)
	->setValue($end_value)
	->setID($end_date_id)
	->setIsTimeDisabled($is_all_day);
	} else if ($is_parent) {
	$recurring_date_edit_label = id(new AphrontFormStaticControl())
	->setUser($viewer)
	->setValue(pht('Date and time of recurring event cannot be edited.'));

	if (!$recurrence_end_date_value->isDisabled()) {
	$disabled_recurrence_end_date_value =
	$recurrence_end_date_value->getValueAsFormat('M d, Y');
	$recurrence_end_date_control = id(new AphrontFormStaticControl())
	->setUser($viewer)
	->setLabel(pht('Recurrence End Date'))
	->setValue($disabled_recurrence_end_date_value)
	->setDisabled(true);
	}

	$recurrence_frequency_select = id(new AphrontFormSelectControl())
	->setName('frequency')
	->setOptions(array(
	'daily' => pht('Daily'),
	'weekly' => pht('Weekly'),
	'monthly' => pht('Monthly'),
	'yearly' => pht('Yearly'),
	))
	->setValue($frequency)
	->setLabel(pht('Recurring Event Frequency'))
	->setID($frequency_id)
	->setDisabled(true);

	$all_day_checkbox = id(new AphrontFormCheckboxControl())
	->addCheckbox(
	'isAllDay',
	1,
	pht('All Day Event'),
	$is_all_day,
	$all_day_id)
	->setDisabled(true);

	$start_disabled = $start_value->getValueAsFormat('M d, Y, g:i A');
	$end_disabled = $end_value->getValueAsFormat('M d, Y, g:i A');

	$start_control = id(new AphrontFormStaticControl())
	->setUser($viewer)
	->setLabel(pht('Start'))
	->setValue($start_disabled)
	->setDisabled(true);

	$end_control = id(new AphrontFormStaticControl())
	->setUser($viewer)
	->setLabel(pht('End'))
	->setValue($end_disabled);
	}

	$description = id(new PhabricatorRemarkupControl())
	->setLabel(pht('Description'))
	->setName('description')
	->setValue($description)
	->setUser($viewer);

	$view_policies = id(new AphrontFormPolicyControl())
	->setUser($viewer)
	->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
	->setPolicyObject($event)
	->setPolicies($current_policies)
	->setName('viewPolicy');
	$edit_policies = id(new AphrontFormPolicyControl())
	->setUser($viewer)
	->setCapability(PhabricatorPolicyCapability::CAN_EDIT)
	->setPolicyObject($event)
	->setPolicies($current_policies)
	->setName('editPolicy');

	$subscribers = id(new AphrontFormTokenizerControl())
	->setLabel(pht('Subscribers'))
	->setName('subscribers')
	->setValue($subscribers)
	->setUser($viewer)
	->setDatasource(new PhabricatorMetaMTAMailableDatasource());

	$invitees = id(new AphrontFormTokenizerControl())
	->setLabel(pht('Invitees'))
	->setName('invitees')
	->setValue($invitees)
	->setUser($viewer)
	->setDatasource(new PhabricatorMetaMTAMailableDatasource());

	if ($this->isCreate()) {
	$icon_uri = $this->getApplicationURI('icon/');
	} else {
	$icon_uri = $this->getApplicationURI('icon/'.$event->getID().'/');
	}
	$icon_display = PhabricatorCalendarIcon::renderIconForChooser($icon);
	$icon = id(new AphrontFormChooseButtonControl())
	->setLabel(pht('Icon'))
	->setName('icon')
	->setDisplayValue($icon_display)
	->setButtonText(pht('Choose Icon...'))
	->setChooseURI($icon_uri)
	->setValue($icon);

	$form = id(new AphrontFormView())
	->addHiddenInput('next', $next_workflow)
	->addHiddenInput('query', $uri_query)
	->setUser($viewer)
	->appendChild($name);

	if ($recurring_date_edit_label) {
	$form->appendControl($recurring_date_edit_label);
	}
	if ($is_recurring_checkbox) {
	$form->appendChild($is_recurring_checkbox);
	}
	if ($recurrence_end_date_control) {
	$form->appendChild($recurrence_end_date_control);
	}
	if ($recurrence_frequency_select) {
	$form->appendControl($recurrence_frequency_select);
	}

	$form
	->appendChild($all_day_checkbox)
	->appendChild($start_control)
	->appendChild($end_control)
	->appendControl($view_policies)
	->appendControl($edit_policies)
	->appendControl($subscribers)
	->appendControl($invitees)
	->appendChild($description)
	->appendChild($icon);


	if ($request->isAjax()) {
	return $this->newDialog()
	->setTitle($page_title)
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->appendForm($form)
	->addCancelButton($cancel_uri)
	->addSubmitButton($submit_label);
	}

	$submit = id(new AphrontFormSubmitControl())
	->addCancelButton($cancel_uri)
	->setValue($submit_label);

	$form->appendChild($submit);

	$form_box = id(new PHUIObjectBoxView())
	->setHeaderText($page_title)
	->setForm($form);

	$crumbs = $this->buildApplicationCrumbs();

	if (!$this->isCreate()) {
	$crumbs->addTextCrumb('E'.$event->getId(), '/E'.$event->getId());
	}

	$crumbs->addTextCrumb($page_title);

	$object_box = id(new PHUIObjectBoxView())
	->setHeaderText($page_title)
	->setValidationException($validation_exception)
	->appendChild($form);

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$object_box,
	),
	array(
	'title' => $page_title,
	));
	}


	public function getNewInviteeList(array $phids, $event) {
	$invitees = $event->getInvitees();
	$invitees = mpull($invitees, null, 'getInviteePHID');
	$invited_status = PhabricatorCalendarEventInvitee::STATUS_INVITED;
	$uninvited_status = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
	$phids = array_fuse($phids);

	$new = array();
	foreach ($phids as $phid) {
	$old_status = $event->getUserInviteStatus($phid);
	if ($old_status != $uninvited_status) {
	continue;
	}
	$new[$phid] = $invited_status;
	}

	foreach ($invitees as $invitee) {
	$deleted_invitee = !idx($phids, $invitee->getInviteePHID());
	if ($deleted_invitee) {
	$new[$invitee->getInviteePHID()] = $uninvited_status;
	}
	}

	return $new;
	}

	private function getDefaultTimeValues($viewer) {
	$start = new DateTime('@'.time());
	$start->setTimeZone($viewer->getTimeZone());

	$start->setTime($start->format('H'), 0, 0);
	$start->modify('+1 hour');
	$end = id(clone $start)->modify('+1 hour');

	$start_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$start->format('U'));
	$end_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$end->format('U'));

	return array($start_value, $end_value);
	}

	}
	diff --git a/src/applications/calendar/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	index 874c62fc4b..87c792a468 100644
	--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	@@ -1,547 +1,553 @@
	<?php

	final class PhabricatorCalendarEvent extends PhabricatorCalendarDAO
	implements PhabricatorPolicyInterface,
	PhabricatorMarkupInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorSubscribableInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorDestructibleInterface,
	PhabricatorMentionableInterface,
	PhabricatorFlaggableInterface {

	protected $name;
	protected $userPHID;
	protected $dateFrom;
	protected $dateTo;
	protected $description;
	protected $isCancelled;
	protected $isAllDay;
	protected $icon;
	protected $mailKey;

	protected $isRecurring = 0;
	protected $recurrenceFrequency = array();
	protected $recurrenceEndDate;

	private $isGhostEvent = false;
	protected $instanceOfEventPHID;
	protected $sequenceIndex;

	protected $viewPolicy;
	protected $editPolicy;

	const DEFAULT_ICON = 'fa-calendar';

	private $parentEvent = self::ATTACHABLE;
	private $invitees = self::ATTACHABLE;
	private $appliedViewer;

	+ // Frequency Constants
	+ const FREQUENCY_DAILY = 'daily';
	+ const FREQUENCY_WEEKLY = 'weekly';
	+ const FREQUENCY_MONTHLY = 'monthly';
	+ const FREQUENCY_YEARLY = 'yearly';
	+
	public static function initializeNewCalendarEvent(
	PhabricatorUser $actor,
	$mode) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorCalendarApplication'))
	->executeOne();

	$view_policy = null;
	$is_recurring = 0;

	if ($mode == 'public') {
	$view_policy = PhabricatorPolicies::getMostOpenPolicy();
	}

	if ($mode == 'recurring') {
	$is_recurring = true;
	}

	return id(new PhabricatorCalendarEvent())
	->setUserPHID($actor->getPHID())
	->setIsCancelled(0)
	->setIsAllDay(0)
	->setIsRecurring($is_recurring)
	->setIcon(self::DEFAULT_ICON)
	->setViewPolicy($view_policy)
	->setEditPolicy($actor->getPHID())
	->attachInvitees(array())
	->applyViewerTimezone($actor);
	}

	public function applyViewerTimezone(PhabricatorUser $viewer) {
	if ($this->appliedViewer) {
	throw new Exception(pht('Viewer timezone is already applied!'));
	}

	$this->appliedViewer = $viewer;

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

	$zone = $viewer->getTimeZone();


	$this->setDateFrom(
	$this->getDateEpochForTimeZone(
	$this->getDateFrom(),
	new DateTimeZone('Pacific/Kiritimati'),
	'Y-m-d',
	null,
	$zone));

	$this->setDateTo(
	$this->getDateEpochForTimeZone(
	$this->getDateTo(),
	new DateTimeZone('Pacific/Midway'),
	'Y-m-d 23:59:00',
	'-1 day',
	$zone));

	return $this;
	}


	public function removeViewerTimezone(PhabricatorUser $viewer) {
	if (!$this->appliedViewer) {
	throw new Exception(pht('Viewer timezone is not applied!'));
	}

	if ($viewer->getPHID() != $this->appliedViewer->getPHID()) {
	throw new Exception(pht('Removed viewer must match applied viewer!'));
	}

	$this->appliedViewer = null;

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

	$zone = $viewer->getTimeZone();

	$this->setDateFrom(
	$this->getDateEpochForTimeZone(
	$this->getDateFrom(),
	$zone,
	'Y-m-d',
	null,
	new DateTimeZone('Pacific/Kiritimati')));

	$this->setDateTo(
	$this->getDateEpochForTimeZone(
	$this->getDateTo(),
	$zone,
	'Y-m-d',
	'+1 day',
	new DateTimeZone('Pacific/Midway')));

	return $this;
	}

	private function getDateEpochForTimeZone(
	$epoch,
	$src_zone,
	$format,
	$adjust,
	$dst_zone) {

	$src = new DateTime('@'.$epoch);
	$src->setTimeZone($src_zone);

	if (strlen($adjust)) {
	$adjust = ' '.$adjust;
	}

	$dst = new DateTime($src->format($format).$adjust, $dst_zone);
	return $dst->format('U');
	}

	public function save() {
	if ($this->appliedViewer) {
	throw new Exception(
	pht(
	'Can not save event with viewer timezone still applied!'));
	}

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

	return parent::save();
	}

	/**
	* Get the event start epoch for evaluating invitee availability.
	*
	* When assessing availability, we pretend events start earlier than they
	* really. 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 getDateFromForCache() {
	return ($this->getDateFrom() - phutil_units('15 minutes in seconds'));
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'text',
	'dateFrom' => 'epoch',
	'dateTo' => 'epoch',
	'description' => 'text',
	'isCancelled' => 'bool',
	'isAllDay' => 'bool',
	'icon' => 'text32',
	'mailKey' => 'bytes20',
	'isRecurring' => 'bool',
	'recurrenceEndDate' => 'epoch?',
	'instanceOfEventPHID' => 'phid?',
	'sequenceIndex' => 'uint32?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'userPHID_dateFrom' => array(
	'columns' => array('userPHID', 'dateTo'),
	),
	'key_instance' => array(
	'columns' => array('instanceOfEventPHID', 'sequenceIndex'),
	'unique' => true,
	),
	),
	self::CONFIG_SERIALIZATION => array(
	'recurrenceFrequency' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

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

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

	public function getInvitees() {
	return $this->assertAttached($this->invitees);
	}

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

	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 getIsUserInvited($phid) {
	$uninvited_status = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
	$declined_status = PhabricatorCalendarEventInvitee::STATUS_DECLINED;
	$status = $this->getUserInviteStatus($phid);
	if ($status == $uninvited_status \|\| $status == $declined_status) {
	return false;
	}
	return true;
	}

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

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

	public function generateNthGhost(
	$sequence_index,
	PhabricatorUser $actor) {

	$frequency = $this->getFrequencyUnit();
	$modify_key = '+'.$sequence_index.' '.$frequency;

	$instance_of = ($this->getPHID()) ?
	$this->getPHID() : $this->instanceOfEventPHID;

	$date = $this->dateFrom;
	$date_time = PhabricatorTime::getDateTimeFromEpoch($date, $actor);
	$date_time->modify($modify_key);
	$date = $date_time->format('U');

	$duration = $this->dateTo - $this->dateFrom;

	$edit_policy = PhabricatorPolicies::POLICY_NOONE;

	$ghost_event = id(clone $this)
	->setIsGhostEvent(true)
	->setDateFrom($date)
	->setDateTo($date + $duration)
	->setIsRecurring(true)
	->setRecurrenceFrequency($this->recurrenceFrequency)
	->setInstanceOfEventPHID($instance_of)
	->setSequenceIndex($sequence_index)
	->setEditPolicy($edit_policy);

	return $ghost_event;
	}

	public function getFrequencyUnit() {
	$frequency = idx($this->recurrenceFrequency, 'rule');

	switch ($frequency) {
	case 'daily':
	return 'day';
	case 'weekly':
	return 'week';
	case 'monthly':
	return 'month';
	case 'yearly':
	return 'year';
	default:
	return 'day';
	}
	}

	public function getURI() {
	$uri = '/'.$this->getMonogram();
	if ($this->isGhostEvent) {
	$uri = $uri.'/'.$this->sequenceIndex;
	}
	return $uri;
	}

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

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

	public function getIsCancelled() {
	$instance_of = $this->instanceOfEventPHID;
	if ($instance_of != null && $this->getIsParentCancelled()) {
	return true;
	}
	return $this->isCancelled;
	}

	public function getIsRecurrenceParent() {
	if ($this->isRecurring && !$this->instanceOfEventPHID) {
	return true;
	}
	return false;
	}

	public function getIsRecurrenceException() {
	if ($this->instanceOfEventPHID && !$this->isGhostEvent) {
	return true;
	}
	return false;
	}

	public function getIsParentCancelled() {
	if ($this->instanceOfEventPHID == null) {
	return false;
	}

	$recurring_event = $this->getParentEvent();
	if ($recurring_event->getIsCancelled()) {
	return true;
	}
	return false;
	}

	public function getDuration() {
	$seconds = $this->dateTo - $this->dateFrom;
	$minutes = round($seconds / 60, 1);
	$hours = round($minutes / 60, 3);
	$days = round($hours / 24, 2);

	$duration = '';

	if ($days >= 1) {
	return pht(
	'%s day(s)',
	round($days, 1));
	} else if ($hours >= 1) {
	return pht(
	'%s hour(s)',
	round($hours, 1));
	} else if ($minutes >= 1) {
	return pht(
	'%s minute(s)',
	round($minutes, 0));
	}
	}

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


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


	/**
	* @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:
	return $this->getEditPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	// The owner of a task can always view and edit it.
	$user_phid = $this->getUserPHID();
	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;
	}

	public function describeAutomaticCapability($capability) {
	return pht('The owner of an event can always view and edit it,
	and invitees can always view it, except if the event is an
	instance of a recurring event.');
	}

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

	public function shouldShowSubscribersProperty() {
	return true;
	}

	public function shouldAllowSubscription($phid) {
	return true;
	}

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


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

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


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();
	$this->saveTransaction();
	}
	}
	diff --git a/src/applications/calendar/storage/PhabricatorCalendarEventTransaction.php b/src/applications/calendar/storage/PhabricatorCalendarEventTransaction.php
	index 2d24281562..65ef68e573 100644
	--- a/src/applications/calendar/storage/PhabricatorCalendarEventTransaction.php
	+++ b/src/applications/calendar/storage/PhabricatorCalendarEventTransaction.php
	@@ -1,511 +1,570 @@
	<?php

	final class PhabricatorCalendarEventTransaction
	extends PhabricatorApplicationTransaction {

	const TYPE_NAME = 'calendar.name';
	const TYPE_START_DATE = 'calendar.startdate';
	const TYPE_END_DATE = 'calendar.enddate';
	const TYPE_DESCRIPTION = 'calendar.description';
	const TYPE_CANCEL = 'calendar.cancel';
	const TYPE_ALL_DAY = 'calendar.allday';
	const TYPE_ICON = 'calendar.icon';
	const TYPE_INVITE = 'calendar.invite';

	const TYPE_RECURRING = 'calendar.recurring';
	const TYPE_FREQUENCY = 'calendar.frequency';
	const TYPE_RECURRENCE_END_DATE = 'calendar.recurrenceenddate';

	const TYPE_INSTANCE_OF_EVENT = 'calendar.instanceofevent';
	const TYPE_SEQUENCE_INDEX = 'calendar.sequenceindex';

	const MAILTAG_RESCHEDULE = 'calendar-reschedule';
	const MAILTAG_CONTENT = 'calendar-content';
	const MAILTAG_OTHER = 'calendar-other';

	public function getApplicationName() {
	return 'calendar';
	}

	public function getApplicationTransactionType() {
	return PhabricatorCalendarEventPHIDType::TYPECONST;
	}

	public function getApplicationTransactionCommentObject() {
	return new PhabricatorCalendarEventTransactionComment();
	}

	public function getRequiredHandlePHIDs() {
	$phids = parent::getRequiredHandlePHIDs();

	switch ($this->getTransactionType()) {
	case self::TYPE_NAME:
	case self::TYPE_START_DATE:
	case self::TYPE_END_DATE:
	case self::TYPE_DESCRIPTION:
	case self::TYPE_CANCEL:
	case self::TYPE_ALL_DAY:
	case self::TYPE_RECURRING:
	case self::TYPE_FREQUENCY:
	case self::TYPE_RECURRENCE_END_DATE:
	case self::TYPE_INSTANCE_OF_EVENT:
	case self::TYPE_SEQUENCE_INDEX:
	$phids[] = $this->getObjectPHID();
	break;
	case self::TYPE_INVITE:
	$new = $this->getNewValue();
	foreach ($new as $phid => $status) {
	$phids[] = $phid;
	}
	break;
	}

	return $phids;
	}

	public function shouldHide() {
	$old = $this->getOldValue();
	switch ($this->getTransactionType()) {
	case self::TYPE_START_DATE:
	case self::TYPE_END_DATE:
	case self::TYPE_DESCRIPTION:
	case self::TYPE_CANCEL:
	case self::TYPE_ALL_DAY:
	case self::TYPE_INVITE:
	case self::TYPE_RECURRING:
	case self::TYPE_FREQUENCY:
	case self::TYPE_RECURRENCE_END_DATE:
	case self::TYPE_INSTANCE_OF_EVENT:
	case self::TYPE_SEQUENCE_INDEX:
	return ($old === null);
	}
	return parent::shouldHide();
	}

	public function getIcon() {
	switch ($this->getTransactionType()) {
	case self::TYPE_ICON:
	return $this->getNewValue();
	case self::TYPE_NAME:
	case self::TYPE_START_DATE:
	case self::TYPE_END_DATE:
	case self::TYPE_DESCRIPTION:
	case self::TYPE_ALL_DAY:
	case self::TYPE_CANCEL:
	case self::TYPE_RECURRING:
	case self::TYPE_FREQUENCY:
	case self::TYPE_RECURRENCE_END_DATE:
	case self::TYPE_INSTANCE_OF_EVENT:
	case self::TYPE_SEQUENCE_INDEX:
	return 'fa-pencil';
	break;
	case self::TYPE_INVITE:
	return 'fa-user-plus';
	break;
	}
	return parent::getIcon();
	}

	public function getTitle() {
	$author_phid = $this->getAuthorPHID();
	$object_phid = $this->getObjectPHID();

	$old = $this->getOldValue();
	$new = $this->getNewValue();

	$type = $this->getTransactionType();
	switch ($type) {
	case self::TYPE_NAME:
	if ($old === null) {
	return pht(
	'%s created this event.',
	$this->renderHandleLink($author_phid));
	} else {
	return pht(
	'%s changed the name of this event from %s to %s.',
	$this->renderHandleLink($author_phid),
	$old,
	$new);
	}
	case self::TYPE_START_DATE:
	if ($old) {
	return pht(
	'%s edited the start date of this event.',
	$this->renderHandleLink($author_phid));
	}
	break;
	case self::TYPE_END_DATE:
	if ($old) {
	return pht(
	'%s edited the end date of this event.',
	$this->renderHandleLink($author_phid));
	}
	break;
	case self::TYPE_DESCRIPTION:
	return pht(
	"%s updated the event's description.",
	$this->renderHandleLink($author_phid));
	case self::TYPE_ALL_DAY:
	if ($new) {
	return pht(
	'%s made this an all day event.',
	$this->renderHandleLink($author_phid));
	} else {
	return pht(
	'%s converted this from an all day event.',
	$this->renderHandleLink($author_phid));
	}
	case self::TYPE_ICON:
	return pht(
	'%s set this event\'s icon to %s.',
	$this->renderHandleLink($author_phid),
	PhabricatorCalendarIcon::getLabel($new));
	break;
	case self::TYPE_CANCEL:
	if ($new) {
	return pht(
	'%s cancelled this event.',
	$this->renderHandleLink($author_phid));
	} else {
	return pht(
	'%s reinstated this event.',
	$this->renderHandleLink($author_phid));
	}
	case self::TYPE_INVITE:
	$text = null;

	if (count($old) === 1
	&& count($new) === 1
	&& isset($old[$author_phid])) {
	// user joined/declined/accepted event themself
	$old_status = $old[$author_phid];
	$new_status = $new[$author_phid];

	if ($old_status !== $new_status) {
	switch ($new_status) {
	case PhabricatorCalendarEventInvitee::STATUS_INVITED:
	$text = pht(
	'%s has joined this event.',
	$this->renderHandleLink($author_phid));
	break;
	case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
	$text = pht(
	'%s is attending this event.',
	$this->renderHandleLink($author_phid));
	break;
	case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
	case PhabricatorCalendarEventInvitee::STATUS_UNINVITED:
	$text = pht(
	'%s has declined this event.',
	$this->renderHandleLink($author_phid));
	break;
	default:
	$text = pht(
	'%s has changed their status for this event.',
	$this->renderHandleLink($author_phid));
	break;
	}
	}
	} else {
	// user changed status for many users
	$self_joined = null;
	$self_declined = null;
	$added = array();
	$uninvited = array();

	foreach ($new as $phid => $status) {
	if ($status == PhabricatorCalendarEventInvitee::STATUS_INVITED
	\|\| $status == PhabricatorCalendarEventInvitee::STATUS_ATTENDING) {
	// added users
	$added[] = $phid;
	} else if (
	$status == PhabricatorCalendarEventInvitee::STATUS_DECLINED
	\|\| $status == PhabricatorCalendarEventInvitee::STATUS_UNINVITED) {
	$uninvited[] = $phid;
	}
	}

	$count_added = count($added);
	$count_uninvited = count($uninvited);
	$added_text = null;
	$uninvited_text = null;

	if ($count_added > 0 && $count_uninvited == 0) {
	$added_text = $this->renderHandleList($added);
	$text = pht('%s invited %s.',
	$this->renderHandleLink($author_phid),
	$added_text);
	} else if ($count_added > 0 && $count_uninvited > 0) {
	$added_text = $this->renderHandleList($added);
	$uninvited_text = $this->renderHandleList($uninvited);
	$text = pht('%s invited %s and uninvited: %s',
	$this->renderHandleLink($author_phid),
	$added_text,
	$uninvited_text);
	} else if ($count_added == 0 && $count_uninvited > 0) {
	$uninvited_text = $this->renderHandleList($uninvited);
	$text = pht('%s uninvited %s.',
	$this->renderHandleLink($author_phid),
	$uninvited_text);
	} else {
	$text = pht('%s updated the invitee list.',
	$this->renderHandleLink($author_phid));
	}
	}
	return $text;
	case self::TYPE_RECURRING:
	+ $text = pht('%s made this event recurring.',
	+ $this->renderHandleLink($author_phid));
	+ return $text;
	case self::TYPE_FREQUENCY:
	+ $text = '';
	+ switch ($new['rule']) {
	+ case PhabricatorCalendarEvent::FREQUENCY_DAILY:
	+ $text = pht('%s set this event to repeat daily.',
	+ $this->renderHandleLink($author_phid));
	+ break;
	+ case PhabricatorCalendarEvent::FREQUENCY_WEEKLY:
	+ $text = pht('%s set this event to repeat weekly.',
	+ $this->renderHandleLink($author_phid));
	+ break;
	+ case PhabricatorCalendarEvent::FREQUENCY_MONTHLY:
	+ $text = pht('%s set this event to repeat monthly.',
	+ $this->renderHandleLink($author_phid));
	+ break;
	+ case PhabricatorCalendarEvent::FREQUENCY_YEARLY:
	+ $text = pht('%s set this event to repeat yearly.',
	+ $this->renderHandleLink($author_phid));
	+ break;
	+ }
	+ return $text;
	case self::TYPE_RECURRENCE_END_DATE:
	+ $text = pht('%s has changed the recurrence end date of this event.',
	+ $this->renderHandleLink($author_phid));
	+ return $text;
	case self::TYPE_INSTANCE_OF_EVENT:
	case self::TYPE_SEQUENCE_INDEX:
	- return pht('Recurring event has been updated');
	+ return pht('Recurring event has been updated.');
	}
	return parent::getTitle();
	}

	public function getTitleForFeed() {
	$author_phid = $this->getAuthorPHID();
	$object_phid = $this->getObjectPHID();

	$old = $this->getOldValue();
	$new = $this->getNewValue();

	$viewer = $this->getViewer();

	$type = $this->getTransactionType();
	switch ($type) {
	case self::TYPE_NAME:
	if ($old === null) {
	return pht(
	'%s created %s',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	} else {
	return pht(
	'%s changed the name of %s from %s to %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid),
	$old,
	$new);
	}
	case self::TYPE_START_DATE:
	if ($old) {
	$old = phabricator_datetime($old, $viewer);
	$new = phabricator_datetime($new, $viewer);
	return pht(
	'%s changed the start date of %s from %s to %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid),
	$old,
	$new);
	}
	break;
	case self::TYPE_END_DATE:
	if ($old) {
	$old = phabricator_datetime($old, $viewer);
	$new = phabricator_datetime($new, $viewer);
	return pht(
	'%s edited the end date of %s from %s to %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid),
	$old,
	$new);
	}
	break;
	case self::TYPE_DESCRIPTION:
	return pht(
	'%s updated the description of %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	case self::TYPE_ALL_DAY:
	if ($new) {
	return pht(
	'%s made %s an all day event.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	} else {
	return pht(
	'%s converted %s from an all day event.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	}
	case self::TYPE_ICON:
	return pht(
	'%s set the icon for %s to %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid),
	PhabricatorCalendarIcon::getLabel($new));
	case self::TYPE_CANCEL:
	if ($new) {
	return pht(
	'%s cancelled %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	} else {
	return pht(
	'%s reinstated %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	}
	case self::TYPE_INVITE:
	$text = null;

	if (count($old) === 1
	&& count($new) === 1
	&& isset($old[$author_phid])) {
	// user joined/declined/accepted event themself
	$old_status = $old[$author_phid];
	$new_status = $new[$author_phid];

	if ($old_status !== $new_status) {
	switch ($new_status) {
	case PhabricatorCalendarEventInvitee::STATUS_INVITED:
	$text = pht(
	'%s has joined %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	break;
	case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
	$text = pht(
	'%s is attending %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	break;
	case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
	case PhabricatorCalendarEventInvitee::STATUS_UNINVITED:
	$text = pht(
	'%s has declined %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	break;
	default:
	$text = pht(
	'%s has changed their status of %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	break;
	}
	}
	} else {
	// user changed status for many users
	$self_joined = null;
	$self_declined = null;
	$added = array();
	$uninvited = array();

	foreach ($new as $phid => $status) {
	if ($status == PhabricatorCalendarEventInvitee::STATUS_INVITED
	\|\| $status == PhabricatorCalendarEventInvitee::STATUS_ATTENDING) {
	// added users
	$added[] = $phid;
	} else if (
	$status == PhabricatorCalendarEventInvitee::STATUS_DECLINED
	\|\| $status == PhabricatorCalendarEventInvitee::STATUS_UNINVITED) {
	$uninvited[] = $phid;
	}
	}

	$count_added = count($added);
	$count_uninvited = count($uninvited);
	$added_text = null;
	$uninvited_text = null;

	if ($count_added > 0 && $count_uninvited == 0) {
	$added_text = $this->renderHandleList($added);
	$text = pht('%s invited %s to %s.',
	$this->renderHandleLink($author_phid),
	$added_text,
	$this->renderHandleLink($object_phid));
	} else if ($count_added > 0 && $count_uninvited > 0) {
	$added_text = $this->renderHandleList($added);
	$uninvited_text = $this->renderHandleList($uninvited);
	$text = pht('%s invited %s and uninvited %s to %s',
	$this->renderHandleLink($author_phid),
	$added_text,
	$uninvited_text,
	$this->renderHandleLink($object_phid));
	} else if ($count_added == 0 && $count_uninvited > 0) {
	$uninvited_text = $this->renderHandleList($uninvited);
	$text = pht('%s uninvited %s to %s.',
	$this->renderHandleLink($author_phid),
	$uninvited_text,
	$this->renderHandleLink($object_phid));
	} else {
	$text = pht('%s updated the invitee list of %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	}
	}
	return $text;
	case self::TYPE_RECURRING:
	+ $text = pht('%s made %s a recurring event.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ return $text;
	case self::TYPE_FREQUENCY:
	+ $text = '';
	+ switch ($new['rule']) {
	+ case PhabricatorCalendarEvent::FREQUENCY_DAILY:
	+ $text = pht('%s set %s to repeat daily.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ break;
	+ case PhabricatorCalendarEvent::FREQUENCY_WEEKLY:
	+ $text = pht('%s set %s to repeat weekly.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ break;
	+ case PhabricatorCalendarEvent::FREQUENCY_MONTHLY:
	+ $text = pht('%s set %s to repeat monthly.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ break;
	+ case PhabricatorCalendarEvent::FREQUENCY_YEARLY:
	+ $text = pht('%s set %s to repeat yearly.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ break;
	+ }
	+ return $text;
	case self::TYPE_RECURRENCE_END_DATE:
	+ $text = pht('%s set the recurrence end date of %s to %s.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid),
	+ $new);
	+ return $text;
	case self::TYPE_INSTANCE_OF_EVENT:
	case self::TYPE_SEQUENCE_INDEX:
	- return pht('Recurring event has been updated');
	+ return pht('Recurring event has been updated.');
	}

	return parent::getTitleForFeed();
	}

	public function getColor() {
	$old = $this->getOldValue();
	$new = $this->getNewValue();

	switch ($this->getTransactionType()) {
	case self::TYPE_NAME:
	case self::TYPE_START_DATE:
	case self::TYPE_END_DATE:
	case self::TYPE_DESCRIPTION:
	case self::TYPE_CANCEL:
	case self::TYPE_INVITE:
	return PhabricatorTransactions::COLOR_GREEN;
	}

	return parent::getColor();
	}


	public function hasChangeDetails() {
	switch ($this->getTransactionType()) {
	case self::TYPE_DESCRIPTION:
	return ($this->getOldValue() !== null);
	}

	return parent::hasChangeDetails();
	}

	public function renderChangeDetails(PhabricatorUser $viewer) {
	switch ($this->getTransactionType()) {
	case self::TYPE_DESCRIPTION:
	$old = $this->getOldValue();
	$new = $this->getNewValue();

	return $this->renderTextCorpusChangeDetails(
	$viewer,
	$old,
	$new);
	}

	return parent::renderChangeDetails($viewer);
	}

	public function getMailTags() {
	$tags = array();
	switch ($this->getTransactionType()) {
	case self::TYPE_NAME:
	case self::TYPE_DESCRIPTION:
	case self::TYPE_INVITE:
	case self::TYPE_ICON:
	$tags[] = self::MAILTAG_CONTENT;
	break;
	case self::TYPE_START_DATE:
	case self::TYPE_END_DATE:
	case self::TYPE_CANCEL:
	$tags[] = self::MAILTAG_RESCHEDULE;
	break;
	}
	return $tags;
	}

	}
	diff --git a/src/applications/diviner/controller/DivinerAtomController.php b/src/applications/diviner/controller/DivinerAtomController.php
	index c73ee40af7..c6b7abde56 100644
	--- a/src/applications/diviner/controller/DivinerAtomController.php
	+++ b/src/applications/diviner/controller/DivinerAtomController.php
	@@ -1,693 +1,697 @@
	<?php

	final class DivinerAtomController extends DivinerController {

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getUser();

	$book_name = $request->getURIData('book');
	$atom_type = $request->getURIData('type');
	$atom_name = $request->getURIData('name');
	$atom_context = nonempty($request->getURIData('context'), null);
	$atom_index = nonempty($request->getURIData('index'), null);

	require_celerity_resource('diviner-shared-css');

	$book = id(new DivinerBookQuery())
	->setViewer($viewer)
	->withNames(array($book_name))
	->executeOne();

	if (!$book) {
	return new Aphront404Response();
	}

	$symbol = id(new DivinerAtomQuery())
	->setViewer($viewer)
	->withBookPHIDs(array($book->getPHID()))
	->withTypes(array($atom_type))
	->withNames(array($atom_name))
	->withContexts(array($atom_context))
	->withIndexes(array($atom_index))
	->withIsDocumentable(true)
	->needAtoms(true)
	->needExtends(true)
	->needChildren(true)
	->executeOne();

	if (!$symbol) {
	return new Aphront404Response();
	}

	$atom = $symbol->getAtom();
	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->setBorder(true);

	$crumbs->addTextCrumb(
	$book->getShortTitle(),
	'/book/'.$book->getName().'/');

	$atom_short_title = $atom
	? $atom->getDocblockMetaValue('short', $symbol->getTitle())
	: $symbol->getTitle();

	$crumbs->addTextCrumb($atom_short_title);

	$header = id(new PHUIHeaderView())
	->setHeader($this->renderFullSignature($symbol))
	->addTag(
	id(new PHUITagView())
	->setType(PHUITagView::TYPE_STATE)
	->setBackgroundColor(PHUITagView::COLOR_BLUE)
	->setName(DivinerAtom::getAtomTypeNameString(
	$atom ? $atom->getType() : $symbol->getType())));

	$properties = new PHUIPropertyListView();

	$group = $atom ? $atom->getProperty('group') : $symbol->getGroupName();
	if ($group) {
	$group_name = $book->getGroupName($group);
	} else {
	$group_name = null;
	}

	$document = id(new PHUIDocumentView())
	->setBook($book->getTitle(), $group_name)
	->setHeader($header)
	->addClass('diviner-view')
	->appendChild($properties);

	if ($atom) {
	$this->buildDefined($properties, $symbol);
	$this->buildExtendsAndImplements($properties, $symbol);
	$this->buildRepository($properties, $symbol);

	$warnings = $atom->getWarnings();
	if ($warnings) {
	$warnings = id(new PHUIInfoView())
	->setErrors($warnings)
	->setTitle(pht('Documentation Warnings'))
	->setSeverity(PHUIInfoView::SEVERITY_WARNING);
	}

	$document->appendChild($warnings);
	}

	$methods = $this->composeMethods($symbol);

	$field = 'default';
	$engine = id(new PhabricatorMarkupEngine())
	->setViewer($viewer)
	->addObject($symbol, $field);
	foreach ($methods as $method) {
	foreach ($method['atoms'] as $matom) {
	$engine->addObject($matom, $field);
	}
	}
	$engine->process();

	if ($atom) {
	$content = $this->renderDocumentationText($symbol, $engine);
	$document->appendChild($content);
	}

	$toc = $engine->getEngineMetadata(
	$symbol,
	$field,
	PhutilRemarkupHeaderBlockRule::KEY_HEADER_TOC,
	array());

	if (!$atom) {
	$document->appendChild(
	id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_NOTICE)
	->appendChild(pht('This atom no longer exists.')));
	}

	if ($atom) {
	$document->appendChild($this->buildParametersAndReturn(array($symbol)));
	}

	if ($methods) {
	$tasks = $this->composeTasks($symbol);

	if ($tasks) {
	$methods_by_task = igroup($methods, 'task');

	// Add phantom tasks for methods which have a "@task" name that isn't
	// documented anywhere, or methods that have no "@task" name.
	foreach ($methods_by_task as $task => $ignored) {
	if (empty($tasks[$task])) {
	$tasks[$task] = array(
	'name' => $task,
	'title' => $task ? $task : pht('Other Methods'),
	'defined' => $symbol,
	);
	}
	}

	$section = id(new DivinerSectionView())
	->setHeader(pht('Tasks'));

	foreach ($tasks as $spec) {
	$section->addContent(
	id(new PHUIHeaderView())
	->setNoBackground(true)
	->setHeader($spec['title']));

	$task_methods = idx($methods_by_task, $spec['name'], array());
	$inner_box = id(new PHUIBoxView())
	->addPadding(PHUI::PADDING_LARGE_LEFT)
	->addPadding(PHUI::PADDING_LARGE_RIGHT)
	->addPadding(PHUI::PADDING_LARGE_BOTTOM);

	$box_content = array();
	if ($task_methods) {
	$list_items = array();
	foreach ($task_methods as $task_method) {
	$atom = last($task_method['atoms']);

	$item = $this->renderFullSignature($atom, true);

	if (strlen($atom->getSummary())) {
	$item = array(
	$item,
	" \xE2\x80\x94 ",
	$atom->getSummary(),
	);
	}

	$list_items[] = phutil_tag('li', array(), $item);
	}

	$box_content[] = phutil_tag(
	'ul',
	array(
	'class' => 'diviner-list',
	),
	$list_items);
	} else {
	$no_methods = pht('No methods for this task.');
	$box_content = phutil_tag('em', array(), $no_methods);
	}

	$inner_box->appendChild($box_content);
	$section->addContent($inner_box);
	}
	$document->appendChild($section);
	}

	$section = id(new DivinerSectionView())
	->setHeader(pht('Methods'));

	foreach ($methods as $spec) {
	$matom = last($spec['atoms']);
	$method_header = id(new PHUIHeaderView())
	->setNoBackground(true);

	$inherited = $spec['inherited'];
	if ($inherited) {
	$method_header->addTag(
	id(new PHUITagView())
	->setType(PHUITagView::TYPE_STATE)
	->setBackgroundColor(PHUITagView::COLOR_GREY)
	->setName(pht('Inherited')));
	}

	$method_header->setHeader($this->renderFullSignature($matom));

	$section->addContent(
	array(
	$method_header,
	$this->renderMethodDocumentationText($symbol, $spec, $engine),
	$this->buildParametersAndReturn($spec['atoms']),
	));
	}
	$document->appendChild($section);
	}

	if ($toc) {
	$side = new PHUIListView();
	$side->addMenuItem(
	id(new PHUIListItemView())
	->setName(pht('Contents'))
	->setType(PHUIListItemView::TYPE_LABEL));
	foreach ($toc as $key => $entry) {
	$side->addMenuItem(
	id(new PHUIListItemView())
	->setName($entry[1])
	->setHref('#'.$key));
	}

	$document->setSideNav($side, PHUIDocumentView::NAV_TOP);
	}

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$document,
	),
	array(
	'title' => $symbol->getTitle(),
	));
	}

	private function buildExtendsAndImplements(
	PHUIPropertyListView $view,
	DivinerLiveSymbol $symbol) {

	$lineage = $this->getExtendsLineage($symbol);
	if ($lineage) {
	$tags = array();
	foreach ($lineage as $item) {
	$tags[] = $this->renderAtomTag($item);
	}

	$caret = phutil_tag('span', array('class' => 'caret-right msl msr'));
	$tags = phutil_implode_html($caret, $tags);
	$view->addProperty(pht('Extends'), $tags);
	}

	$implements = $this->getImplementsLineage($symbol);
	if ($implements) {
	$items = array();
	foreach ($implements as $spec) {
	$via = $spec['via'];
	$iface = $spec['interface'];
	if ($via == $symbol) {
	$items[] = $this->renderAtomTag($iface);
	} else {
	$items[] = array(
	$this->renderAtomTag($iface),
	" \xE2\x97\x80 ",
	$this->renderAtomTag($via),
	);
	}
	}

	$view->addProperty(
	pht('Implements'),
	phutil_implode_html(phutil_tag('br'), $items));
	}
	}

	private function buildRepository(
	PHUIPropertyListView $view,
	DivinerLiveSymbol $symbol) {

	+ if (!$symbol->getRepositoryPHID()) {
	+ return;
	+ }
	+
	$view->addProperty(
	pht('Repository'),
	$this->getViewer()->renderHandle($symbol->getRepositoryPHID()));
	}

	private function renderAtomTag(DivinerLiveSymbol $symbol) {
	return id(new PHUITagView())
	->setType(PHUITagView::TYPE_OBJECT)
	->setName($symbol->getName())
	->setHref($symbol->getURI());
	}

	private function getExtendsLineage(DivinerLiveSymbol $symbol) {
	foreach ($symbol->getExtends() as $extends) {
	if ($extends->getType() == 'class') {
	$lineage = $this->getExtendsLineage($extends);
	$lineage[] = $extends;
	return $lineage;
	}
	}
	return array();
	}

	private function getImplementsLineage(DivinerLiveSymbol $symbol) {
	$implements = array();

	// Do these first so we get interfaces ordered from most to least specific.
	foreach ($symbol->getExtends() as $extends) {
	if ($extends->getType() == 'interface') {
	$implements[$extends->getName()] = array(
	'interface' => $extends,
	'via' => $symbol,
	);
	}
	}

	// Now do parent interfaces.
	foreach ($symbol->getExtends() as $extends) {
	if ($extends->getType() == 'class') {
	$implements += $this->getImplementsLineage($extends);
	}
	}

	return $implements;
	}

	private function buildDefined(
	PHUIPropertyListView $view,
	DivinerLiveSymbol $symbol) {

	$atom = $symbol->getAtom();
	$defined = $atom->getFile().':'.$atom->getLine();

	$link = $symbol->getBook()->getConfig('uri.source');
	if ($link) {
	$link = strtr(
	$link,
	array(
	'%%' => '%',
	'%f' => phutil_escape_uri($atom->getFile()),
	'%l' => phutil_escape_uri($atom->getLine()),
	));
	$defined = phutil_tag(
	'a',
	array(
	'href' => $link,
	'target' => '_blank',
	),
	$defined);
	}

	$view->addProperty(pht('Defined'), $defined);
	}

	private function composeMethods(DivinerLiveSymbol $symbol) {
	$methods = $this->findMethods($symbol);
	if (!$methods) {
	return $methods;
	}

	foreach ($methods as $name => $method) {
	// Check for "@task" on each parent, to find the most recently declared
	// "@task".
	$task = null;
	foreach ($method['atoms'] as $key => $method_symbol) {
	$atom = $method_symbol->getAtom();
	if ($atom->getDocblockMetaValue('task')) {
	$task = $atom->getDocblockMetaValue('task');
	}
	}
	$methods[$name]['task'] = $task;

	// Set 'inherited' if this atom has no implementation of the method.
	if (last($method['implementations']) !== $symbol) {
	$methods[$name]['inherited'] = true;
	} else {
	$methods[$name]['inherited'] = false;
	}
	}

	return $methods;
	}

	private function findMethods(DivinerLiveSymbol $symbol) {
	$child_specs = array();
	foreach ($symbol->getExtends() as $extends) {
	if ($extends->getType() == DivinerAtom::TYPE_CLASS) {
	$child_specs = $this->findMethods($extends);
	}
	}

	foreach ($symbol->getChildren() as $child) {
	if ($child->getType() == DivinerAtom::TYPE_METHOD) {
	$name = $child->getName();
	if (isset($child_specs[$name])) {
	$child_specs[$name]['atoms'][] = $child;
	$child_specs[$name]['implementations'][] = $symbol;
	} else {
	$child_specs[$name] = array(
	'atoms' => array($child),
	'defined' => $symbol,
	'implementations' => array($symbol),
	);
	}
	}
	}

	return $child_specs;
	}

	private function composeTasks(DivinerLiveSymbol $symbol) {
	$extends_task_specs = array();
	foreach ($symbol->getExtends() as $extends) {
	$extends_task_specs += $this->composeTasks($extends);
	}

	$task_specs = array();

	$tasks = $symbol->getAtom()->getDocblockMetaValue('task');
	if (strlen($tasks)) {
	$tasks = phutil_split_lines($tasks, $retain_endings = false);

	foreach ($tasks as $task) {
	list($name, $title) = explode(' ', $task, 2);
	$name = trim($name);
	$title = trim($title);

	$task_specs[$name] = array(
	'name' => $name,
	'title' => $title,
	'defined' => $symbol,
	);
	}
	}

	$specs = $task_specs + $extends_task_specs;

	// Reorder "@tasks" in original declaration order. Basically, we want to
	// use the documentation of the closest subclass, but put tasks which
	// were declared by parents first.
	$keys = array_keys($extends_task_specs);
	$specs = array_select_keys($specs, $keys) + $specs;

	return $specs;
	}

	private function renderFullSignature(
	DivinerLiveSymbol $symbol,
	$is_link = false) {

	switch ($symbol->getType()) {
	case DivinerAtom::TYPE_CLASS:
	case DivinerAtom::TYPE_INTERFACE:
	case DivinerAtom::TYPE_METHOD:
	case DivinerAtom::TYPE_FUNCTION:
	break;
	default:
	return $symbol->getTitle();
	}

	$atom = $symbol->getAtom();

	$out = array();

	if ($atom) {
	if ($atom->getProperty('final')) {
	$out[] = 'final';
	}

	if ($atom->getProperty('abstract')) {
	$out[] = 'abstract';
	}

	if ($atom->getProperty('access')) {
	$out[] = $atom->getProperty('access');
	}

	if ($atom->getProperty('static')) {
	$out[] = 'static';
	}
	}

	switch ($symbol->getType()) {
	case DivinerAtom::TYPE_CLASS:
	case DivinerAtom::TYPE_INTERFACE:
	$out[] = $symbol->getType();
	break;
	case DivinerAtom::TYPE_FUNCTION:
	switch ($atom->getLanguage()) {
	case 'php':
	$out[] = $symbol->getType();
	break;
	}
	break;
	case DivinerAtom::TYPE_METHOD:
	switch ($atom->getLanguage()) {
	case 'php':
	$out[] = DivinerAtom::TYPE_FUNCTION;
	break;
	}
	break;
	}

	$anchor = null;
	switch ($symbol->getType()) {
	case DivinerAtom::TYPE_METHOD:
	$anchor = $symbol->getType().'/'.$symbol->getName();
	break;
	default:
	break;
	}

	$out[] = phutil_tag(
	$anchor ? 'a' : 'span',
	array(
	'class' => 'diviner-atom-signature-name',
	'href' => $anchor ? '#'.$anchor : null,
	'name' => $is_link ? null : $anchor,
	),
	$symbol->getName());

	$out = phutil_implode_html(' ', $out);

	if ($atom) {
	$parameters = $atom->getProperty('parameters');
	if ($parameters !== null) {
	$pout = array();
	foreach ($parameters as $parameter) {
	$pout[] = idx($parameter, 'name', '...');
	}
	$out = array($out, '('.implode(', ', $pout).')');
	}
	}

	return phutil_tag(
	'span',
	array(
	'class' => 'diviner-atom-signature',
	),
	$out);
	}

	private function buildParametersAndReturn(array $symbols) {
	assert_instances_of($symbols, 'DivinerLiveSymbol');

	$symbols = array_reverse($symbols);
	$out = array();

	$collected_parameters = null;
	foreach ($symbols as $symbol) {
	$parameters = $symbol->getAtom()->getProperty('parameters');
	if ($parameters !== null) {
	if ($collected_parameters === null) {
	$collected_parameters = array();
	}
	foreach ($parameters as $key => $parameter) {
	if (isset($collected_parameters[$key])) {
	$collected_parameters[$key] += $parameter;
	} else {
	$collected_parameters[$key] = $parameter;
	}
	}
	}
	}

	if (nonempty($parameters)) {
	$out[] = id(new DivinerParameterTableView())
	->setHeader(pht('Parameters'))
	->setParameters($parameters);
	}

	$collected_return = null;
	foreach ($symbols as $symbol) {
	$return = $symbol->getAtom()->getProperty('return');
	if ($return) {
	if ($collected_return) {
	$collected_return += $return;
	} else {
	$collected_return = $return;
	}
	}
	}

	if (nonempty($return)) {
	$out[] = id(new DivinerReturnTableView())
	->setHeader(pht('Return'))
	->setReturn($collected_return);
	}

	return $out;
	}

	private function renderDocumentationText(
	DivinerLiveSymbol $symbol,
	PhabricatorMarkupEngine $engine) {

	$field = 'default';
	$content = $engine->getOutput($symbol, $field);

	if (strlen(trim($symbol->getMarkupText($field)))) {
	$content = phutil_tag(
	'div',
	array(
	'class' => 'phabricator-remarkup',
	),
	$content);
	} else {
	$atom = $symbol->getAtom();
	$content = phutil_tag(
	'div',
	array(
	'class' => 'diviner-message-not-documented',
	),
	DivinerAtom::getThisAtomIsNotDocumentedString($atom->getType()));
	}

	return $content;
	}

	private function renderMethodDocumentationText(
	DivinerLiveSymbol $parent,
	array $spec,
	PhabricatorMarkupEngine $engine) {

	$symbols = array_values($spec['atoms']);
	$implementations = array_values($spec['implementations']);

	$field = 'default';

	$out = array();
	foreach ($symbols as $key => $symbol) {
	$impl = $implementations[$key];
	if ($impl !== $parent) {
	if (!strlen(trim($symbol->getMarkupText($field)))) {
	continue;
	}
	}

	$doc = $this->renderDocumentationText($symbol, $engine);

	if (($impl !== $parent) \|\| $out) {
	$where = id(new PHUIBoxView())
	->addPadding(PHUI::PADDING_MEDIUM_LEFT)
	->addPadding(PHUI::PADDING_MEDIUM_RIGHT)
	->addClass('diviner-method-implementation-header')
	->appendChild($impl->getName());
	$doc = array($where, $doc);

	if ($impl !== $parent) {
	$doc = phutil_tag(
	'div',
	array(
	'class' => 'diviner-method-implementation-inherited',
	),
	$doc);
	}
	}

	$out[] = $doc;
	}

	// If we only have inherited implementations but none have documentation,
	// render the last one here so we get the "this thing has no documentation"
	// element.
	if (!$out) {
	$out[] = $this->renderDocumentationText($symbol, $engine);
	}

	return $out;
	}

	}
	diff --git a/src/docs/user/userguide/arcanist.diviner b/src/docs/user/userguide/arcanist.diviner
	index 734c41f6e6..826ee7d7a6 100644
	--- a/src/docs/user/userguide/arcanist.diviner
	+++ b/src/docs/user/userguide/arcanist.diviner
	@@ -1,183 +1,182 @@
	@title Arcanist User Guide
	@group userguide

	Guide to Arcanist, a command-line interface to Phabricator.

	Arcanists provides command-line access to many Phabricator tools (like
	Differential, Files, and Paste), integrates with static analysis ("lint") and
	unit tests, and manages common workflows like getting changes into Differential
	for review.

	A detailed command reference is available by running `arc help`. This
	document provides an overview of common workflows and installation.

	Arcanist has technical, contributor-focused documentation here:
	<http://www.phabricator.com/docs/arcanist/>

	= Quick Start =

	A quick start guide is available at @{article:Arcanist Quick Start}. It provides
	a much more compact summary of how to get `arc` set up and running for a new
	project. You may want to start there, and return here if you need more
	information.

	= Overview =

	Arcanist is a wrapper script that sits on top of other tools (e.g.,
	Differential, linters, unit test frameworks, git, Mercurial, and SVN) and
	provides a simple command-line API to manage code review and some related
	revision control operations.

	For a detailed list of all available commands, run:

	$ arc help

	For detailed information about a specific command, run:

	$ arc help <command>

	Arcanist allows you to do things like:

	- get detailed help about available commands with `arc help`
	- send your code to Differential for review with `arc diff` (for detailed
	instructions, see @{article:Arcanist User Guide: arc diff})
	- show pending revision information with `arc list`
	- find likely reviewers for a change with `arc cover`
	- apply changes in a revision to the working copy with `arc patch`
	- download a patch from Differential with `arc export`
	- update Git commit messages after review with `arc amend`
	- commit SVN changes with `arc commit`
	- push Git and Mercurial changes with `arc land`
	- view enhanced information about Git branches with `arc branch`

	Once you've configured lint and unit test integration, you can also:

	- check your code for syntax and style errors with `arc lint`
	(see @{article:Arcanist User Guide: Lint})
	- run unit tests that cover your changes with `arc unit`

	Arcanist integrates with other tools:

	- upload and download files with `arc upload` and `arc download`
	- create and view pastes with `arc paste`

	Arcanist has some advanced features as well, you can:

	- execute Conduit method calls with `arc call-conduit`
	- create or update libphutil libraries with `arc liberate`
	- activate tab completion with `arc shell-complete`
	- ...or extend Arcanist and add new commands.

	Except where otherwise noted, these workflows are generally agnostic to the
	underlying version control system and will work properly in git, Mercurial, or
	SVN repositories.

	= Installing Arcanist =

	Arcanist is meant to be installed on your local machine or development server --
	whatever machine you're editing code on. It runs on:

	- Linux;
	- Other operating systems which are pretty similar to Linux, or which
	Linux is pretty similar to;
	- FreeBSD, a fine operating system held in great esteem by many;
	- Mac OS X (see @{article:Arcanist User Guide: Mac OS X}); and
	- Windows (see @{article:Arcanist User Guide: Windows}).

	Arcanist is written in PHP, so you need to install the PHP CLI first if you
	don't already have it. Arcanist should run on PHP 5.2 and newer. If you don't
	have PHP installed, you can download it from <http://www.php.net/>.

	To install Arcanist, pick an install directory and clone the code from GitHub:

	some_install_path/ $ git clone https://github.com/phacility/libphutil.git
	some_install_path/ $ git clone https://github.com/phacility/arcanist.git

	This should leave you with a directory structure like this

	some_install_path/ # Wherever you chose to install it.
	arcanist/ # Arcanist-specific code and libraries.
	libphutil/ # A shared library Arcanist depends upon.

	Now add `some_install_path/arcanist/bin/` to your PATH environment variable.
	When you type "arc", you should see something like this:

	Usage Exception: No command provided. Try 'arc help'.

	If you get that far, you've done things correctly. If you get an error or have
	trouble getting this far, see these detailed guides:

	- On Windows: @{article:Arcanist User Guide: Windows}
	- On Mac OS X: @{article:Arcanist User Guide: Mac OS X}

	You can later upgrade Arcanist and libphutil to the latest versions with
	`arc upgrade`:

	$ arc upgrade

	== Installing Arcanist for a Team ==

	Arcanist changes quickly, so it can be something of a headache to get it
	installed and keep people up to date. Here are some approaches you might be
	able to use:

	- Facebook does most development on development servers, which have a standard
	environment and NFS mounts. Arcanist and libphutil themselves live on an
	NFS mount, and the default `.bashrc` adds them to the PATH. Updating the
	mount source updates everyone's versions, and new employees have a working
	`arc` when they first log in.
	- Another common approach is to write an install script as an action into
	existing build scripts, so users can run `make install-arc` or
	`ant install-arc` or similar.
	- In general, if this sucks and is causing you pain, let us know (see
	@{article:Give Feedback! Get Support!}). We're planning to improve this at
	some point, but it's somewhat complicated to get right. While it can take a
	little time to set up, we aren't getting feedback that it's a persistent
	pain point, so it hasn't been a priority.

	== Installing Tab Completion ==

	If you use `bash`, you can set up tab completion by adding something like this
	to your `.bashrc`, `.profile` or similar:

	source /path/to/arcanist/resources/shell/bash-completion

	== Configuration ==

	Some Arcanist commands can be configured. This configuration is read from
	several sources:

	# A customization can force any setting with
	@{method@arcanist:ArcanistWorkingCopyIdentity::setRuntimeConfig}.
	# User can specify settings for working copy in `arc/config` file located in
	VCS directory (e.g. `.git/arc/config`) in JSON format. This file can also be
	modified by running `arc set-config --local`.
	# Repository can specify its config in `.arcconfig` in JSON format.
	# User can specify the settings in `~/.arcrc` (JSON) through the `config` key.
	This file can be modified also by `arc set-config --global`.
	# Machine can specify the settings with `/etc/arcconfig` (JSON). On Windows,
	the file path is `C:\ProgramData\Phabricator\Arcanist\config`.

	The first place where the setting is defined wins.

	Existing settings can be printed with `arc get-config`.

	== Next Steps ==

	Continue by:

	- setting up a new project for use with `arc`, with
	@{article:Arcanist User Guide: Configuring a New Project}; or
	- learning how to use `arc` to send changes for review with
	@{article:Arcanist User Guide: arc diff}.

	Advanced topics are also available. These are detailed guides to configuring
	technical features of `arc` that refine its behavior. You do not need to read
	them to get it working.

	- @{article:Arcanist User Guide: Commit Ranges}
	- @{article:Arcanist User Guide: Lint}
	- @{article:Arcanist User Guide: Customizing Existing Linters}
	- @{article:Arcanist User Guide: Customizing Lint, Unit Tests and Workflows}
	- @{article:Arcanist User Guide: Code Coverage}
	- - @{article:Arcanist User Guide: Repository Hooks}

File Metadata

Mime Type: text/x-diff
Expires: Jan 19 2025, 16:28 (7 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1126485
Default Alt Text: (82 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions