No OneTemporary
Actions

Size

88 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/__celerity_resource_map__.php b/src/__celerity_resource_map__.php
	index 65c37615a7..bb9b2f8b90 100644
	--- a/src/__celerity_resource_map__.php
	+++ b/src/__celerity_resource_map__.php
	@@ -1,1207 +1,1207 @@
	<?php

	/**
	* This file is automatically generated. Use 'celerity_mapper.php' to rebuild
	* it.
	* @generated
	*/

	celerity_register_resource_map(array(
	'aphront-attached-file-view-css' =>
	array(
	'uri' => '/res/a6ca5487/rsrc/css/aphront/attached-file-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/attached-file-view.css',
	),
	'aphront-crumbs-view-css' =>
	array(
	'uri' => '/res/9009e6bd/rsrc/css/aphront/crumbs-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/crumbs-view.css',
	),
	'aphront-dark-console-css' =>
	array(
	'uri' => '/res/e7011594/rsrc/css/aphront/dark-console.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/dark-console.css',
	),
	'aphront-dialog-view-css' =>
	array(
	'uri' => '/res/79613f9b/rsrc/css/aphront/dialog-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/dialog-view.css',
	),
	'aphront-error-view-css' =>
	array(
	'uri' => '/res/98c5fc69/rsrc/css/aphront/error-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/error-view.css',
	),
	'aphront-form-view-css' =>
	array(
	'uri' => '/res/38a347da/rsrc/css/aphront/form-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/form-view.css',
	),
	'aphront-headsup-action-list-view-css' =>
	array(
	'uri' => '/res/71783633/rsrc/css/aphront/headsup-action-list-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/headsup-action-list-view.css',
	),
	'aphront-list-filter-view-css' =>
	array(
	'uri' => '/res/e6cff171/rsrc/css/aphront/list-filter-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/list-filter-view.css',
	),
	'aphront-pager-view-css' =>
	array(
	'uri' => '/res/43fb79f0/rsrc/css/aphront/pager-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/pager-view.css',
	),
	'aphront-panel-view-css' =>
	array(
	'uri' => '/res/e0139b9c/rsrc/css/aphront/panel-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/panel-view.css',
	),
	'aphront-request-failure-view-css' =>
	array(
	'uri' => '/res/c9a43002/rsrc/css/aphront/request-failure-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/request-failure-view.css',
	),
	'aphront-side-nav-view-css' =>
	array(
	'uri' => '/res/f92966bd/rsrc/css/aphront/side-nav-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/side-nav-view.css',
	),
	'aphront-table-view-css' =>
	array(
	'uri' => '/res/910e83ec/rsrc/css/aphront/table-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/table-view.css',
	),
	'aphront-tokenizer-control-css' =>
	array(
	'uri' => '/res/f530af47/rsrc/css/aphront/tokenizer.css',
	'type' => 'css',
	'requires' =>
	array(
	0 => 'aphront-typeahead-control-css',
	),
	'disk' => '/rsrc/css/aphront/tokenizer.css',
	),
	'aphront-typeahead-control-css' =>
	array(
	'uri' => '/res/a05236a6/rsrc/css/aphront/typeahead.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/aphront/typeahead.css',
	),
	'differential-changeset-view-css' =>
	array(
	- 'uri' => '/res/a239213a/rsrc/css/application/differential/changeset-view.css',
	+ 'uri' => '/res/d92a2fb5/rsrc/css/application/differential/changeset-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/differential/changeset-view.css',
	),
	'differential-core-view-css' =>
	array(
	'uri' => '/res/d0ae90e5/rsrc/css/application/differential/core.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/differential/core.css',
	),
	'differential-revision-add-comment-css' =>
	array(
	'uri' => '/res/849748d3/rsrc/css/application/differential/add-comment.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/differential/add-comment.css',
	),
	'differential-revision-comment-css' =>
	array(
	'uri' => '/res/e3539439/rsrc/css/application/differential/revision-comment.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/differential/revision-comment.css',
	),
	'differential-revision-comment-list-css' =>
	array(
	'uri' => '/res/3b31faa3/rsrc/css/application/differential/revision-comment-list.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/differential/revision-comment-list.css',
	),
	'differential-revision-detail-css' =>
	array(
	'uri' => '/res/ea9de420/rsrc/css/application/differential/revision-detail.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/differential/revision-detail.css',
	),
	0 =>
	array(
	'uri' => '/res/39de799e/rsrc/js/javelin/docs/Base.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	),
	'disk' => '/rsrc/js/javelin/docs/Base.js',
	),
	'differential-revision-history-css' =>
	array(
	'uri' => '/res/0d7d515d/rsrc/css/application/differential/revision-history.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/differential/revision-history.css',
	),
	'differential-table-of-contents-css' =>
	array(
	'uri' => '/res/d173445b/rsrc/css/application/differential/table-of-contents.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/differential/table-of-contents.css',
	),
	'diffusion-commit-view-css' =>
	array(
	'uri' => '/res/bc39d876/rsrc/css/application/diffusion/commit-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/diffusion/commit-view.css',
	),
	'diffusion-source-css' =>
	array(
	'uri' => '/res/db4566b6/rsrc/css/application/diffusion/diffusion-source.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/diffusion/diffusion-source.css',
	),
	'herald-css' =>
	array(
	'uri' => '/res/5051f3ab/rsrc/css/application/herald/herald.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/herald/herald.css',
	),
	'herald-rule-editor' =>
	array(
	'uri' => '/res/402e94d2/rsrc/js/application/herald/HeraldRuleEditor.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'multirow-row-manager',
	1 => 'javelin-install',
	2 => 'javelin-typeahead',
	3 => 'javelin-util',
	4 => 'javelin-dom',
	5 => 'javelin-tokenizer',
	6 => 'javelin-typeahead-preloaded-source',
	7 => 'javelin-stratcom',
	8 => 'javelin-json',
	),
	'disk' => '/rsrc/js/application/herald/HeraldRuleEditor.js',
	),
	'herald-test-css' =>
	array(
	'uri' => '/res/c0cd6bdb/rsrc/css/application/herald/herald-test.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/herald/herald-test.css',
	),
	'javelin-behavior' =>
	array(
	'uri' => '/res/3c772c64/rsrc/js/javelin/lib/behavior.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-magical-init',
	),
	'disk' => '/rsrc/js/javelin/lib/behavior.js',
	),
	'javelin-behavior-aphront-basic-tokenizer' =>
	array(
	'uri' => '/res/bce3961b/rsrc/js/application/core/behavior-tokenizer.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-typeahead',
	2 => 'javelin-tokenizer',
	3 => 'javelin-typeahead-preloaded-source',
	4 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/application/core/behavior-tokenizer.js',
	),
	'javelin-behavior-aphront-drag-and-drop' =>
	array(
	'uri' => '/res/170115f4/rsrc/js/application/core/behavior-drag-and-drop.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-dom',
	2 => 'javelin-util',
	3 => 'phabricator-drag-and-drop-file-upload',
	),
	'disk' => '/rsrc/js/application/core/behavior-drag-and-drop.js',
	),
	'javelin-behavior-aphront-form-disable-on-submit' =>
	array(
	'uri' => '/res/6c659ede/rsrc/js/application/core/behavior-form.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-stratcom',
	2 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/application/core/behavior-form.js',
	),
	'javelin-behavior-dark-console' =>
	array(
	'uri' => '/res/044c171f/rsrc/js/application/core/behavior-dark-console.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-stratcom',
	2 => 'javelin-util',
	3 => 'javelin-dom',
	4 => 'javelin-request',
	),
	'disk' => '/rsrc/js/application/core/behavior-dark-console.js',
	),
	'javelin-behavior-differential-add-reviewers' =>
	array(
	'uri' => '/res/dc79790c/rsrc/js/application/differential/behavior-add-reviewers.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-dom',
	2 => 'javelin-tokenizer',
	3 => 'javelin-typeahead',
	4 => 'javelin-typeahead-preloaded-source',
	),
	'disk' => '/rsrc/js/application/differential/behavior-add-reviewers.js',
	),
	'javelin-behavior-differential-comment-jump' =>
	array(
	'uri' => '/res/be77fced/rsrc/js/application/differential/behavior-comment-jump.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-util',
	2 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/application/differential/behavior-comment-jump.js',
	),
	'javelin-behavior-differential-diff-radios' =>
	array(
	'uri' => '/res/004cb66f/rsrc/js/application/differential/behavior-diff-radios.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-stratcom',
	2 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/application/differential/behavior-diff-radios.js',
	),
	'javelin-behavior-differential-edit-inline-comments' =>
	array(
	'uri' => '/res/682d1a9c/rsrc/js/application/differential/behavior-edit-inline-comments.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-stratcom',
	2 => 'javelin-dom',
	3 => 'javelin-workflow',
	4 => 'javelin-vector',
	),
	'disk' => '/rsrc/js/application/differential/behavior-edit-inline-comments.js',
	),
	'javelin-behavior-differential-feedback-preview' =>
	array(
	'uri' => '/res/ab8a7d60/rsrc/js/application/differential/behavior-comment-preview.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-stratcom',
	2 => 'javelin-dom',
	3 => 'javelin-request',
	4 => 'javelin-util',
	5 => 'phabricator-shaped-request',
	),
	'disk' => '/rsrc/js/application/differential/behavior-comment-preview.js',
	),
	'javelin-behavior-differential-populate' =>
	array(
	'uri' => '/res/025171e1/rsrc/js/application/differential/behavior-populate.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-request',
	2 => 'javelin-util',
	3 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/application/differential/behavior-populate.js',
	),
	'javelin-behavior-differential-show-all-comments' =>
	array(
	'uri' => '/res/bcc990f0/rsrc/js/application/differential/behavior-show-all-comments.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-stratcom',
	2 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/application/differential/behavior-show-all-comments.js',
	),
	'javelin-behavior-differential-show-more' =>
	array(
	'uri' => '/res/9cbf1c9c/rsrc/js/application/differential/behavior-show-more.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-dom',
	2 => 'javelin-request',
	3 => 'javelin-util',
	4 => 'javelin-stratcom',
	),
	'disk' => '/rsrc/js/application/differential/behavior-show-more.js',
	),
	'javelin-behavior-diffusion-jump-to' =>
	array(
	'uri' => '/res/4b63e436/rsrc/js/application/diffusion/behavior-jump-to.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-util',
	2 => 'javelin-vector',
	3 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/application/diffusion/behavior-jump-to.js',
	),
	'javelin-behavior-diffusion-pull-lastmodified' =>
	array(
	'uri' => '/res/29fe2790/rsrc/js/application/diffusion/behavior-pull-lastmodified.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-dom',
	2 => 'javelin-util',
	3 => 'javelin-request',
	),
	'disk' => '/rsrc/js/application/diffusion/behavior-pull-lastmodified.js',
	),
	'javelin-behavior-error-log' =>
	array(
	'uri' => '/res/a5cb42a5/rsrc/js/application/core/behavior-error-log.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/application/core/behavior-error-log.js',
	),
	'javelin-behavior-herald-rule-editor' =>
	array(
	'uri' => '/res/77a0c945/rsrc/js/application/herald/herald-rule-editor.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'herald-rule-editor',
	1 => 'javelin-behavior',
	),
	'disk' => '/rsrc/js/application/herald/herald-rule-editor.js',
	),
	'javelin-behavior-maniphest-transaction-controls' =>
	array(
	'uri' => '/res/94a2a395/rsrc/js/application/maniphest/behavior-transaction-controls.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-dom',
	2 => 'javelin-tokenizer',
	3 => 'javelin-typeahead',
	4 => 'javelin-typeahead-preloaded-source',
	),
	'disk' => '/rsrc/js/application/maniphest/behavior-transaction-controls.js',
	),
	'javelin-behavior-maniphest-transaction-expand' =>
	array(
	'uri' => '/res/966410de/rsrc/js/application/maniphest/behavior-transaction-expand.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-dom',
	2 => 'javelin-workflow',
	3 => 'javelin-stratcom',
	),
	'disk' => '/rsrc/js/application/maniphest/behavior-transaction-expand.js',
	),
	'javelin-behavior-maniphest-transaction-preview' =>
	array(
	'uri' => '/res/44e86555/rsrc/js/application/maniphest/behavior-transaction-preview.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-dom',
	2 => 'javelin-util',
	3 => 'phabricator-shaped-request',
	),
	'disk' => '/rsrc/js/application/maniphest/behavior-transaction-preview.js',
	),
	'javelin-behavior-owners-path-editor' =>
	array(
	'uri' => '/res/9cf78ffc/rsrc/js/application/owners/owners-path-editor.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'owners-path-editor',
	1 => 'javelin-behavior',
	),
	'disk' => '/rsrc/js/application/owners/owners-path-editor.js',
	),
	'javelin-behavior-phabricator-keyboard-shortcuts' =>
	array(
	'uri' => '/res/5a23bcc8/rsrc/js/application/core/behavior-keyboard-shortcuts.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-workflow',
	2 => 'javelin-json',
	3 => 'phabricator-keyboard-shortcut',
	),
	'disk' => '/rsrc/js/application/core/behavior-keyboard-shortcuts.js',
	),
	'javelin-behavior-phabricator-object-selector' =>
	array(
	'uri' => '/res/12d4d90d/rsrc/js/application/core/behavior-object-selector.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-dom',
	2 => 'javelin-request',
	3 => 'javelin-util',
	4 => 'javelin-stratcom',
	),
	'disk' => '/rsrc/js/application/core/behavior-object-selector.js',
	),
	'javelin-behavior-phabricator-watch-anchor' =>
	array(
	'uri' => '/res/bb6fa5b2/rsrc/js/application/core/behavior-watch-anchor.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-stratcom',
	2 => 'javelin-util',
	3 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/application/core/behavior-watch-anchor.js',
	),
	'javelin-behavior-workflow' =>
	array(
	'uri' => '/res/079f49c3/rsrc/js/application/core/behavior-workflow.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-behavior',
	1 => 'javelin-stratcom',
	2 => 'javelin-workflow',
	),
	'disk' => '/rsrc/js/application/core/behavior-workflow.js',
	),
	'javelin-dom' =>
	array(
	'uri' => '/res/43e9e2de/rsrc/js/javelin/lib/DOM.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-magical-init',
	1 => 'javelin-install',
	2 => 'javelin-util',
	3 => 'javelin-vector',
	4 => 'javelin-stratcom',
	),
	'disk' => '/rsrc/js/javelin/lib/DOM.js',
	),
	'javelin-event' =>
	array(
	'uri' => '/res/25c7c9e8/rsrc/js/javelin/core/Event.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	),
	'disk' => '/rsrc/js/javelin/core/Event.js',
	),
	'javelin-install' =>
	array(
	'uri' => '/res/f4d0e147/rsrc/js/javelin/core/install.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-util',
	1 => 'javelin-magical-init',
	),
	'disk' => '/rsrc/js/javelin/core/install.js',
	),
	'javelin-json' =>
	array(
	'uri' => '/res/1c4e3f6a/rsrc/js/javelin/lib/JSON.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-util',
	),
	'disk' => '/rsrc/js/javelin/lib/JSON.js',
	),
	'javelin-magical-init' =>
	array(
	'uri' => '/res/92e7f37e/rsrc/js/javelin/core/init.js',
	'type' => 'js',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/js/javelin/core/init.js',
	),
	'javelin-mask' =>
	array(
	'uri' => '/res/28e3bd9c/rsrc/js/javelin/lib/Mask.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-vector',
	2 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/javelin/lib/Mask.js',
	),
	'javelin-request' =>
	array(
	'uri' => '/res/1ed0d596/rsrc/js/javelin/lib/Request.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-stratcom',
	2 => 'javelin-util',
	3 => 'javelin-behavior',
	),
	'disk' => '/rsrc/js/javelin/lib/Request.js',
	),
	'javelin-stratcom' =>
	array(
	'uri' => '/res/9e7eb62b/rsrc/js/javelin/core/Stratcom.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-event',
	2 => 'javelin-util',
	3 => 'javelin-magical-init',
	),
	'disk' => '/rsrc/js/javelin/core/Stratcom.js',
	),
	'javelin-tokenizer' =>
	array(
	'uri' => '/res/83787676/rsrc/js/javelin/lib/control/tokenizer/Tokenizer.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-dom',
	1 => 'javelin-util',
	2 => 'javelin-stratcom',
	3 => 'javelin-install',
	),
	'disk' => '/rsrc/js/javelin/lib/control/tokenizer/Tokenizer.js',
	),
	'javelin-typeahead' =>
	array(
	'uri' => '/res/ae18ee16/rsrc/js/javelin/lib/control/typeahead/Typeahead.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-dom',
	2 => 'javelin-vector',
	3 => 'javelin-util',
	),
	'disk' => '/rsrc/js/javelin/lib/control/typeahead/Typeahead.js',
	),
	'javelin-typeahead-normalizer' =>
	array(
	'uri' => '/res/a5d60e3c/rsrc/js/javelin/lib/control/typeahead/normalizer/TypeaheadNormalizer.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	),
	'disk' => '/rsrc/js/javelin/lib/control/typeahead/normalizer/TypeaheadNormalizer.js',
	),
	'javelin-typeahead-ondemand-source' =>
	array(
	'uri' => '/res/0015bbf5/rsrc/js/javelin/lib/control/typeahead/source/TypeaheadOnDemandSource.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-util',
	2 => 'javelin-stratcom',
	3 => 'javelin-request',
	4 => 'javelin-typeahead-source',
	),
	'disk' => '/rsrc/js/javelin/lib/control/typeahead/source/TypeaheadOnDemandSource.js',
	),
	'javelin-typeahead-preloaded-source' =>
	array(
	'uri' => '/res/863a173c/rsrc/js/javelin/lib/control/typeahead/source/TypeaheadPreloadedSource.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-util',
	2 => 'javelin-stratcom',
	3 => 'javelin-request',
	4 => 'javelin-typeahead-source',
	),
	'disk' => '/rsrc/js/javelin/lib/control/typeahead/source/TypeaheadPreloadedSource.js',
	),
	'javelin-typeahead-source' =>
	array(
	'uri' => '/res/58518dde/rsrc/js/javelin/lib/control/typeahead/source/TypeaheadSource.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-util',
	2 => 'javelin-dom',
	3 => 'javelin-typeahead-normalizer',
	),
	'disk' => '/rsrc/js/javelin/lib/control/typeahead/source/TypeaheadSource.js',
	),
	'javelin-uri' =>
	array(
	'uri' => '/res/70c9d32b/rsrc/js/javelin/lib/URI.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-util',
	2 => 'javelin-stratcom',
	),
	'disk' => '/rsrc/js/javelin/lib/URI.js',
	),
	'javelin-util' =>
	array(
	'uri' => '/res/be43fdba/rsrc/js/javelin/core/util.js',
	'type' => 'js',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/js/javelin/core/util.js',
	),
	'javelin-vector' =>
	array(
	'uri' => '/res/cd4721c4/rsrc/js/javelin/lib/Vector.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-event',
	),
	'disk' => '/rsrc/js/javelin/lib/Vector.js',
	),
	'javelin-workflow' =>
	array(
	'uri' => '/res/efe645f0/rsrc/js/javelin/lib/Workflow.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-stratcom',
	1 => 'javelin-request',
	2 => 'javelin-dom',
	3 => 'javelin-vector',
	4 => 'javelin-install',
	5 => 'javelin-util',
	6 => 'javelin-mask',
	7 => 'javelin-uri',
	),
	'disk' => '/rsrc/js/javelin/lib/Workflow.js',
	),
	'mainphest-task-detail-css' =>
	array(
	'uri' => '/res/dbefc148/rsrc/css/application/maniphest/task-detail.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/maniphest/task-detail.css',
	),
	'maniphest-task-summary-css' =>
	array(
	'uri' => '/res/41624cb0/rsrc/css/application/maniphest/task-summary.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/maniphest/task-summary.css',
	),
	'maniphest-transaction-detail-css' =>
	array(
	'uri' => '/res/7ee02b5e/rsrc/css/application/maniphest/transaction-detail.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/maniphest/transaction-detail.css',
	),
	'multirow-row-manager' =>
	array(
	'uri' => '/res/0a9b3dee/rsrc/js/application/core/MultirowRowManager.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-stratcom',
	2 => 'javelin-dom',
	3 => 'javelin-util',
	),
	'disk' => '/rsrc/js/application/core/MultirowRowManager.js',
	),
	'owners-path-editor' =>
	array(
	'uri' => '/res/e6c51eb6/rsrc/js/application/owners/OwnersPathEditor.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'multirow-row-manager',
	1 => 'javelin-install',
	2 => 'path-typeahead',
	3 => 'javelin-dom',
	4 => 'javelin-util',
	),
	'disk' => '/rsrc/js/application/owners/OwnersPathEditor.js',
	),
	'owners-path-editor-css' =>
	array(
	'uri' => '/res/9bc5332c/rsrc/css/application/owners/owners-path-editor.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/owners/owners-path-editor.css',
	),
	'path-typeahead' =>
	array(
	'uri' => '/res/1343345d/rsrc/js/application/herald/PathTypeahead.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-typeahead',
	2 => 'javelin-dom',
	3 => 'javelin-request',
	4 => 'javelin-typeahead-ondemand-source',
	5 => 'javelin-util',
	),
	'disk' => '/rsrc/js/application/herald/PathTypeahead.js',
	),
	'phabricator-core-buttons-css' =>
	array(
	'uri' => '/res/3059cf79/rsrc/css/core/buttons.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/core/buttons.css',
	),
	'phabricator-core-css' =>
	array(
	'uri' => '/res/78194d68/rsrc/css/core/core.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/core/core.css',
	),
	'phabricator-directory-css' =>
	array(
	'uri' => '/res/a3d307c5/rsrc/css/application/directory/phabricator-directory.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/directory/phabricator-directory.css',
	),
	'phabricator-drag-and-drop-file-upload' =>
	array(
	'uri' => '/res/63a06ad9/rsrc/js/application/core/DragAndDropFileUpload.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-util',
	2 => 'javelin-request',
	3 => 'javelin-dom',
	4 => 'javelin-uri',
	),
	'disk' => '/rsrc/js/application/core/DragAndDropFileUpload.js',
	),
	'phabricator-keyboard-shortcut' =>
	array(
	'uri' => '/res/beed38cd/rsrc/js/application/core/KeyboardShortcut.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-util',
	2 => 'phabricator-keyboard-shortcut-manager',
	),
	'disk' => '/rsrc/js/application/core/KeyboardShortcut.js',
	),
	'phabricator-keyboard-shortcut-manager' =>
	array(
	'uri' => '/res/b32845bd/rsrc/js/application/core/KeyboardShortcutManager.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-util',
	2 => 'javelin-stratcom',
	3 => 'javelin-dom',
	),
	'disk' => '/rsrc/js/application/core/KeyboardShortcutManager.js',
	),
	'phabricator-object-selector-css' =>
	array(
	'uri' => '/res/ced4098a/rsrc/css/application/objectselector/object-selector.css',
	'type' => 'css',
	'requires' =>
	array(
	0 => 'aphront-dialog-view-css',
	),
	'disk' => '/rsrc/css/application/objectselector/object-selector.css',
	),
	'phabricator-profile-css' =>
	array(
	'uri' => '/res/adcdb5f3/rsrc/css/application/people/profile.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/people/profile.css',
	),
	'phabricator-remarkup-css' =>
	array(
	'uri' => '/res/774d4078/rsrc/css/core/remarkup.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/core/remarkup.css',
	),
	'phabricator-shaped-request' =>
	array(
	'uri' => '/res/d7ba774e/rsrc/js/application/core/ShapedRequest.js',
	'type' => 'js',
	'requires' =>
	array(
	0 => 'javelin-install',
	1 => 'javelin-util',
	2 => 'javelin-request',
	),
	'disk' => '/rsrc/js/application/core/ShapedRequest.js',
	),
	'phabricator-standard-page-view' =>
	array(
	'uri' => '/res/02ae6920/rsrc/css/application/base/standard-page-view.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/base/standard-page-view.css',
	),
	'phabricator-ui-example-css' =>
	array(
	'uri' => '/res/0cef078b/rsrc/css/application/uiexample/example.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/application/uiexample/example.css',
	),
	'syntax-highlighting-css' =>
	array(
	'uri' => '/res/e5cc3d88/rsrc/css/core/syntax.css',
	'type' => 'css',
	'requires' =>
	array(
	),
	'disk' => '/rsrc/css/core/syntax.css',
	),
	), array (
	'packages' =>
	array (
	'03ef179e' =>
	array (
	'name' => 'diffusion.pkg.css',
	'symbols' =>
	array (
	0 => 'diffusion-commit-view-css',
	),
	'uri' => '/res/pkg/03ef179e/diffusion.pkg.css',
	'type' => 'css',
	),
	'33f413ef' =>
	array (
	'name' => 'typeahead.pkg.js',
	'symbols' =>
	array (
	0 => 'javelin-typeahead',
	1 => 'javelin-typeahead-normalizer',
	2 => 'javelin-typeahead-source',
	3 => 'javelin-typeahead-preloaded-source',
	4 => 'javelin-typeahead-ondemand-source',
	5 => 'javelin-tokenizer',
	6 => 'javelin-behavior-aphront-basic-tokenizer',
	),
	'uri' => '/res/pkg/33f413ef/typeahead.pkg.js',
	'type' => 'js',
	),
	- '613cf273' =>
	+ '3bf80070' =>
	array (
	'name' => 'differential.pkg.css',
	'symbols' =>
	array (
	0 => 'differential-core-view-css',
	1 => 'differential-changeset-view-css',
	2 => 'differential-revision-detail-css',
	3 => 'differential-revision-history-css',
	4 => 'differential-table-of-contents-css',
	5 => 'differential-revision-comment-css',
	6 => 'differential-revision-add-comment-css',
	7 => 'differential-revision-comment-list-css',
	),
	- 'uri' => '/res/pkg/613cf273/differential.pkg.css',
	+ 'uri' => '/res/pkg/3bf80070/differential.pkg.css',
	'type' => 'css',
	),
	'64383b02' =>
	array (
	'name' => 'core.pkg.css',
	'symbols' =>
	array (
	0 => 'phabricator-core-css',
	1 => 'phabricator-core-buttons-css',
	2 => 'phabricator-standard-page-view',
	3 => 'aphront-dialog-view-css',
	4 => 'aphront-form-view-css',
	5 => 'aphront-panel-view-css',
	6 => 'aphront-side-nav-view-css',
	7 => 'aphront-table-view-css',
	8 => 'aphront-crumbs-view-css',
	9 => 'aphront-tokenizer-control-css',
	10 => 'aphront-typeahead-control-css',
	11 => 'aphront-list-filter-view-css',
	12 => 'phabricator-directory-css',
	13 => 'phabricator-remarkup-css',
	14 => 'syntax-highlighting-css',
	),
	'uri' => '/res/pkg/64383b02/core.pkg.css',
	'type' => 'css',
	),
	'db95a6d0' =>
	array (
	'name' => 'javelin.pkg.js',
	'symbols' =>
	array (
	0 => 'javelin-util',
	1 => 'javelin-install',
	2 => 'javelin-event',
	3 => 'javelin-stratcom',
	4 => 'javelin-behavior',
	5 => 'javelin-request',
	6 => 'javelin-vector',
	7 => 'javelin-dom',
	8 => 'javelin-json',
	9 => 'javelin-uri',
	),
	'uri' => '/res/pkg/db95a6d0/javelin.pkg.js',
	'type' => 'js',
	),
	'e26c5e06' =>
	array (
	'name' => 'workflow.pkg.js',
	'symbols' =>
	array (
	0 => 'javelin-mask',
	1 => 'javelin-workflow',
	2 => 'javelin-behavior-workflow',
	3 => 'javelin-behavior-aphront-form-disable-on-submit',
	4 => 'phabricator-keyboard-shortcut-manager',
	5 => 'phabricator-keyboard-shortcut',
	6 => 'javelin-behavior-phabricator-keyboard-shortcuts',
	),
	'uri' => '/res/pkg/e26c5e06/workflow.pkg.js',
	'type' => 'js',
	),
	'ed383f69' =>
	array (
	'name' => 'differential.pkg.js',
	'symbols' =>
	array (
	0 => 'javelin-behavior-differential-feedback-preview',
	1 => 'javelin-behavior-differential-edit-inline-comments',
	2 => 'javelin-behavior-differential-populate',
	3 => 'javelin-behavior-differential-show-more',
	4 => 'javelin-behavior-differential-diff-radios',
	),
	'uri' => '/res/pkg/ed383f69/differential.pkg.js',
	'type' => 'js',
	),
	),
	'reverse' =>
	array (
	'aphront-crumbs-view-css' => '64383b02',
	'aphront-dialog-view-css' => '64383b02',
	'aphront-form-view-css' => '64383b02',
	'aphront-list-filter-view-css' => '64383b02',
	'aphront-panel-view-css' => '64383b02',
	'aphront-side-nav-view-css' => '64383b02',
	'aphront-table-view-css' => '64383b02',
	'aphront-tokenizer-control-css' => '64383b02',
	'aphront-typeahead-control-css' => '64383b02',
	- 'differential-changeset-view-css' => '613cf273',
	- 'differential-core-view-css' => '613cf273',
	- 'differential-revision-add-comment-css' => '613cf273',
	- 'differential-revision-comment-css' => '613cf273',
	- 'differential-revision-comment-list-css' => '613cf273',
	- 'differential-revision-detail-css' => '613cf273',
	- 'differential-revision-history-css' => '613cf273',
	- 'differential-table-of-contents-css' => '613cf273',
	+ 'differential-changeset-view-css' => '3bf80070',
	+ 'differential-core-view-css' => '3bf80070',
	+ 'differential-revision-add-comment-css' => '3bf80070',
	+ 'differential-revision-comment-css' => '3bf80070',
	+ 'differential-revision-comment-list-css' => '3bf80070',
	+ 'differential-revision-detail-css' => '3bf80070',
	+ 'differential-revision-history-css' => '3bf80070',
	+ 'differential-table-of-contents-css' => '3bf80070',
	'diffusion-commit-view-css' => '03ef179e',
	'javelin-behavior' => 'db95a6d0',
	'javelin-behavior-aphront-basic-tokenizer' => '33f413ef',
	'javelin-behavior-aphront-form-disable-on-submit' => 'e26c5e06',
	'javelin-behavior-differential-diff-radios' => 'ed383f69',
	'javelin-behavior-differential-edit-inline-comments' => 'ed383f69',
	'javelin-behavior-differential-feedback-preview' => 'ed383f69',
	'javelin-behavior-differential-populate' => 'ed383f69',
	'javelin-behavior-differential-show-more' => 'ed383f69',
	'javelin-behavior-phabricator-keyboard-shortcuts' => 'e26c5e06',
	'javelin-behavior-workflow' => 'e26c5e06',
	'javelin-dom' => 'db95a6d0',
	'javelin-event' => 'db95a6d0',
	'javelin-install' => 'db95a6d0',
	'javelin-json' => 'db95a6d0',
	'javelin-mask' => 'e26c5e06',
	'javelin-request' => 'db95a6d0',
	'javelin-stratcom' => 'db95a6d0',
	'javelin-tokenizer' => '33f413ef',
	'javelin-typeahead' => '33f413ef',
	'javelin-typeahead-normalizer' => '33f413ef',
	'javelin-typeahead-ondemand-source' => '33f413ef',
	'javelin-typeahead-preloaded-source' => '33f413ef',
	'javelin-typeahead-source' => '33f413ef',
	'javelin-uri' => 'db95a6d0',
	'javelin-util' => 'db95a6d0',
	'javelin-vector' => 'db95a6d0',
	'javelin-workflow' => 'e26c5e06',
	'phabricator-core-buttons-css' => '64383b02',
	'phabricator-core-css' => '64383b02',
	'phabricator-directory-css' => '64383b02',
	'phabricator-keyboard-shortcut' => 'e26c5e06',
	'phabricator-keyboard-shortcut-manager' => 'e26c5e06',
	'phabricator-remarkup-css' => '64383b02',
	'phabricator-standard-page-view' => '64383b02',
	'syntax-highlighting-css' => '64383b02',
	),
	));
	diff --git a/src/applications/differential/parser/changeset/DifferentialChangesetParser.php b/src/applications/differential/parser/changeset/DifferentialChangesetParser.php
	index e4bd9cde87..b3a52ead5e 100644
	--- a/src/applications/differential/parser/changeset/DifferentialChangesetParser.php
	+++ b/src/applications/differential/parser/changeset/DifferentialChangesetParser.php
	@@ -1,1530 +1,1533 @@
	<?php

	/*
	* Copyright 2011 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	class DifferentialChangesetParser {

	protected $visible = array();
	protected $new = array();
	protected $old = array();
	protected $intra = array();
	protected $newRender = null;
	protected $oldRender = null;
	protected $parsedHunk = false;

	protected $filename = null;
	protected $filetype = null;
	protected $missingOld = array();
	protected $missingNew = array();

	protected $comments = array();
	protected $specialAttributes = array();

	protected $changeset;
	protected $whitespaceMode = null;

	protected $subparser;

	protected $renderCacheKey = null;

	private $handles;
	private $user;

	private $leftSideChangesetID;
	private $leftSideAttachesToNewFile;

	private $rightSideChangesetID;
	private $rightSideAttachesToNewFile;

	private $renderingReference;
	private $isSubparser;

	const CACHE_VERSION = 4;

	const ATTR_GENERATED = 'attr:generated';
	const ATTR_DELETED = 'attr:deleted';
	const ATTR_UNCHANGED = 'attr:unchanged';
	const ATTR_WHITELINES = 'attr:white';

	const LINES_CONTEXT = 8;

	const WHITESPACE_SHOW_ALL = 'show-all';
	const WHITESPACE_IGNORE_TRAILING = 'ignore-trailing';
	const WHITESPACE_IGNORE_ALL = 'ignore-all';

	/**
	* Configure which Changeset comments added to the right side of the visible
	* diff will be attached to. The ID must be the ID of a real Differential
	* Changeset.
	*
	* The complexity here is that we may show an arbitrary side of an arbitrary
	* changeset as either the left or right part of a diff. This method allows
	* the left and right halves of the displayed diff to be correctly mapped to
	* storage changesets.
	*
	* @param id The Differential Changeset ID that comments added to the right
	* side of the visible diff should be attached to.
	* @param bool If true, attach new comments to the right side of the storage
	* changeset. Note that this may be false, if the left side of
	* some storage changeset is being shown as the right side of
	* a display diff.
	* @return this
	*/
	public function setRightSideCommentMapping($id, $is_new) {
	$this->rightSideChangesetID = $id;
	$this->rightSideAttachesToNewFile = $is_new;
	return $this;
	}

	/**
	* See setRightSideCommentMapping(), but this sets information for the left
	* side of the display diff.
	*/
	public function setLeftSideCommentMapping($id, $is_new) {
	$this->leftSideChangesetID = $id;
	$this->leftSideAttachesToNewFile = $is_new;
	return $this;
	}

	/**
	* Set a key for identifying this changeset in the render cache. If set, the
	* parser will attempt to use the changeset render cache, which can improve
	* performance for frequently-viewed changesets.
	*
	* By default, there is no render cache key and parsers do not use the cache.
	* This is appropriate for rarely-viewed changesets.
	*
	* NOTE: Currently, this key must be a valid Differential Changeset ID.
	*
	* @param string Key for identifying this changeset in the render cache.
	* @return this
	*/
	public function setRenderCacheKey($key) {
	$this->renderCacheKey = $key;
	return $this;
	}

	private function getRenderCacheKey() {
	return $this->renderCacheKey;
	}

	public function setChangeset($changeset) {
	$this->changeset = $changeset;
	$this->setFilename($changeset->getFilename());

	return $this;
	}

	public function setWhitespaceMode($whitespace_mode) {
	$this->whitespaceMode = $whitespace_mode;
	return $this;
	}

	public function setRenderingReference($ref) {
	$this->renderingReference = $ref;
	return $this;
	}

	public function getChangeset() {
	return $this->changeset;
	}

	public function setFilename($filename) {
	$this->filename = $filename;
	if (strpos($filename, '.', 1) !== false) {
	$parts = explode('.', $filename);
	$this->filetype = end($parts);
	}
	}

	public function setHandles(array $handles) {
	$this->handles = $handles;
	return $this;
	}

	public function setMarkupEngine(PhutilMarkupEngine $engine) {
	$this->markupEngine = $engine;
	return $this;
	}

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

	public function parseHunk(DifferentialHunk $hunk) {
	$this->parsedHunk = true;
	$lines = $hunk->getChanges();

	// Flatten UTF-8 into "\0". We don't support UTF-8 because the diffing
	// algorithms are byte-oriented (not character oriented) and everyone seems
	// to be in agreement that it's fairly reasonable not to allow UTF-8 in
	// source files. These bytes will later be replaced with a "?" glyph, but
	// in the meantime we replace them with "\0" since Pygments is happy to
	// deal with that.
	$lines = preg_replace('/[\x80-\xFF]/', "\0", $lines);

	$lines = str_replace(
	array("\t", "\r\n", "\r"),
	array(' ', "\n", "\n"),
	$lines);
	$lines = explode("\n", $lines);

	$types = array();
	foreach ($lines as $line_index => $line) {
	if (isset($line[0])) {
	$char = $line[0];
	if ($char == ' ') {
	$types[$line_index] = null;
	} else if ($char == '\\' && $line_index > 0) {
	$types[$line_index] = $types[$line_index - 1];
	} else {
	$types[$line_index] = $char;
	}
	} else {
	$types[$line_index] = null;
	}
	}

	$old_line = $hunk->getOldOffset();
	$new_line = $hunk->getNewOffset();
	$num_lines = count($lines);

	if ($old_line > 1) {
	$this->missingOld[$old_line] = true;
	} else if ($new_line > 1) {
	$this->missingNew[$new_line] = true;
	}

	for ($cursor = 0; $cursor < $num_lines; $cursor++) {
	$type = $types[$cursor];
	$data = array(
	'type' => $type,
	'text' => (string)substr($lines[$cursor], 1),
	'line' => $new_line,
	);
	switch ($type) {
	case '+':
	$this->new[] = $data;
	++$new_line;
	break;
	case '-':
	$data['line'] = $old_line;
	$this->old[] = $data;
	++$old_line;
	break;
	default:
	$this->new[] = $data;
	$data['line'] = $old_line;
	$this->old[] = $data;
	++$new_line;
	++$old_line;
	break;
	}
	}
	}

	public function getDisplayLine($offset, $length) {
	$start = 1;
	for ($ii = $offset; $ii > 0; $ii--) {
	if ($this->new[$ii] && $this->new[$ii]['line']) {
	$start = $this->new[$ii]['line'];
	break;
	}
	}
	$end = $start;
	for ($ii = $offset + $length; $ii < count($this->new); $ii++) {
	if ($this->new[$ii] && $this->new[$ii]['line']) {
	$end = $this->new[$ii]['line'];
	break;
	}
	}
	return "{$start},{$end}";
	}

	public function parseInlineComment(DifferentialInlineComment $comment) {
	// Parse only comments which are actually visible.
	if ($this->isCommentVisibleOnRenderedDiff($comment)) {
	$this->comments[] = $comment;
	}
	return $this;
	}

	public function process() {

	$old = array();
	$new = array();

	$n = 0;

	$this->old = array_reverse($this->old);
	$this->new = array_reverse($this->new);

	$whitelines = false;
	$changed = false;

	$skip_intra = array();
	while (count($this->old) \|\| count($this->new)) {
	$o_desc = array_pop($this->old);
	$n_desc = array_pop($this->new);

	$oend = end($this->old);
	if ($oend) {
	$o_next = $oend['type'];
	} else {
	$o_next = null;
	}

	$nend = end($this->new);
	if ($nend) {
	$n_next = $nend['type'];
	} else {
	$n_next = null;
	}

	if ($o_desc) {
	$o_type = $o_desc['type'];
	} else {
	$o_type = null;
	}

	if ($n_desc) {
	$n_type = $n_desc['type'];
	} else {
	$n_type = null;
	}

	if (($o_type != null) && ($n_type == null)) {
	$old[] = $o_desc;
	$new[] = null;
	if ($n_desc) {
	array_push($this->new, $n_desc);
	}
	$changed = true;
	continue;
	}

	if (($n_type != null) && ($o_type == null)) {
	$old[] = null;
	$new[] = $n_desc;
	if ($o_desc) {
	array_push($this->old, $o_desc);
	}
	$changed = true;
	continue;
	}

	if ($this->whitespaceMode != self::WHITESPACE_SHOW_ALL) {
	$similar = false;
	switch ($this->whitespaceMode) {
	case self::WHITESPACE_IGNORE_TRAILING:
	if (rtrim($o_desc['text']) == rtrim($n_desc['text'])) {
	$similar = true;
	}
	break;
	}
	if ($similar) {
	$o_desc['type'] = null;
	$n_desc['type'] = null;
	$skip_intra[count($old)] = true;
	$whitelines = true;
	} else {
	$changed = true;
	}
	} else {
	$changed = true;
	}

	$old[] = $o_desc;
	$new[] = $n_desc;
	}

	$this->old = $old;
	$this->new = $new;

	$unchanged = false;
	if ($this->subparser) {
	$unchanged = $this->subparser->isUnchanged();
	$whitelines = $this->subparser->isWhitespaceOnly();
	} else if (!$changed) {
	$filetype = $this->changeset->getFileType();
	if ($filetype == DifferentialChangeType::FILE_TEXT \|\|
	$filetype == DifferentialChangeType::FILE_SYMLINK) {
	$unchanged = true;
	}
	}

	$this->specialAttributes = array(
	self::ATTR_UNCHANGED => $unchanged,
	self::ATTR_DELETED => array_filter($this->old) &&
	!array_filter($this->new),
	self::ATTR_WHITELINES => $whitelines
	);

	if ($this->isSubparser) {
	// The rest of this function deals with formatting the diff for display;
	// we can exit early if we're a subparser and avoid doing extra work.
	return;
	}

	if ($this->subparser) {

	// Use this parser's side-by-side line information -- notably, the
	// change types -- but replace all the line text with the subparser's.
	// This lets us render whitespace-only changes without marking them as
	// different.

	$old = $this->old;
	$new = $this->new;
	$old_text = ipull($this->subparser->old, 'text', 'line');
	$new_text = ipull($this->subparser->new, 'text', 'line');

	foreach ($old as $k => $desc) {
	if (empty($desc)) {
	continue;
	}
	$old[$k]['text'] = idx($old_text, $desc['line']);
	}
	foreach ($new as $k => $desc) {
	if (empty($desc)) {
	continue;
	}
	$new[$k]['text'] = idx($new_text, $desc['line']);

	// If there's a corresponding "old" text and the line is marked as
	// unchanged, test if there are internal whitespace changes between
	// non-whitespace characters, e.g. spaces added to a string or spaces
	// added around operators. If we find internal spaces, mark the line
	// as changed.
	//
	// We only need to do this for "new" lines because any line that is
	// missing either "old" or "new" text certainly can not have internal
	// whitespace changes without also having non-whitespace changes,
	// because characters had to be either added or removed to create the
	// possibility of internal whitespace.
	if (isset($old[$k]['text']) && empty($new[$k]['type'])) {
	if (trim($old[$k]['text']) != trim($new[$k]['text'])) {
	// The strings aren't the same when trimmed, so there are internal
	// whitespace changes. Mark this line changed.
	$old[$k]['type'] = '-';
	$new[$k]['type'] = '+';
	}
	}
	}

	$this->old = $old;
	$this->new = $new;
	}

	$min_length = min(count($this->old), count($this->new));
	for ($ii = 0; $ii < $min_length; $ii++) {
	if ($this->old[$ii] \|\| $this->new[$ii]) {
	if (isset($this->old[$ii]['text'])) {
	$otext = $this->old[$ii]['text'];
	} else {
	$otext = '';
	}
	if (isset($this->new[$ii]['text'])) {
	$ntext = $this->new[$ii]['text'];
	} else {
	$ntext = '';
	}
	if ($otext != $ntext && empty($skip_intra[$ii])) {
	$this->intra[$ii] = ArcanistDiffUtils::generateIntralineDiff(
	$otext,
	$ntext);
	}
	}
	}

	$lines_context = self::LINES_CONTEXT;
	$max_length = max(count($this->old), count($this->new));
	$old = $this->old;
	$new = $this->new;
	$visible = false;
	$last = 0;
	for ($cursor = -$lines_context; $cursor < $max_length; $cursor++) {
	$offset = $cursor + $lines_context;
	if ((isset($old[$offset]) && $old[$offset]['type']) \|\|
	(isset($new[$offset]) && $new[$offset]['type'])) {
	$visible = true;
	$last = $offset;
	} else if ($cursor > $last + $lines_context) {
	$visible = false;
	}
	if ($visible && $cursor > 0) {
	$this->visible[$cursor] = 1;
	}
	}

	$old_corpus = ipull($this->old, 'text');
	$old_corpus_block = implode("\n", $old_corpus);

	$new_corpus = ipull($this->new, 'text');
	$new_corpus_block = implode("\n", $new_corpus);

	$old_future = $this->getHighlightFuture($old_corpus_block);
	$new_future = $this->getHighlightFuture($new_corpus_block);
	$futures = array(
	'old' => $old_future,
	'new' => $new_future,
	);
	foreach (Futures($futures) as $key => $future) {
	try {
	switch ($key) {
	case 'old':
	$this->oldRender = $this->processHighlightedSource(
	$this->old,
	$future->resolve());
	break;
	case 'new':
	$this->newRender = $this->processHighlightedSource(
	$this->new,
	$future->resolve());
	break;
	}
	} catch (Exception $ex) {
	phlog($ex);
	throw $ex;
	}
	}

	$this->applyIntraline(
	$this->oldRender,
	ipull($this->intra, 0),
	$old_corpus);
	$this->applyIntraline(
	$this->newRender,
	ipull($this->intra, 1),
	$new_corpus);

	$this->tokenHighlight($this->oldRender);
	$this->tokenHighlight($this->newRender);

	$generated = (strpos($new_corpus_block, '@'.'generated') !== false);

	$this->specialAttributes[self::ATTR_GENERATED] = $generated;
	}

	public function loadCache() {
	$render_cache_key = $this->getRenderCacheKey();
	if (!$render_cache_key) {
	return false;
	}

	$data = null;

	$changeset = new DifferentialChangeset();
	$conn_r = $changeset->establishConnection('r');
	$data = queryfx_one(
	$conn_r,
	'SELECT * FROM %T WHERE id = %d',
	$changeset->getTableName().'_parse_cache',
	$render_cache_key);

	if (!$data) {
	return false;
	}

	$data = json_decode($data['cache'], true);
	if (!is_array($data) \|\| !$data) {
	return false;
	}

	foreach (self::getCacheableProperties() as $cache_key) {
	if (!array_key_exists($cache_key, $data)) {
	// If we're missing a cache key, assume we're looking at an old cache
	// and ignore it.
	return false;
	}
	}

	if ($data['cacheVersion'] !== self::CACHE_VERSION) {
	return false;
	}

	unset($data['cacheVersion'], $data['cacheHost']);
	$cache_prop = array_select_keys($data, self::getCacheableProperties());
	foreach ($cache_prop as $cache_key => $v) {
	$this->$cache_key = $v;
	}

	return true;
	}

	protected static function getCacheableProperties() {
	return array(
	'visible',
	'new',
	'old',
	'intra',
	'newRender',
	'oldRender',
	'specialAttributes',
	'missingOld',
	'missingNew',
	'cacheVersion',
	'cacheHost',
	);
	}

	public function saveCache() {
	$render_cache_key = $this->getRenderCacheKey();
	if (!$render_cache_key) {
	return false;
	}

	$cache = array();
	foreach (self::getCacheableProperties() as $cache_key) {
	switch ($cache_key) {
	case 'cacheVersion':
	$cache[$cache_key] = self::CACHE_VERSION;
	break;
	case 'cacheHost':
	$cache[$cache_key] = php_uname('n');
	break;
	default:
	$cache[$cache_key] = $this->$cache_key;
	break;
	}
	}
	$cache = json_encode($cache);

	try {
	$changeset = new DifferentialChangeset();
	$conn_w = $changeset->establishConnection('w');
	queryfx(
	$conn_w,
	'INSERT INTO %T (id, cache) VALUES (%d, %s)
	ON DUPLICATE KEY UPDATE cache = VALUES(cache)',
	$changeset->getTableName().'_parse_cache',
	$render_cache_key,
	$cache);
	} catch (AphrontQueryException $ex) {
	// TODO: uhoh
	}
	}

	public function isGenerated() {
	return idx($this->specialAttributes, self::ATTR_GENERATED, false);
	}

	public function isDeleted() {
	return idx($this->specialAttributes, self::ATTR_DELETED, false);
	}

	public function isUnchanged() {
	return idx($this->specialAttributes, self::ATTR_UNCHANGED, false);
	}

	public function isWhitespaceOnly() {
	return idx($this->specialAttributes, self::ATTR_WHITELINES, false);
	}

	public function getLength() {
	return max(count($this->old), count($this->new));
	}

	protected function applyIntraline(&$render, $intra, $corpus) {
	foreach ($render as $key => $text) {
	if (isset($intra[$key])) {
	$render[$key] = ArcanistDiffUtils::applyIntralineDiff(
	$text,
	$intra[$key]);
	}
	if (isset($corpus[$key]) && strlen($corpus[$key]) > 80) {
	$render[$key] = $this->lineWrap($render[$key]);
	}
	}
	}

	protected function lineWrap($l) {
	$c = 0;
	$len = strlen($l);
	$ins = array();
	for ($ii = 0; $ii < $len; ++$ii) {
	if ($l[$ii] == '&') {
	do {
	++$ii;
	} while ($l[$ii] != ';');
	++$c;
	} else if ($l[$ii] == '<') {
	do {
	++$ii;
	} while ($l[$ii] != '>');
	} else {
	++$c;
	}
	if ($c == 80) {
	$ins[] = ($ii + 1);
	$c = 0;
	}
	}
	while (($pos = array_pop($ins))) {
	$l = substr_replace(
	$l,
	"<span class=\"over-the-line\">\xE2\xAC\x85</span><br />",
	$pos,
	0);
	}
	return $l;
	}


	protected function tokenHighlight(&$render) {
	foreach ($render as $key => $text) {
	$render[$key] = str_replace(
	"\0",
	'<span class="uu">'."\xEF\xBF\xBD".'</span>',
	$text);
	}
	}

	protected function getHighlightFuture($corpus) {
	return $this->highlightEngine->getHighlightFuture(
	$this->filetype,
	$corpus);
	}

	protected function processHighlightedSource($data, $result) {

	$result_lines = explode("\n", $result);
	foreach ($data as $key => $info) {
	if (!$info) {
	unset($result_lines[$key]);
	}
	}
	return $result_lines;
	}

	private function tryCacheStuff() {
	$whitespace_mode = $this->whitespaceMode;
	switch ($whitespace_mode) {
	case self::WHITESPACE_SHOW_ALL:
	case self::WHITESPACE_IGNORE_TRAILING:
	break;
	default:
	$whitespace_mode = self::WHITESPACE_IGNORE_ALL;
	break;
	}

	$skip_cache = ($whitespace_mode != self::WHITESPACE_IGNORE_ALL);
	$this->whitespaceMode = $whitespace_mode;

	$changeset = $this->changeset;

	if ($changeset->getFileType() == DifferentialChangeType::FILE_TEXT \|\|
	$changeset->getFileType() == DifferentialChangeType::FILE_SYMLINK) {
	if ($skip_cache \|\| !$this->loadCache()) {
	if ($this->whitespaceMode == self::WHITESPACE_IGNORE_ALL) {

	// Huge mess. Generate a "-bw" (ignore all whitespace changes) diff,
	// parse it out, and then play a shell game with the parsed format
	// in process() so we highlight only changed lines but render
	// whitespace differences. If we don't do this, we either fail to
	// render whitespace changes (which is incredibly confusing,
	// especially for python) or often produce a much larger set of
	// differences than necessary.

	$old_tmp = new TempFile();
	$new_tmp = new TempFile();
	Filesystem::writeFile($old_tmp, $changeset->makeOldFile());
	Filesystem::writeFile($new_tmp, $changeset->makeNewFile());
	list($err, $diff) = exec_manual(
	'diff -bw -U65535 %s %s ',
	$old_tmp,
	$new_tmp);

	if (!strlen($diff)) {
	// If there's no diff text, that means the files are identical
	// except for whitespace changes. Build a synthetic, changeless
	// diff. TODO: this is incredibly hacky.
	$entire_file = explode("\n", $changeset->makeOldFile());
	foreach ($entire_file as $k => $line) {
	$entire_file[$k] = ' '.$line;
	}
	$len = count($entire_file);
	$entire_file = implode("\n", $entire_file);

	$diff = <<<EOSYNTHETIC
	--- ignored 9999-99-99
	+++ ignored 9999-99-99
	@@ -{$len},{$len} +{$len},{$len} @@
	{$entire_file}
	EOSYNTHETIC;
	}

	// subparser takes over the current non-whitespace-ignoring changeset
	$subparser = new DifferentialChangesetParser();
	$subparser->isSubparser = true;
	$subparser->setChangeset($changeset);
	foreach ($changeset->getHunks() as $hunk) {
	$subparser->parseHunk($hunk);
	}
	// We need to call process() so that the subparser's values for
	// things like.
	$subparser->process();

	$this->subparser = $subparser;

	// this parser takes new changeset; will use subparser's text later
	$changes = id(new ArcanistDiffParser())->parseDiff($diff);
	$diff = DifferentialDiff::newFromRawChanges($changes);

	// While we aren't updating $this->changeset (since it has a bunch
	// of metadata we need to preserve, so that headers like "this file
	// was moved" render correctly), we're overwriting the local
	// $changeset so that the block below will choose the synthetic
	// hunks we've built instead of the original hunks.
	$changeset = head($diff->getChangesets());
	}

	// This either uses the real hunks, or synthetic hunks we built above.
	foreach ($changeset->getHunks() as $hunk) {
	$this->parseHunk($hunk);
	}
	$this->process();
	if (!$skip_cache) {
	$this->saveCache();
	}
	}
	}
	}

	public function render(
	$range_start = null,
	$range_len = null,
	$mask_force = array()) {

	$this->highlightEngine = new PhutilDefaultSyntaxHighlighterEngine();
	$this->highlightEngine->setConfig(
	'pygments.enabled',
	PhabricatorEnv::getEnvConfig('pygments.enabled'));

	$this->tryCacheStuff();

	$feedback_mask = array();

	switch ($this->changeset->getFileType()) {
	case DifferentialChangeType::FILE_IMAGE:
	$old = null;
	$cur = null;

	$metadata = $this->changeset->getMetadata();
	$data = idx($metadata, 'attachment-data');

	$old_phid = idx($metadata, 'old:binary-phid');
	$new_phid = idx($metadata, 'new:binary-phid');
	if ($old_phid \|\| $new_phid) {
	if ($old_phid) {
	$old_uri = PhabricatorFileURI::getViewURIForPHID($old_phid);
	$old = phutil_render_tag(
	'img',
	array(
	'src' => $old_uri,
	));
	}
	if ($new_phid) {
	$new_uri = PhabricatorFileURI::getViewURIForPHID($new_phid);
	$cur = phutil_render_tag(
	'img',
	array(
	'src' => $new_uri,
	));
	}
	}

	$output = $this->renderChangesetTable(
	$this->changeset,
	'<tr>'.
	'<th></th>'.
	'<td class="differential-old-image">'.
	'<div class="differential-image-stage">'.
	$old.
	'</div>'.
	'</td>'.
	'<th></th>'.
	'<td class="differential-new-image">'.
	'<div class="differential-image-stage">'.
	$cur.
	'</div>'.
	'</td>'.
	'</tr>');

	return $output;
	case DifferentialChangeType::FILE_DIRECTORY:
	case DifferentialChangeType::FILE_BINARY:
	$output = $this->renderChangesetTable($this->changeset, null);
	return $output;
	}

	$shield = null;
	if ($range_start === null && $range_len === null && !$this->comments) {
	if ($this->isGenerated()) {
	$shield = $this->renderShield(
	"This file contains generated code, which does not normally need ".
	"to be reviewed.",
	true);
	} else if ($this->isUnchanged()) {
	if ($this->isWhitespaceOnly()) {
	$shield = $this->renderShield(
	"This file was changed only by adding or removing trailing ".
	"whitespace.",
	false);
	} else {
	$shield = $this->renderShield(
	"The contents of this file were not changed.",
	false);
	}
	} else if ($this->isDeleted()) {
	$shield = $this->renderShield(
	"This file was completely deleted.",
	true);
	} else if ($this->changeset->getAffectedLineCount() > 2500) {
	$lines = number_format($this->changeset->getAffectedLineCount());
	$shield = $this->renderShield(
	"This file has a very large number of changes ({$lines} lines).",
	true);
	}
	}

	if ($shield) {
	return $this->renderChangesetTable($this->changeset, $shield);
	}

	$old_comments = array();
	$new_comments = array();

	$old_mask = array();
	$new_mask = array();
	$feedback_mask = array();

	if ($this->comments) {
	foreach ($this->comments as $comment) {
	$start = max($comment->getLineNumber() - self::LINES_CONTEXT, 0);
	$end = $comment->getLineNumber() +
	$comment->getLineLength() +
	self::LINES_CONTEXT;
	$new = $this->isCommentOnRightSideWhenDisplayed($comment);
	for ($ii = $start; $ii <= $end; $ii++) {
	if ($new) {
	$new_mask[$ii] = true;
	} else {
	$old_mask[$ii] = true;
	}
	}
	}

	foreach ($this->old as $ii => $old) {
	if (isset($old['line']) && isset($old_mask[$old['line']])) {
	$feedback_mask[$ii] = true;
	}
	}

	foreach ($this->new as $ii => $new) {
	if (isset($new['line']) && isset($new_mask[$new['line']])) {
	$feedback_mask[$ii] = true;
	}
	}
	$this->comments = msort($this->comments, 'getID');
	foreach ($this->comments as $comment) {
	$final = $comment->getLineNumber() +
	$comment->getLineLength();
	if ($this->isCommentOnRightSideWhenDisplayed($comment)) {
	$new_comments[$final][] = $comment;
	} else {
	$old_comments[$final][] = $comment;
	}
	}
	}

	$html = $this->renderTextChange(
	$range_start,
	$range_len,
	$mask_force,
	$feedback_mask,
	$old_comments,
	$new_comments);

	return $this->renderChangesetTable($this->changeset, $html);
	}

	/**
	* Determine if an inline comment will appear on the rendered diff,
	* taking into consideration which halves of which changesets will actually
	* be shown.
	*
	* @param DifferentialInlineComment Comment to test for visibility.
	* @return bool True if the comment is visible on the rendered diff.
	*/
	private function isCommentVisibleOnRenderedDiff(
	DifferentialInlineComment $comment) {

	$changeset_id = $comment->getChangesetID();
	$is_new = $comment->getIsNewFile();

	if ($changeset_id == $this->rightSideChangesetID &&
	$is_new == $this->rightSideAttachesToNewFile) {
	return true;
	}

	if ($changeset_id == $this->leftSideChangesetID &&
	$is_new == $this->leftSideAttachesToNewFile) {
	return true;
	}

	return false;
	}


	/**
	* Determine if a comment will appear on the right side of the display diff.
	* Note that the comment must appear somewhere on the rendered changeset, as
	* per isCommentVisibleOnRenderedDiff().
	*
	* @param DifferentialInlineComment Comment to test for display location.
	* @return bool True for right, false for left.
	*/
	private function isCommentOnRightSideWhenDisplayed(
	DifferentialInlineComment $comment) {

	if (!$this->isCommentVisibleOnRenderedDiff($comment)) {
	throw new Exception("Comment is not visible on changeset!");
	}

	$changeset_id = $comment->getChangesetID();
	$is_new = $comment->getIsNewFile();

	if ($changeset_id == $this->rightSideChangesetID &&
	$is_new == $this->rightSideAttachesToNewFile) {
	return true;
	}

	return false;
	}

	protected function renderShield($message, $more) {

	if ($more) {
	$end = $this->getLength();
	$reference = $this->renderingReference;
	$more =
	' '.
	javelin_render_tag(
	'a',
	array(
	'mustcapture' => true,
	'sigil' => 'show-more',
	'class' => 'complete',
	'href' => '#',
	'meta' => array(
	'ref' => $reference,
	'range' => "0-{$end}",
	),
	),
	'Show File Contents');
	} else {
	$more = null;
	}

	return javelin_render_tag(
	'tr',
	array(
	'sigil' => 'context-target',
	),
	'<td class="differential-shield" colspan="4">'.
	phutil_escape_html($message).
	$more.
	'</td>');
	}

	protected function renderTextChange(
	$range_start,
	$range_len,
	$mask_force,
	$feedback_mask,
	array $old_comments,
	array $new_comments) {

	$context_not_available = null;
	if ($this->missingOld \|\| $this->missingNew) {
	$context_not_available = javelin_render_tag(
	'tr',
	array(
	'sigil' => 'context-target',
	),
	'<td colspan="4" class="show-more">'.
	'Context not available.'.
	'</td>');
	$context_not_available = $context_not_available;
	}

	$html = array();

	$rows = max(
	count($this->old),
	count($this->new));

	if ($range_start === null) {
	$range_start = 0;
	}

	if ($range_len === null) {
	$range_len = $rows;
	}

	$range_len = min($range_len, $rows - $range_start);

	// Gaps - compute gaps in the visible display diff, where we will render
	// "Show more context" spacers. This builds an aggregate $mask of all the
	// lines we must show (because they are near changed lines, near inline
	// comments, or the request has explicitly asked for them, i.e. resulting
	// from the user clicking "show more") and then finds all the gaps between
	// visible lines. If a gap is smaller than the context size, we just
	// display it. Otherwise, we record it into $gaps and will render a
	// "show more context" element instead of diff text below.

	$gaps = array();
	$gap_start = 0;
	$in_gap = false;
	$mask = $this->visible + $mask_force + $feedback_mask;
	$mask[$range_start + $range_len] = true;
	for ($ii = $range_start; $ii <= $range_start + $range_len; $ii++) {
	if (isset($mask[$ii])) {
	if ($in_gap) {
	$gap_length = $ii - $gap_start;
	if ($gap_length <= self::LINES_CONTEXT) {
	for ($jj = $gap_start; $jj <= $gap_start + $gap_length; $jj++) {
	$mask[$jj] = true;
	}
	} else {
	$gaps[] = array($gap_start, $gap_length);
	}
	$in_gap = false;
	}
	} else {
	if (!$in_gap) {
	$gap_start = $ii;
	$in_gap = true;
	}
	}
	}

	$gaps = array_reverse($gaps);

	$reference = $this->renderingReference;

	$left_id = $this->leftSideChangesetID;
	$right_id = $this->rightSideChangesetID;

	// "N" stands for 'new' and means the comment should attach to the new file
	// when stored, i.e. DifferentialInlineComment->setIsNewFile().
	// "O" stands for 'old' and means the comment should attach to the old file.

	$left_char = $this->leftSideAttachesToNewFile
	? 'N'
	: 'O';
	$right_char = $this->rightSideAttachesToNewFile
	? 'N'
	: 'O';

	for ($ii = $range_start; $ii < $range_start + $range_len; $ii++) {
	if (empty($mask[$ii])) {
	// If we aren't going to show this line, we've just entered a gap.
	// Pop information about the next gap off the $gaps stack and render
	// an appropriate "Show more context" element. This branch eventually
	// increments $ii by the entire size of the gap and then continues
	// the loop.
	$gap = array_pop($gaps);
	$top = $gap[0];
	$len = $gap[1];

	$end = $top + $len - 20;

	$contents = array();

	if ($len > 40) {
	$contents[] = javelin_render_tag(
	'a',
	array(
	'href' => '#',
	'mustcapture' => true,
	'sigil' => 'show-more',
	'meta' => array(
	'ref' => $reference,
	'range' => "{$top}-{$len}/{$top}-20",
	),
	),
	"\xE2\x96\xB2 Show 20 Lines");
	}

	$contents[] = javelin_render_tag(
	'a',
	array(
	'href' => '#',
	'mustcapture' => true,
	'sigil' => 'show-more',
	'meta' => array(
	'ref' => $reference,
	'range' => "{$top}-{$len}/{$top}-{$len}",
	),
	),
	'Show All '.$len.' Lines');

	if ($len > 40) {
	$contents[] = javelin_render_tag(
	'a',
	array(
	'href' => '#',
	'mustcapture' => true,
	'sigil' => 'show-more',
	'meta' => array(
	'ref' => $reference,
	'range' => "{$top}-{$len}/{$end}-20",
	),
	),
	"\xE2\x96\xBC Show 20 Lines");
	};

	$container = javelin_render_tag(
	'tr',
	array(
	'sigil' => 'context-target',
	),
	'<td colspan="4" class="show-more">'.
	implode(' • ', $contents).
	'</td>');

	$html[] = $container;

	$ii += ($len - 1);
	continue;
	}

	if (isset($this->old[$ii])) {
	$o_num = $this->old[$ii]['line'];
	$o_text = isset($this->oldRender[$ii]) ? $this->oldRender[$ii] : null;
	$o_attr = null;
	if ($this->old[$ii]['type']) {
	if (empty($this->new[$ii])) {
	$o_attr = ' class="old old-full"';
	} else {
	$o_attr = ' class="old"';
	}
	}
	} else {
	$o_num = null;
	$o_text = null;
	$o_attr = null;
	}

	if (isset($this->new[$ii])) {
	$n_num = $this->new[$ii]['line'];
	$n_text = isset($this->newRender[$ii]) ? $this->newRender[$ii] : null;
	$n_attr = null;
	if ($this->new[$ii]['type']) {
	if (empty($this->old[$ii])) {
	$n_attr = ' class="new new-full"';
	} else {
	$n_attr = ' class="new"';
	}
	}
	} else {
	$n_num = null;
	$n_text = null;
	$n_attr = null;
	}


	if (($o_num && !empty($this->missingOld[$o_num])) \|\|
	($n_num && !empty($this->missingNew[$n_num]))) {
	$html[] = $context_not_available;
	}

	if ($o_num && $left_id) {
	$o_id = ' id="C'.$left_id.$left_char.'L'.$o_num.'"';
	} else {
	$o_id = null;
	}

	if ($n_num && $right_id) {
	$n_id = ' id="C'.$right_id.$right_char.'L'.$n_num.'"';
	} else {
	$n_id = null;
	}

	// NOTE: The Javascript is sensitive to whitespace changes in this
	// block!
	$html[] =
	'<tr>'.
	'<th'.$o_id.'>'.$o_num.'</th>'.
	'<td'.$o_attr.'>'.$o_text.'</td>'.
	'<th'.$n_id.'>'.$n_num.'</th>'.
	'<td'.$n_attr.'>'.$n_text.'</td>'.
	'</tr>';

	if ($context_not_available && ($ii == $rows - 1)) {
	$html[] = $context_not_available;
	}

	if ($o_num && isset($old_comments[$o_num])) {
	foreach ($old_comments[$o_num] as $comment) {
	$xhp = $this->renderInlineComment($comment);
	$html[] =
	'<tr class="inline"><th /><td>'.
	$xhp.
	'</td><th /><td /></tr>';
	}
	}
	if ($n_num && isset($new_comments[$n_num])) {
	foreach ($new_comments[$n_num] as $comment) {
	$xhp = $this->renderInlineComment($comment);
	$html[] =
	'<tr class="inline"><th /><td /><th /><td>'.
	$xhp.
	'</td></tr>';
	}
	}
	}

	return implode('', $html);
	}

	private function renderInlineComment(DifferentialInlineComment $comment) {

	$user = $this->user;
	$edit = $user &&
	($comment->getAuthorPHID() == $user->getPHID()) &&
	(!$comment->getCommentID());

	$on_right = $this->isCommentOnRightSideWhenDisplayed($comment);

	return id(new DifferentialInlineCommentView())
	->setInlineComment($comment)
	->setOnRight($on_right)
	->setHandles($this->handles)
	->setMarkupEngine($this->markupEngine)
	->setEditable($edit)
	->render();
	}

	protected function renderPropertyChangeHeader($changeset) {
	$old = $changeset->getOldProperties();
	$new = $changeset->getNewProperties();

	if ($old === $new) {
	return null;
	}

	if ($changeset->getChangeType() == DifferentialChangeType::TYPE_ADD &&
	$new == array('unix:filemode' => '100644')) {
	return null;
	}

	if ($changeset->getChangeType() == DifferentialChangeType::TYPE_DELETE &&
	$old == array('unix:filemode' => '100644')) {
	return null;
	}

	- return null;
	-/*
	- TODO
	-
	- $table = <table class="differential-property-table" />;
	- $table->appendChild(
	- <tr class="property-table-header">
	- <th>Property Changes</th>
	- <td class="oval">Old Value</td>
	- <td class="nval">New Value</td>
	- </tr>);
	-
	$keys = array_keys($old + $new);
	sort($keys);
	+
	+ $rows = array();
	foreach ($keys as $key) {
	$oval = idx($old, $key);
	$nval = idx($new, $key);
	if ($oval !== $nval) {
	if ($oval === null) {
	- $oval = <em>null</em>;
	+ $oval = '<em>null</em>';
	+ } else {
	+ $oval = phutil_escape_html($oval);
	}
	+
	if ($nval === null) {
	- $nval = <em>null</em>;
	+ $nval = '<em>null</em>';
	+ } else {
	+ $nval = phutil_escape_html($nval);
	}
	- $table->appendChild(
	- <tr>
	- <th>{$key}</th>
	- <td class="oval">{$oval}</td>
	- <td class="nval">{$nval}</td>
	- </tr>);
	+
	+ $rows[] =
	+ '<tr>'.
	+ '<th>'.phutil_escape_html($key).'</th>'.
	+ '<td class="oval">'.$oval.'</td>'.
	+ '<td class="nval">'.$nval.'</td>'.
	+ '</tr>';
	}
	}

	- return $table;
	-*/
	+ return
	+ '<table class="differential-property-table">'.
	+ '<tr class="property-table-header">'.
	+ '<th>Property Changes</th>'.
	+ '<td class="oval">Old Value</td>'.
	+ '<td class="nval">New Value</td>'.
	+ '</tr>'.
	+ implode('', $rows).
	+ '</table>';
	}

	protected function renderChangesetTable($changeset, $contents) {
	$props = $this->renderPropertyChangeHeader($this->changeset);
	$table = null;
	if ($contents) {
	$table =
	'<table class="differential-diff remarkup-code PhabricatorMonospaced">'.
	$contents.
	'</table>';
	}

	if (!$table && !$props) {
	$notice = $this->renderChangeTypeHeader($this->changeset, true);
	} else {
	$notice = $this->renderChangeTypeHeader($this->changeset, false);
	}

	return implode(
	"\n",
	array(
	$notice,
	$props,
	$table,
	));
	}

	protected function renderChangeTypeHeader($changeset, $force) {

	static $articles = array(
	DifferentialChangeType::FILE_IMAGE => 'an',
	);

	static $files = array(
	DifferentialChangeType::FILE_TEXT => 'file',
	DifferentialChangeType::FILE_IMAGE => 'image',
	DifferentialChangeType::FILE_DIRECTORY => 'directory',
	DifferentialChangeType::FILE_BINARY => 'binary file',
	DifferentialChangeType::FILE_SYMLINK => 'symlink',
	);

	static $changes = array(
	DifferentialChangeType::TYPE_ADD => 'added',
	DifferentialChangeType::TYPE_CHANGE => 'changed',
	DifferentialChangeType::TYPE_DELETE => 'deleted',
	DifferentialChangeType::TYPE_MOVE_HERE => 'moved from',
	DifferentialChangeType::TYPE_COPY_HERE => 'copied from',
	DifferentialChangeType::TYPE_MOVE_AWAY => 'moved to',
	DifferentialChangeType::TYPE_COPY_AWAY => 'copied to',
	DifferentialChangeType::TYPE_MULTICOPY
	=> 'deleted after being copied to',
	);

	$change = $changeset->getChangeType();
	$file = $changeset->getFileType();

	$message = null;
	if ($change == DifferentialChangeType::TYPE_CHANGE &&
	$file == DifferentialChangeType::FILE_TEXT) {
	if ($force) {
	// We have to force something to render because there were no changes
	// of other kinds.
	$message = "This {$files[$file]} was not modified.";
	} else {
	// Default case of changes to a text file, no metadata.
	return null;
	}
	} else {
	$verb = idx($changes, $change, 'changed');
	switch ($change) {
	default:
	$message = "This {$files[$file]} was <strong>{$verb}</strong>.";
	break;
	case DifferentialChangeType::TYPE_MOVE_HERE:
	case DifferentialChangeType::TYPE_COPY_HERE:
	$message =
	"This {$files[$file]} was {$verb} ".
	"<strong>{$changeset->getOldFile()}</strong>.";
	break;
	case DifferentialChangeType::TYPE_MOVE_AWAY:
	case DifferentialChangeType::TYPE_COPY_AWAY:
	case DifferentialChangeType::TYPE_MULTICOPY:
	$paths = $changeset->getAwayPaths();
	if (count($paths) > 1) {
	$message =
	"This {$files[$file]} was {$verb}: ".
	"<strong>".implode(', ', $paths)."</strong>.";
	} else {
	$message =
	"This {$files[$file]} was {$verb} ".
	"<strong>".reset($paths)."</strong>.";
	}
	break;
	case DifferentialChangeType::TYPE_CHANGE:
	$message = "This is ".idx($articles, $file, 'a')." {$files[$file]}.";
	break;
	}
	}

	return
	'<div class="differential-meta-notice">'.
	$message.
	'</div>';
	}

	public function renderForEmail() {
	$ret = '';

	$min = min(count($this->old), count($this->new));
	for ($i = 0; $i < $min; $i++) {
	$o = $this->old[$i];
	$n = $this->new[$i];

	if (!isset($this->visible[$i])) {
	continue;
	}

	if ($o['line'] && $n['line']) {
	// It is quite possible there are better ways to achieve this. For
	// example, "white-space: pre;" can do a better job, WERE IT NOT for
	// broken email clients like OWA which use newlines to do weird
	// wrapping. So dont give them newlines.
	if (isset($this->intra[$i])) {
	$ret .= sprintf(
	"<font color=\"red\">- %s</font><br/>",
	str_replace(" ", " ", phutil_escape_html($o['text']))
	);
	$ret .= sprintf(
	"<font color=\"green\">+ %s</font><br/>",
	str_replace(" ", " ", phutil_escape_html($n['text']))
	);
	} else {
	$ret .= sprintf("  %s<br/>",
	str_replace(" ", " ", phutil_escape_html($n['text']))
	);
	}
	} else if ($o['line'] && !$n['line']) {
	$ret .= sprintf(
	"<font color=\"red\">- %s</font><br/>",
	str_replace(" ", " ", phutil_escape_html($o['text']))
	);
	} else {
	$ret .= sprintf(
	"<font color=\"green\">+ %s</font><br/>",
	str_replace(" ", " ", phutil_escape_html($n['text']))
	);
	}
	}

	return $ret;
	}

	}
	diff --git a/webroot/rsrc/css/application/differential/changeset-view.css b/webroot/rsrc/css/application/differential/changeset-view.css
	index b58b8aec9b..9599b1f7a5 100644
	--- a/webroot/rsrc/css/application/differential/changeset-view.css
	+++ b/webroot/rsrc/css/application/differential/changeset-view.css
	@@ -1,182 +1,231 @@
	/**
	* @provides differential-changeset-view-css
	*/

	.differential-diff {
	background: #ffffff;
	font-family: "Menlo", "Consolas", "Monaco", monospace;
	font-size: 10px;
	width: 100%;
	}

	.differential-diff td {
	/* using monospace fonts makes ex/em most useful:
	*
	* Unfortunately, firefox 3.6 renders diffs columns for added and removed
	* files "way-too-wide" when given em as the dimension measurement, so we
	* use an eyeballed ex equivalent and reset it to the ch character width
	* measurement for browsers that support that css3 measurement.
	*/
	width: 88ex;
	width: 81ch;
	/*
	Disable ligatures in Firefox. Firefox 3 has fancypants ligature support, but
	it gets applied to monospaced fonts, which sucks because it means that the
	"fi" ligature only takes up one character, e.g. It's probably the font's
	fault that it even specifies ligatures (seriously, what the hell?) but
	that's hard to fix and this is "easy" to "fix": custom letter spacing
	disables ligatures, as long as it's at least 0.008333-repeating pixels of
	custom letter spacing. I have no idea where this number comes from, but note
	that .83333.. = 5/6. -epriestley
	*/
	letter-spacing: 0.0083334px;
	vertical-align: top;
	white-space: pre;
	padding: 0 8px 1px;
	line-height: 16px;
	overflow: hidden;
	}

	.differential-diff th {
	text-align: right;
	padding: 2px 6px;
	width: 44px;
	vertical-align: top;
	background: #eeeeee;
	color: #888888;
	cursor: pointer;
	border-style: solid;
	border-width: 0px 1px;
	border-color: #eeeeee #999999 #eeeeee #dddddd;
	font-weight: bold;
	font-family: "Verdana";
	font-size: 11px;
	overflow: hidden;
	}

	.differential-diff td.old {
	background: #ffd0d0;
	color: #161111;
	}

	.differential-diff td.new {
	background: #d0ffd0;
	color: #111611;
	}

	.differential-diff td.old-full,
	.differential-diff td.old span.bright {
	background: #ffaaaa;
	color: #221111;
	}

	.differential-diff td.new-full,
	.differential-diff td.new span.bright {
	background: #aaffaa;
	color: #112211;
	}

	.differential-diff td.show-more,
	.differential-diff td.differential-shield {
	background: #ffffee;
	padding: 1em;
	text-align: center;
	font-family: "Verdana";
	font-size: 11px;
	border: 1px solid #ccccaa;
	white-space: normal;
	}

	.differential-diff td.show-more {
	color: #999966;
	}

	.differential-diff td.differential-shield {
	text-align: center;
	max-width: 1160px;
	}

	.differential-diff td.differential-shield a {
	font-weight: bold;
	}

	.differential-meta-notice {
	border: 1px solid #ffdd99;
	background: #ffeeaa;
	font-family: "Verdana";
	font-size: 11px;
	padding: 1em;
	margin: 0 0 6px 0;
	}

	.differential-changeset h1 {
	font-size: 14px;
	font-weight: bold;
	padding: 2px 0 8px;
	}

	.differential-changeset {
	margin: 0.5em 0;
	padding: 10px 0px 20px;
	}

	.differential-reticle {
	background: #ffeeaa;
	border: 1px solid #ffcc00;
	position: absolute;
	z-index: 2;
	opacity: 0.5;
	top: 0px;
	left: 0px;
	}

	.differential-inline-comment {
	background: #f9f9f1;
	border: 1px solid #aaaa88;
	font-family: Verdana;
	font-size: 11px;
	margin: 4px 0px;
	padding: 8px 10px;
	width: 100%;
	-moz-box-sizing: border-box;
	-webkit-box-sizing: border-box;
	overflow: hidden;
	max-width: 520px;
	white-space: normal;
	}

	.differential-inline-comment-head {
	font-weight: bold;
	color: #333333;
	border-bottom: 1px solid #ccccaa;
	padding-bottom: 6px;
	margin-bottom: 4px;
	}

	.differential-inline-comment-links,
	.differential-inline-comment-line {
	font-weight: normal;
	font-style: italic;
	color: #666666;
	float: right;
	white-space: nowrap;
	}

	.differential-inline-comment-links {
	margin-left: 8px;
	font-style: normal;
	}


	.differential-inline-comment-edit-textarea {
	width: 100%;
	height: 12em;
	}

	.differential-changeset-buttons {
	float: right;
	}

	.differential-changeset-buttons a.button {
	margin-left: 8px;
	}
	+
	+
	+.differential-property-table {
	+ width: auto;
	+ margin: .75em auto;
	+ background: #e3e3e3;
	+}
	+
	+.differential-property-table th {
	+ text-align: right;
	+ width: 10em;
	+ font-weight: bold;
	+ color: #666666;
	+ white-space: nowrap;
	+ padding: 4px 8px;
	+ border-right: 1px solid #666666;
	+}
	+
	+.differential-property-table td {
	+ padding: 4px 8px;
	+ width: 35em;
	+}
	+
	+.differential-property-table td em {
	+ color: #888888;
	+}
	+
	+.differential-property-table tr.property-table-header th,
	+.differential-property-table tr.property-table-header td {
	+ text-align: center;
	+ font-weight: bold;
	+ border-bottom: 1px solid #666666;
	+}
	+
	+.differential-property-table td.oval {
	+ background: #ffd0d0;
	+}
	+
	+.differential-property-table td.nval {
	+ background: #d0ffd0;
	+}
	+
	+.differential-property-table tr.property-table-header td.oval {
	+ background: #ffaaaa;
	+}
	+
	+.differential-property-table tr.property-table-header td.nval {
	+ background: #aaffaa;
	+}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 16:41 (2 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1126576
Default Alt Text: (88 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions