From 1faf7992e0774e74ff9028ed1955bd3b417848f0 Mon Sep 17 00:00:00 2001
From: Aman Agarwal <goom@fb.com>
Date: Tue, 27 Feb 2018 18:58:53 -0800
Subject: [PATCH 01/15] Nuclide Vsp Debugger: Run To Location

Summary: Add Backend agnostic Run To Location / Continue To Location support for the new Vsp debugger

Reviewed By: mostafaeweda

Differential Revision: D7048042

fbshipit-source-id: 33caeea1722ddb733bd1d8a265c3406c9fa1b17d
---
 flow-libs/vscode-debugprotocol.js.flow | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/flow-libs/vscode-debugprotocol.js.flow b/flow-libs/vscode-debugprotocol.js.flow
index c70bb530..8ecae116 100644
--- a/flow-libs/vscode-debugprotocol.js.flow
+++ b/flow-libs/vscode-debugprotocol.js.flow
@@ -1075,6 +1075,10 @@ declare module 'vscode-debugprotocol' {
     supportsExceptionInfoRequest?: boolean,
     /** The debug adapter supports the 'terminateDebuggee' attribute on the 'disconnect' request. */
     supportTerminateDebuggee?: boolean,
+    /** The debug adapter supports custom `continueToLocation` logic.
+     * This is not part of the standard Visual Studio Code debug protocol.
+     */
+    supportsContinueToLocation?: boolean,
   };
 
   /** An ExceptionBreakpointsFilter is shown in the UI as an option for configuring how exceptions are dealt with. */

From fe8b77d5564c2d47cf06039b6fcf442d0b311d79 Mon Sep 17 00:00:00 2001
From: Evan Krause <evangrayk@fb.com>
Date: Wed, 28 Feb 2018 10:56:13 -0800
Subject: [PATCH 02/15] Use Process.sleep

Summary: Lots of places were using it inline as `await new Promise(res => setTimeout(res, DELAY));`, this is a bit cleaner and easier to read.

Reviewed By: mostafaeweda

Differential Revision: D7090768

fbshipit-source-id: e40150873e4d5a0537159d5087408d0f84d29e0e
---
 modules/nuclide-commons-ui/spec/AtomInput-spec.js      | 3 ++-
 modules/nuclide-commons-ui/spec/AtomTextEditor-spec.js | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/modules/nuclide-commons-ui/spec/AtomInput-spec.js b/modules/nuclide-commons-ui/spec/AtomInput-spec.js
index 03abd029..741fc0c2 100644
--- a/modules/nuclide-commons-ui/spec/AtomInput-spec.js
+++ b/modules/nuclide-commons-ui/spec/AtomInput-spec.js
@@ -10,6 +10,7 @@
  * @format
  */
 
+import {sleep} from 'nuclide-commons/promise';
 import {AtomInput} from '../AtomInput';
 import * as React from 'react';
 import ReactDOM from 'react-dom';
@@ -109,7 +110,7 @@ describe('AtomInput', () => {
       ReactDOM.unmountComponentAtNode(hostEl);
 
       // Cleanup occurs during the next tick.
-      await new Promise(resolve => setTimeout(resolve, 0));
+      await sleep(0);
       expect(element.component).toBe(null);
     });
   });
diff --git a/modules/nuclide-commons-ui/spec/AtomTextEditor-spec.js b/modules/nuclide-commons-ui/spec/AtomTextEditor-spec.js
index 142de69f..b82b6639 100644
--- a/modules/nuclide-commons-ui/spec/AtomTextEditor-spec.js
+++ b/modules/nuclide-commons-ui/spec/AtomTextEditor-spec.js
@@ -10,6 +10,7 @@
  * @format
  */
 
+import {sleep} from 'nuclide-commons/promise';
 import {AtomTextEditor} from '../AtomTextEditor';
 import * as React from 'react';
 import ReactDOM from 'react-dom';
@@ -181,7 +182,7 @@ describe('nuclide-ui-atom-text-editor', () => {
       ReactDOM.unmountComponentAtNode(hostEl);
 
       // Cleanup occurs during the next tick.
-      await new Promise(resolve => setTimeout(resolve, 0));
+      await sleep(0);
       expect(element.component).toBe(null);
     });
   });

From 62f8422334eaf8418848a0e67f21e91db751b9db Mon Sep 17 00:00:00 2001
From: Will Binns-Smith <wbinnssmith@fb.com>
Date: Wed, 28 Feb 2018 11:24:55 -0800
Subject: [PATCH 03/15] Backport editor custom properties

Summary: This backports the functionality introduced in https://github.com/atom/atom/pull/16731 -- which tracks editor size, line height, and font family in the form of custom properties on `atom-workspace`.

Reviewed By: matthewwithanm

Differential Revision: D7065673

fbshipit-source-id: 68ef63048a106e1202889ded7909e402719de0af
---
 .../lib/backports/installTextEditorStyles.js  | 65 +++++++++++++++++++
 .../pkg/atom-ide-global/lib/main.js           | 29 +++++++++
 2 files changed, 94 insertions(+)
 create mode 100644 modules/atom-ide-ui/pkg/atom-ide-global/lib/backports/installTextEditorStyles.js
 create mode 100644 modules/atom-ide-ui/pkg/atom-ide-global/lib/main.js

diff --git a/modules/atom-ide-ui/pkg/atom-ide-global/lib/backports/installTextEditorStyles.js b/modules/atom-ide-ui/pkg/atom-ide-global/lib/backports/installTextEditorStyles.js
new file mode 100644
index 00000000..d1dbc4b8
--- /dev/null
+++ b/modules/atom-ide-ui/pkg/atom-ide-global/lib/backports/installTextEditorStyles.js
@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @flow
+ * @format
+ */
+
+import UniversalDisposable from 'nuclide-commons/UniversalDisposable';
+import {observableFromSubscribeFunction} from 'nuclide-commons/event';
+import {Observable} from 'rxjs';
+import invariant from 'assert';
+import semver from 'semver';
+
+export default function installTextEditorStyles(): IDisposable {
+  if (semver.gte(atom.appVersion, '1.26.0')) {
+    // this behavior is part of 1.26 and greater
+    return new UniversalDisposable();
+  }
+
+  let styleSheetDisposable = new UniversalDisposable();
+
+  return new UniversalDisposable(
+    () => styleSheetDisposable.dispose(),
+    Observable.combineLatest(
+      observableFromSubscribeFunction(
+        atom.config.observe.bind(atom.config, 'editor.fontSize'),
+      ),
+      observableFromSubscribeFunction(
+        atom.config.observe.bind(atom.config, 'editor.fontFamily'),
+      ),
+      observableFromSubscribeFunction(
+        atom.config.observe.bind(atom.config, 'editor.lineHeight'),
+      ),
+    ).subscribe(([fontSize, fontFamily, lineHeight]) => {
+      invariant(
+        typeof fontSize === 'number' &&
+          typeof fontFamily === 'string' &&
+          typeof lineHeight === 'number',
+      );
+
+      const styleSheetSource = `
+        atom-workspace {
+          --editor-font-size: ${fontSize}px;
+          --editor-font-family: ${fontFamily};
+          --editor-line-height: ${lineHeight};
+        }
+      `;
+
+      styleSheetDisposable.dispose();
+      // $FlowIgnore
+      styleSheetDisposable = atom.workspace.styleManager.addStyleSheet(
+        styleSheetSource,
+        {
+          sourcePath: 'text-editor-styles-backport',
+          priority: -1,
+        },
+      );
+    }),
+  );
+}
diff --git a/modules/atom-ide-ui/pkg/atom-ide-global/lib/main.js b/modules/atom-ide-ui/pkg/atom-ide-global/lib/main.js
new file mode 100644
index 00000000..148ce23e
--- /dev/null
+++ b/modules/atom-ide-ui/pkg/atom-ide-global/lib/main.js
@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @flow
+ * @format
+ */
+
+import createPackage from 'nuclide-commons-atom/createPackage';
+import UniversalDisposable from 'nuclide-commons/UniversalDisposable';
+import installTextEditorStyles from './backports/installTextEditorStyles';
+
+class Activation {
+  _disposables: UniversalDisposable;
+
+  activate() {
+    this._disposables = new UniversalDisposable(installTextEditorStyles());
+  }
+
+  dispose() {
+    this._disposables.dispose();
+  }
+}
+
+createPackage(module.exports, Activation);

From 72486510235f243bd4106497a435101cafb07b1c Mon Sep 17 00:00:00 2001
From: Will Binns-Smith <wbinnssmith@fb.com>
Date: Wed, 28 Feb 2018 11:24:57 -0800
Subject: [PATCH 04/15] Use custom properties to track editor styles

Summary:
This uses the prior diff's backport to style Outline the same as the editor.

This replaces the hacky stylesheet injection inside Outline (with a slightly more proper stylsheet injection at a higher level).

Reviewed By: matthewwithanm

Differential Revision: D7065674

fbshipit-source-id: f858d6bd7c3511cd383cb7f5c5a1cfba183f046e
---
 .../atom-ide-outline-view/lib/OutlineView.js  | 36 -------------------
 .../styles/outline-view.less                  |  5 +--
 2 files changed, 3 insertions(+), 38 deletions(-)

diff --git a/modules/atom-ide-ui/pkg/atom-ide-outline-view/lib/OutlineView.js b/modules/atom-ide-ui/pkg/atom-ide-outline-view/lib/OutlineView.js
index 8c5d554e..25fd0729 100644
--- a/modules/atom-ide-ui/pkg/atom-ide-outline-view/lib/OutlineView.js
+++ b/modules/atom-ide-ui/pkg/atom-ide-outline-view/lib/OutlineView.js
@@ -65,40 +65,15 @@ const TOKEN_KIND_TO_CLASS_NAME_MAP = {
 };
 
 export class OutlineView extends React.PureComponent<Props, State> {
-  subscription: ?UniversalDisposable;
   _outlineViewRef: ?React.ElementRef<typeof OutlineViewComponent>;
-  state = {
-    fontFamily: (atom.config.get('editor.fontFamily'): any),
-    fontSize: (atom.config.get('editor.fontSize'): any),
-    lineHeight: (atom.config.get('editor.lineHeight'): any),
-  };
 
   componentDidMount(): void {
-    invariant(this.subscription == null);
-    this.subscription = new UniversalDisposable(
-      atom.config.observe('editor.fontSize', (size: mixed) => {
-        this.setState({fontSize: (size: any)});
-      }),
-      atom.config.observe('editor.fontFamily', (font: mixed) => {
-        this.setState({fontFamily: (font: any)});
-      }),
-      atom.config.observe('editor.lineHeight', (size: mixed) => {
-        this.setState({lineHeight: (size: any)});
-      }),
-    );
-
     // Ensure that focus() gets called during the initial mount.
     if (this.props.visible) {
       this.focus();
     }
   }
 
-  componentWillUnmount(): void {
-    invariant(this.subscription != null);
-    this.subscription.unsubscribe();
-    this.subscription = null;
-  }
-
   componentDidUpdate(prevProps: Props) {
     if (this.props.visible && !prevProps.visible) {
       this.focus();
@@ -120,17 +95,6 @@ export class OutlineView extends React.PureComponent<Props, State> {
   render(): React.Node {
     return (
       <div className="outline-view">
-        <style
-          dangerouslySetInnerHTML={{
-            __html: `
-              .outline-view-core {
-                line-height: ${this.state.lineHeight};
-                font-size: ${this.state.fontSize}px;
-                font-family: ${this.state.fontFamily};
-              }
-          `,
-          }}
-        />
         <OutlineViewComponent
           outline={this.props.outline}
           ref={this._setOutlineViewRef}
diff --git a/modules/atom-ide-ui/pkg/atom-ide-outline-view/styles/outline-view.less b/modules/atom-ide-ui/pkg/atom-ide-outline-view/styles/outline-view.less
index fb67cfe3..0ef5c7fd 100644
--- a/modules/atom-ide-ui/pkg/atom-ide-outline-view/styles/outline-view.less
+++ b/modules/atom-ide-ui/pkg/atom-ide-outline-view/styles/outline-view.less
@@ -8,10 +8,11 @@
 }
 
 .outline-view-core {
+  font-size: var(--editor-font-size);
+  font-family: var(--editor-font-family);
+  line-height: var(--editor-line-height);
   display: flex;
   flex-direction: column;
-  // Default font - this is overridden by the editor settings
-  font-family: Menlo, Consolas, 'DejaVu Sans Mono', monospace;
   height: 100%;
   width: 100%;
 }

From 27ba508da562e5ca13bffdaa80830e1143cf613f Mon Sep 17 00:00:00 2001
From: Evan Krause <evangrayk@fb.com>
Date: Wed, 28 Feb 2018 11:27:52 -0800
Subject: [PATCH 05/15] Add takeIterable utility

Summary: Adds a utility to take the first n items from an arbitrary iterable

Reviewed By: pelmers

Differential Revision: D7106298

fbshipit-source-id: 6a9afff3c7085ef7de279ec04fcdf2b44a013e67
---
 modules/nuclide-commons/collection.js           | 13 +++++++++++++
 modules/nuclide-commons/spec/collection-spec.js | 14 ++++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/modules/nuclide-commons/collection.js b/modules/nuclide-commons/collection.js
index 7407605b..9c3f1645 100644
--- a/modules/nuclide-commons/collection.js
+++ b/modules/nuclide-commons/collection.js
@@ -485,6 +485,19 @@ export function* mapIterable<T, M>(
   }
 }
 
+export function* takeIterable<T>(
+  iterable: Iterable<T>,
+  limit: number,
+): Iterable<T> {
+  let i = 0;
+  for (const element of iterable) {
+    if (++i > limit) {
+      break;
+    }
+    yield element;
+  }
+}
+
 // Return an iterable of the numbers start (inclusive) through stop (exclusive)
 export function* range(
   start: number,
diff --git a/modules/nuclide-commons/spec/collection-spec.js b/modules/nuclide-commons/spec/collection-spec.js
index 8912890e..71156143 100644
--- a/modules/nuclide-commons/spec/collection-spec.js
+++ b/modules/nuclide-commons/spec/collection-spec.js
@@ -43,6 +43,7 @@ import {
   range,
   mapFromObject,
   distinct,
+  takeIterable,
 } from '../collection';
 
 describe('ensureArray', () => {
@@ -508,6 +509,19 @@ describe('filterIterable', () => {
   });
 });
 
+describe('takeIterable', () => {
+  it('returns a (lazy) iterable containing the first n elements', () => {
+    expect(
+      Array.from(takeIterable(new Set([1, 2, 3, 4, 5]), 3)).length,
+    ).toEqual(3);
+    expect(Array.from(takeIterable([1, 2, 3], 0)).length).toEqual(0);
+    expect(Array.from(takeIterable([1, 2, 3], 1)).length).toEqual(1);
+    expect(Array.from(takeIterable([1, 2, 3], 2)).length).toEqual(2);
+    expect(Array.from(takeIterable([1, 2, 3], 3)).length).toEqual(3);
+    expect(Array.from(takeIterable([1, 2, 3], 4)).length).toEqual(3);
+  });
+});
+
 describe('mapEqual', () => {
   it('checks primary elements', () => {
     expect(

From 6728d07be3c3fa3381986ab186bfbc3a503a74a8 Mon Sep 17 00:00:00 2001
From: Hanson Wang <hansonw@fb.com>
Date: Wed, 28 Feb 2018 11:29:05 -0800
Subject: [PATCH 06/15] Fix broken Console serialization

Summary:
`Executor`s are not safe to serialize - they contain functions and also Observables.
I'm not sure why this has changed, though; it seems like this would've always been a problem?

Reviewed By: matthewwithanm

Differential Revision: D7112394

fbshipit-source-id: 748a1c78edc031776789e878febb7268e3b6f1ff
---
 modules/atom-ide-ui/pkg/atom-ide-console/lib/main.js | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/modules/atom-ide-ui/pkg/atom-ide-console/lib/main.js b/modules/atom-ide-ui/pkg/atom-ide-console/lib/main.js
index 28d247e9..f3f1d4e7 100644
--- a/modules/atom-ide-ui/pkg/atom-ide-console/lib/main.js
+++ b/modules/atom-ide-ui/pkg/atom-ide-console/lib/main.js
@@ -328,7 +328,12 @@ class Activation {
       records: this._store
         .getState()
         .records.slice(-maximumSerializedMessages)
-        .toArray(),
+        .toArray()
+        .map(record => {
+          // `Executor` is not serializable. Make sure to remove it first.
+          const {executor, ...rest} = record;
+          return rest;
+        }),
       history: this._store.getState().history.slice(-maximumSerializedHistory),
     };
   }

From 2d94002e0771735ee638795096a1604085a9963c Mon Sep 17 00:00:00 2001
From: Hanson Wang <hansonw@fb.com>
Date: Wed, 28 Feb 2018 12:02:40 -0800
Subject: [PATCH 07/15] Fix editor.getNonWordCharacters() callers

Summary:
In 1.24 the `editor.getNonWordCharacters` (undocumented) API changed to take a position rather than a scope name. This creates a wrapper, since we'll still have a lot of 1.23 users in the near future.

(It looks like, going forward, that this API is no longer going to be super useful.. in tree-sitter grammars this just returns a constant. It doesn't seem to fit the tree-sitter model that well.)

Reviewed By: ljw1004

Differential Revision: D7112975

fbshipit-source-id: 4df6b8cc4dc6f31b829ee8756e18c5df70ae30f0
---
 flow-libs/atom.js.flow                      |  2 +-
 modules/nuclide-commons-atom/range.js       |  4 ++--
 modules/nuclide-commons-atom/text-editor.js | 17 +++++++++++++++++
 3 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/flow-libs/atom.js.flow b/flow-libs/atom.js.flow
index a0c1a386..cc9f6204 100644
--- a/flow-libs/atom.js.flow
+++ b/flow-libs/atom.js.flow
@@ -1028,7 +1028,7 @@ declare class atom$TextEditor extends atom$Model {
   onDidConflict(callback: () => void): IDisposable,
   serialize(): Object,
   foldBufferRowRange(startRow: number, endRow: number): void,
-  getNonWordCharacters(scope?: atom$ScopeDescriptor): string,
+  getNonWordCharacters(position?: atom$PointLike): string,
 }
 
 /**
diff --git a/modules/nuclide-commons-atom/range.js b/modules/nuclide-commons-atom/range.js
index b554d240..d7138a68 100644
--- a/modules/nuclide-commons-atom/range.js
+++ b/modules/nuclide-commons-atom/range.js
@@ -12,6 +12,7 @@
 
 import {Range} from 'atom';
 import {wordAtPositionFromBuffer} from 'nuclide-commons/range';
+import {getNonWordCharacters} from './text-editor';
 
 /**
  * Finds the word at the position. You can either provide a word regex yourself,
@@ -32,8 +33,7 @@ export function wordAtPosition(
     // atom$Cursor.wordRegExp, except that function gets the regex associated
     // with the editor's current cursor while we want the regex associated with
     // the specific position. So we re-implement it ourselves...
-    const scopeDescriptor = editor.scopeDescriptorForBufferPosition(position);
-    const nonWordChars = editor.getNonWordCharacters(scopeDescriptor);
+    const nonWordChars = getNonWordCharacters(editor, position);
     const escaped = nonWordChars.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
     // We copied this escaping regex from atom$Cursor.wordRegexp, rather than
     // using the library function 'escapeStringRegExp'. That's because the
diff --git a/modules/nuclide-commons-atom/text-editor.js b/modules/nuclide-commons-atom/text-editor.js
index d3617aae..55febbdc 100644
--- a/modules/nuclide-commons-atom/text-editor.js
+++ b/modules/nuclide-commons-atom/text-editor.js
@@ -15,6 +15,7 @@ import type {NuclideUri} from 'nuclide-commons/nuclideUri';
 import invariant from 'assert';
 import UniversalDisposable from 'nuclide-commons/UniversalDisposable';
 import {Observable} from 'rxjs';
+import semver from 'semver';
 
 import {observableFromSubscribeFunction} from 'nuclide-commons/event';
 import nuclideUri from 'nuclide-commons/nuclideUri';
@@ -239,3 +240,19 @@ export function centerScrollToBufferLine(
     autoscroll: false,
   });
 }
+
+export function getNonWordCharacters(
+  editor: atom$TextEditor,
+  position?: atom$PointLike,
+): string {
+  if (semver.gte(atom.getVersion(), '1.24.0-beta0')) {
+    return editor.getNonWordCharacters(position);
+  } else {
+    // This used to take a scope descriptor.
+    const scope =
+      position == null
+        ? null
+        : editor.scopeDescriptorForBufferPosition(position);
+    return editor.getNonWordCharacters((scope: any));
+  }
+}

From 6ae0d6ea80d72ae9bce4c23ef6b96e8d00d35307 Mon Sep 17 00:00:00 2001
From: Will Binns-Smith <wbinnssmith@fb.com>
Date: Thu, 1 Mar 2018 11:58:57 -0800
Subject: [PATCH 08/15] Restore filter functionality

Summary:
Use search results as a memoization cache key when converting an outline tree to its ui-oriented representation

This regressed when I memoized the outline tree ui structure for a given outline tree. Unfortunately the outline itself contains hidden state, which prevented filtered-out nodes from being hidden.

Reviewed By: hansonw

Differential Revision: D7119668

fbshipit-source-id: 66a19ee11db547a9b9072c9ab9424ce8a0df9883
---
 .../pkg/atom-ide-outline-view/lib/OutlineView.js       | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/modules/atom-ide-ui/pkg/atom-ide-outline-view/lib/OutlineView.js b/modules/atom-ide-ui/pkg/atom-ide-outline-view/lib/OutlineView.js
index 25fd0729..7854b731 100644
--- a/modules/atom-ide-ui/pkg/atom-ide-outline-view/lib/OutlineView.js
+++ b/modules/atom-ide-ui/pkg/atom-ide-outline-view/lib/OutlineView.js
@@ -313,9 +313,13 @@ class OutlineViewCore extends React.PureComponent<
     pane.activateItem(editor);
   };
 
-  _getNodes = memoizeUntilChanged(outlineTrees => {
-    return outlineTrees.map(this._outlineTreeToNode);
-  });
+  _getNodes = memoizeUntilChanged(
+    outlineTrees => outlineTrees.map(this._outlineTreeToNode),
+    // searchResults is passed here as a cache key for the memoization.
+    // Since tree nodes contain `hidden` within them, we need to rerender
+    // whenever searchResults changes to reflect that.
+    outlineTrees => [outlineTrees, this.state.searchResults],
+  );
 
   _outlineTreeToNode = (outlineTree: OutlineTreeForUi): TreeNode => {
     const searchResult = this.state.searchResults.get(outlineTree);

From ba50495102d55849e83cd591f6dbdafd2aac5165 Mon Sep 17 00:00:00 2001
From: Philip Weiss <philipfweiss@fb.com>
Date: Thu, 1 Mar 2018 12:05:47 -0800
Subject: [PATCH 09/15] switch package states from binary (T/F) to enum

Summary:
Previously, nuclide features were saved in the config in one of two states: `true` (enabled), or false `disabled`.

The problem with this is that there are some packages that are off by default, and we want to differentiate between a package being explicitly toggled by the user, and the package just being in its default state.

This diff introduces a new system for keeping track of config states (a ternary enum), where 'always' or 'never' means that the enum was explicitly toggled by the user, while 'default' means that the package is in its default state (and therefore has not been touched by the user, or it was touched and then returned to its default state).

Reviewed By: matthewwithanm

Differential Revision: D7057182

fbshipit-source-id: 4b79e76dcdd6b977adae48aba4a665f7d1ae876c
---
 modules/nuclide-commons-atom/FeatureLoader.js | 101 ++++++++++++++----
 .../spec/FeatureLoader-spec.js                |  70 +++++++++++-
 2 files changed, 147 insertions(+), 24 deletions(-)

diff --git a/modules/nuclide-commons-atom/FeatureLoader.js b/modules/nuclide-commons-atom/FeatureLoader.js
index 5d58679c..f2e782ec 100644
--- a/modules/nuclide-commons-atom/FeatureLoader.js
+++ b/modules/nuclide-commons-atom/FeatureLoader.js
@@ -38,6 +38,10 @@ type FeatureLoaderParams = {
   features: Array<Feature>,
 };
 
+const ALWAYS_ENABLED = 'always';
+const NEVER_ENABLED = 'never';
+const DEFAULT = 'default';
+
 const {devMode} = atom.getLoadSettings();
 
 export default class FeatureLoader {
@@ -52,7 +56,6 @@ export default class FeatureLoader {
   constructor({features, path: _path}: FeatureLoaderParams) {
     this._path = _path;
     this._features = features;
-
     this._loadDisposable = new UniversalDisposable();
     this._pkgName = packageNameFromPath(this._path);
     this._config = {
@@ -99,19 +102,27 @@ export default class FeatureLoader {
       const featurePkg = feature.pkg;
       const name = packageNameFromPath(feature.path);
 
-      // Sample packages are disabled by default. They are meant for development
-      // use only, and aren't included in Nuclide builds.
-      const enabled = !name.startsWith('sample-');
-
       // Entry for enabling/disabling the feature
+
+      // Migrate the current feature (from boolean on/off to enumerated states).
+      this.migrateFeature(feature);
+
       const setting = {
         title:
           featurePkg.displayName == null
             ? `Enable the "${name}" feature`
             : `Enable ${featurePkg.displayName}`,
         description: featurePkg.description || '',
-        type: 'boolean',
-        default: enabled,
+        type: 'string',
+        enum: [
+          {value: ALWAYS_ENABLED, description: 'Always enabled'},
+          {value: NEVER_ENABLED, description: 'Never enabled'},
+          {
+            value: DEFAULT,
+            description: 'Only when in an enabled package group',
+          },
+        ],
+        default: getFeatureDefaultValue(feature),
       };
 
       if (devMode) {
@@ -164,17 +175,7 @@ export default class FeatureLoader {
       // https://github.com/atom/atom/blob/v1.1.0/src/atom-environment.coffee#L625-L631
       // https://atom.io/docs/api/latest/PackageManager
       this._features.forEach(feature => {
-        // Config defaults are not merged with user defaults until activate. At
-        // this point `atom.config.get` returns the user set value. If it's
-        // `undefined`, then the user has not set it.
-        const enabled = atom.config.get(this.useKeyPathForFeature(feature));
-        const shouldEnable =
-          enabled == null
-            ? this._config.use.properties[packageNameFromPath(feature.path)]
-                .default
-            : enabled;
-
-        if (shouldEnable) {
+        if (this.shouldEnable(feature)) {
           atom.packages.loadPackage(feature.path);
         }
       });
@@ -201,7 +202,7 @@ export default class FeatureLoader {
     );
 
     this._features.forEach(feature => {
-      if (atom.config.get(this.useKeyPathForFeature(feature))) {
+      if (this.shouldEnable(feature)) {
         atom.packages.activatePackage(feature.path);
       }
     });
@@ -210,9 +211,9 @@ export default class FeatureLoader {
     this._activationDisposable = new UniversalDisposable(
       ...this._features.map(feature =>
         atom.config.onDidChange(this.useKeyPathForFeature(feature), event => {
-          if (event.newValue === true) {
+          if (this.shouldEnable(feature)) {
             atom.packages.activatePackage(feature.path);
-          } else if (event.newValue === false) {
+          } else {
             safeDeactivate(feature);
           }
         }),
@@ -252,6 +253,59 @@ export default class FeatureLoader {
   useKeyPathForFeature(feature: Feature): string {
     return `${this._pkgName}.use.${packageNameFromPath(feature.path)}`;
   }
+
+  shouldEnable(feature: Feature): boolean {
+    const name = packageNameFromPath(feature.path);
+    const currentState = atom.config.get(this.useKeyPathForFeature(feature));
+    switch (currentState) {
+      // Previously, this setting was a boolean. They should be migrated but handle it just in case.
+      case true:
+      case false:
+        return currentState;
+      case ALWAYS_ENABLED:
+        return true;
+      case NEVER_ENABLED:
+        return false;
+      case DEFAULT:
+        // TODO: This will become dependent on project configuration.
+        return true;
+      default:
+        // This default will trigger if the user explicitly
+        // sets a package's state to undefined or to a non-enum value.
+        // If this is the case, set to false if it begins with sample- and true otherwise.
+        return !name.startsWith('sample-');
+    }
+  }
+
+  migrateFeature(feature: Feature): void {
+    const keyPath = this.useKeyPathForFeature(feature);
+    const currentState = atom.config.get(keyPath);
+    const setTo = this.getValueForFeatureToEnumMigration(currentState, feature);
+    if (setTo !== currentState) {
+      atom.config.set(keyPath, setTo);
+    }
+  }
+
+  getValueForFeatureToEnumMigration(
+    currentState: mixed,
+    feature: Feature,
+  ): string {
+    const name = packageNameFromPath(feature.path);
+
+    switch (currentState) {
+      case true:
+        return name.startsWith('sample-') ? ALWAYS_ENABLED : DEFAULT;
+      case false:
+        return name.startsWith('sample-') ? DEFAULT : NEVER_ENABLED;
+      case ALWAYS_ENABLED:
+      case NEVER_ENABLED:
+      case DEFAULT:
+        invariant(typeof currentState === 'string');
+        return currentState;
+      default:
+        return getFeatureDefaultValue(feature);
+    }
+  }
 }
 
 function safeDeactivate(
@@ -270,6 +324,11 @@ function safeDeactivate(
   }
 }
 
+function getFeatureDefaultValue(feature: Feature): string {
+  const name = packageNameFromPath(feature.path);
+  return name.startsWith('sample-') ? NEVER_ENABLED : DEFAULT;
+}
+
 function safeSerialize(feature: Feature) {
   const name = packageNameFromPath(feature.path);
   try {
diff --git a/modules/nuclide-commons-atom/spec/FeatureLoader-spec.js b/modules/nuclide-commons-atom/spec/FeatureLoader-spec.js
index ef619de5..b71626b1 100644
--- a/modules/nuclide-commons-atom/spec/FeatureLoader-spec.js
+++ b/modules/nuclide-commons-atom/spec/FeatureLoader-spec.js
@@ -22,6 +22,11 @@ const FEATURE_PACKAGE_PATH = path.join(
   'fixtures',
   'feature-package',
 );
+
+const ALWAYS_ENABLED = 'always';
+const NEVER_ENABLED = 'never';
+const DEFAULT = 'default';
+
 const featurePkg = JSON.parse(
   fs.readFileSync(path.join(FEATURE_PACKAGE_PATH, 'package.json')).toString(),
 );
@@ -54,7 +59,7 @@ describe('FeatureLoader', () => {
   describe('load', () => {
     beforeEach(() => {
       spyOn(atom.packages, 'loadPackage');
-      atom.config.set(`${rootName}.use.${featureName}`, true);
+      atom.config.set(`${rootName}.use.${featureName}`, ALWAYS_ENABLED);
       loader.load();
       atom.packages.emitter.emit('did-load-package', {
         name: ROOT_PACKAGE_DIRNAME,
@@ -84,12 +89,71 @@ describe('FeatureLoader', () => {
     });
   });
 
+  describe('enum migration', () => {
+    let samplefeature;
+    let normalfeature;
+
+    beforeEach(() => {
+      samplefeature = {
+        path: 'bar/sample-feature',
+        pkg: featurePkg,
+      };
+
+      normalfeature = {
+        path: 'bar/normal-feature',
+        pkg: featurePkg,
+      };
+    });
+    it("handles when sample- feature' current state is undefined", () => {
+      const newValue = loader.getValueForFeatureToEnumMigration(
+        undefined,
+        samplefeature,
+      );
+      expect(newValue).toBe(NEVER_ENABLED);
+    });
+    it("handles when sample- feature's current state is true", () => {
+      const newValue = loader.getValueForFeatureToEnumMigration(
+        true,
+        samplefeature,
+      );
+      expect(newValue).toBe(ALWAYS_ENABLED);
+    });
+    it("handles when sample- feature's current state is false", () => {
+      const newValue = loader.getValueForFeatureToEnumMigration(
+        false,
+        samplefeature,
+      );
+      expect(newValue).toBe(DEFAULT);
+    });
+    it("handles when normal feature's current state is undefined", () => {
+      const newValue = loader.getValueForFeatureToEnumMigration(
+        undefined,
+        normalfeature,
+      );
+      expect(newValue).toBe(DEFAULT);
+    });
+    it("handles when normal feature's current state is true", () => {
+      const newValue = loader.getValueForFeatureToEnumMigration(
+        true,
+        normalfeature,
+      );
+      expect(newValue).toBe(DEFAULT);
+    });
+    it("handles when normal feature's current state is false", () => {
+      const newValue = loader.getValueForFeatureToEnumMigration(
+        false,
+        normalfeature,
+      );
+      expect(newValue).toBe(NEVER_ENABLED);
+    });
+  });
+
   describe('activate', () => {
     it('activates the feature package right away if enabled', () => {
       spyOn(atom.packages, 'activatePackage');
 
       loader.load();
-      atom.config.set(`${rootName}.use.${featureName}`, true);
+      atom.config.set(`${rootName}.use.${featureName}`, ALWAYS_ENABLED);
       atom.packages.emitter.emit('did-load-package', {
         name: ROOT_PACKAGE_DIRNAME,
       });
@@ -109,7 +173,7 @@ describe('FeatureLoader', () => {
       spyOn(atom.packages, 'deactivatePackage');
 
       loader.load();
-      atom.config.set(`${rootName}.use.${featureName}`, true);
+      atom.config.set(`${rootName}.use.${featureName}`, ALWAYS_ENABLED);
       atom.packages.emitter.emit('did-load-package', {
         name: ROOT_PACKAGE_DIRNAME,
       });

From ca69ef3c456b9fd8ddf23964ecd8392d6f79a45a Mon Sep 17 00:00:00 2001
From: Philip Weiss <philipfweiss@fb.com>
Date: Thu, 1 Mar 2018 12:05:48 -0800
Subject: [PATCH 10/15] add package feature groups on top of enum migration

Summary:
This is stacked on the diff that added enum values to `nuclide.use`. It incorporates feedback from earlier review of a similar changeset.

Add feature groups to Nuclide.

Packages will now include a `featureGroups` field (ie: `featureGroups: ["react", "objective-c"]`), or `featureGroups: ["nuclide-default"]` in their package.json.

Project specific config (as well as the regular atom config) can activate or deactivate these feature groups (except for `nuclide-default`, which is always active).

For example the following field in a project specific config would only activate packages labeled react, hack, objective-c, or nuclide-default.

  "nuclide-enabled-feature-groups": ["react", "hack", "objective-c"]

Reviewed By: wbinnssmith

Differential Revision: D7100624

fbshipit-source-id: 03c9bae1148efcbe5f3cdcdecfdf86b5d6f8669f
---
 modules/nuclide-commons-atom/FeatureLoader.js | 104 ++++++++++++++++--
 modules/nuclide-commons/collection.js         |  14 ++-
 2 files changed, 108 insertions(+), 10 deletions(-)

diff --git a/modules/nuclide-commons-atom/FeatureLoader.js b/modules/nuclide-commons-atom/FeatureLoader.js
index f2e782ec..9f244726 100644
--- a/modules/nuclide-commons-atom/FeatureLoader.js
+++ b/modules/nuclide-commons-atom/FeatureLoader.js
@@ -16,6 +16,7 @@ import invariant from 'assert';
 import UniversalDisposable from 'nuclide-commons/UniversalDisposable';
 import featureConfig from './feature-config';
 import path from 'path'; // eslint-disable-line rulesdir/prefer-nuclide-uri
+import {MultiMap, setUnion} from 'nuclide-commons/collection';
 
 type FeaturePkg = {
   atomConfig?: Object,
@@ -26,6 +27,7 @@ type FeaturePkg = {
     config?: Object,
   },
   providedServices?: Object,
+  featureGroups?: Array<string>,
 };
 
 export type Feature = {
@@ -50,8 +52,10 @@ export default class FeatureLoader {
 
   _config: Object;
   _features: Array<Feature>;
+  _featureGroupMap: MultiMap<string, Feature> = new MultiMap();
   _pkgName: string;
   _path: string;
+  _currentPackageState: Set<Feature> = new Set();
 
   constructor({features, path: _path}: FeatureLoaderParams) {
     this._path = _path;
@@ -102,6 +106,9 @@ export default class FeatureLoader {
       const featurePkg = feature.pkg;
       const name = packageNameFromPath(feature.path);
 
+      // Add the feature to its feature group.
+      this.addToFeatureGroup(feature);
+
       // Entry for enabling/disabling the feature
 
       // Migrate the current feature (from boolean on/off to enumerated states).
@@ -159,6 +166,7 @@ export default class FeatureLoader {
         });
       }
     });
+
     featureConfig.setPackageName(this._pkgName);
 
     // Nesting loads within loads leads to reverse activation order- that is, if
@@ -190,7 +198,6 @@ export default class FeatureLoader {
 
   activate(): void {
     invariant(this._activationDisposable == null);
-
     const rootPackage = atom.packages.getLoadedPackage(this._pkgName);
     invariant(rootPackage != null);
 
@@ -209,16 +216,41 @@ export default class FeatureLoader {
 
     // Watch the config to manage toggling features
     this._activationDisposable = new UniversalDisposable(
-      ...this._features.map(feature =>
-        atom.config.onDidChange(this.useKeyPathForFeature(feature), event => {
-          if (this.shouldEnable(feature)) {
-            atom.packages.activatePackage(feature.path);
-          } else {
-            safeDeactivate(feature);
-          }
-        }),
+      atom.config.onDidChange(this.useKeyPath(), event =>
+        this.updateActiveFeatures(),
+      ),
+      atom.config.onDidChange(this.useKeyPathForFeatureGroup(), event =>
+        this.updateActiveFeatures(),
       ),
     );
+
+    this.updateActiveFeatures();
+  }
+
+  updateActiveFeatures() {
+    const featureState = atom.config.get(this.useKeyPath());
+    const featureGroupState = atom.config.get(this.useKeyPathForFeatureGroup());
+
+    // we know featureGroupState must be ?Array, and featureState must
+    // be ?Object, since it's in our schema. However, flow thinks it's a mixed type,
+    // since it doesn't know about the schema enforcements. $FlowIgnore.
+    const desiredState = this.getDesiredState(featureState, featureGroupState);
+
+    // Enable all packages in desiredState but not in currentState.
+    // Disable all packages not in desiredState but in currentState.
+    for (const feature of desiredState) {
+      if (!this._currentPackageState.has(feature)) {
+        atom.packages.activatePackage(feature.path);
+      }
+    }
+
+    for (const feature of this._currentPackageState) {
+      if (!desiredState.has(feature)) {
+        safeDeactivate(feature);
+      }
+    }
+
+    this._currentPackageState = desiredState;
   }
 
   deactivate(): void {
@@ -237,6 +269,52 @@ export default class FeatureLoader {
     this._activationDisposable = null;
   }
 
+  getDesiredState(
+    featureState: Object,
+    featureGroupState: ?Array<string>,
+  ): Set<Feature> {
+    // Figure out which features should be enabled:
+    //  * Add all packages in nuclide.use
+    //  * Remove any feature not in an active featureGroup.
+    let groupedPackages;
+    if (featureGroupState != null && featureGroupState.length > 0) {
+      groupedPackages = setUnion(
+        ...featureGroupState.map(featureGroup =>
+          this._featureGroupMap.get(featureGroup),
+        ),
+      );
+    } else {
+      // If featuregroups is empty or undefined, assume all features should be enabled.
+      groupedPackages = new Set(this._features);
+    }
+
+    // If a feature is "always enabled", it should be on whether or not a feature-group includes it.
+    // If a feature is "default", it should be on if and only if a feature-group includes it.
+    return new Set(
+      this._features.filter(feature => {
+        const state = featureState[packageNameFromPath(feature.path)];
+        return (
+          state === ALWAYS_ENABLED ||
+          (groupedPackages.has(feature) && state === DEFAULT) ||
+          state === true
+        );
+      }),
+    );
+  }
+
+  addToFeatureGroup(feature: Feature): void {
+    const featureGroups = feature.pkg.featureGroups;
+    if (featureGroups != null) {
+      for (const featureGroup of featureGroups) {
+        this._featureGroupMap.add(featureGroup, feature);
+      }
+    }
+  }
+
+  getFeatureGroups(): MultiMap<string, Feature> {
+    return this._featureGroupMap;
+  }
+
   getConfig(): Object {
     return this._config;
   }
@@ -254,6 +332,14 @@ export default class FeatureLoader {
     return `${this._pkgName}.use.${packageNameFromPath(feature.path)}`;
   }
 
+  useKeyPath(): string {
+    return `${this._pkgName}.use`;
+  }
+
+  useKeyPathForFeatureGroup(): string {
+    return `${this._pkgName}.enabled-feature-groups`;
+  }
+
   shouldEnable(feature: Feature): boolean {
     const name = packageNameFromPath(feature.path);
     const currentState = atom.config.get(this.useKeyPathForFeature(feature));
diff --git a/modules/nuclide-commons/collection.js b/modules/nuclide-commons/collection.js
index 9c3f1645..347c9bcb 100644
--- a/modules/nuclide-commons/collection.js
+++ b/modules/nuclide-commons/collection.js
@@ -188,7 +188,7 @@ export function setIntersect<T>(a: Set<T>, b: Set<T>): Set<T> {
   return setFilter(a, e => b.has(e));
 }
 
-export function setUnion<T>(a: Set<T>, b: Set<T>): Set<T> {
+function setUnionTwo<T>(a: Set<T>, b: Set<T>): Set<T> {
   // Avoids the extra Array allocations that `new Set([...a, ...b])` would incur. Some quick tests
   // indicate it would be about 60% slower.
   const result = new Set(a);
@@ -198,6 +198,18 @@ export function setUnion<T>(a: Set<T>, b: Set<T>): Set<T> {
   return result;
 }
 
+export function setUnion<T>(...sets: Array<Set<T>>): Set<T> {
+  if (sets.length < 1) {
+    return new Set();
+  }
+
+  const setReducer = (accumulator: Set<T>, current: Set<T>): Set<T> => {
+    return setUnionTwo(accumulator, current);
+  };
+
+  return sets.reduce(setReducer);
+}
+
 export function setDifference<T>(
   a: Set<T>,
   b: Set<T>,

From 65374e3077d215a7a4bde122cdbd7e09ca37f6c2 Mon Sep 17 00:00:00 2001
From: Erin Teo <erinteo@fb.com>
Date: Thu, 1 Mar 2018 16:21:56 -0800
Subject: [PATCH 11/15] Parse file paths in console record text and link them
 to files

Summary:
Regex matches file paths with trailing line number and column number.

Examples:
/absolute/path/with_line_number.js:42
relative/path/with_line_and_column_number.js:42:42
relative/path/with_none_of_those.js

Reviewed By: wbinnssmith

Differential Revision: D7101345

fbshipit-source-id: d422a8f8676257f5f0043788a46383b6c914f1b3
---
 .../pkg/atom-ide-console/lib/parseText.js     | 111 ++++++++++++++
 .../pkg/atom-ide-console/lib/ui/RecordView.js |  80 +---------
 .../atom-ide-console/spec/parseText-spec.js   | 137 ++++++++++++++++++
 3 files changed, 249 insertions(+), 79 deletions(-)
 create mode 100644 modules/atom-ide-ui/pkg/atom-ide-console/lib/parseText.js
 create mode 100644 modules/atom-ide-ui/pkg/atom-ide-console/spec/parseText-spec.js

diff --git a/modules/atom-ide-ui/pkg/atom-ide-console/lib/parseText.js b/modules/atom-ide-ui/pkg/atom-ide-console/lib/parseText.js
new file mode 100644
index 00000000..19ec535e
--- /dev/null
+++ b/modules/atom-ide-ui/pkg/atom-ide-console/lib/parseText.js
@@ -0,0 +1,111 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @flow
+ * @format
+ */
+
+import {goToLocation} from 'nuclide-commons-atom/go-to-location';
+import * as React from 'react';
+import featureConfig from 'nuclide-commons-atom/feature-config';
+
+import {URL_REGEX} from 'nuclide-commons/string';
+const DIFF_PATTERN = '\\b[dD][1-9][0-9]{5,}\\b';
+const TASK_PATTERN = '\\b[tT]\\d+\\b';
+const FILE_PATH_PATTERN =
+  '([/A-Za-z_-s0-9.-]+[.][A-Za-z]+)(:([0-9]+))?(:([0-9]+))?';
+const CLICKABLE_PATTERNS = `(${DIFF_PATTERN})|(${TASK_PATTERN})|(${
+  URL_REGEX.source
+})|${FILE_PATH_PATTERN}`;
+const CLICKABLE_RE = new RegExp(CLICKABLE_PATTERNS, 'g');
+
+function toString(value: mixed): string {
+  return typeof value === 'string' ? value : '';
+}
+
+/**
+ * Parse special entities into links. In the future, it would be great to add a service so that we
+ * could add new clickable things and to allow providers to mark specific ranges as links to things
+ * that only they can know (e.g. relative paths output in BUCK messages). For now, however, we'll
+ * just use some pattern settings and hardcode the patterns we care about.
+ */
+export default function parseText(
+  text: string,
+): Array<string | React.Element<any>> {
+  const chunks = [];
+  let lastIndex = 0;
+  let index = 0;
+  while (true) {
+    const match = CLICKABLE_RE.exec(text);
+    if (match == null) {
+      break;
+    }
+
+    const matchedText = match[0];
+
+    // Add all the text since our last match.
+    chunks.push(
+      text.slice(lastIndex, CLICKABLE_RE.lastIndex - matchedText.length),
+    );
+    lastIndex = CLICKABLE_RE.lastIndex;
+
+    let href;
+    let handleOnClick;
+    if (match[1] != null) {
+      // It's a diff
+      const url = toString(
+        featureConfig.get('atom-ide-console.diffUrlPattern'),
+      );
+      if (url !== '') {
+        href = url.replace('%s', matchedText);
+      }
+    } else if (match[2] != null) {
+      // It's a task
+      const url = toString(
+        featureConfig.get('atom-ide-console.taskUrlPattern'),
+      );
+      if (url !== '') {
+        href = url.replace('%s', matchedText.slice(1));
+      }
+    } else if (match[3] != null) {
+      // It's a URL
+      href = matchedText;
+    } else if (match[5] != null) {
+      // It's a file path
+      href = '#';
+      handleOnClick = () => {
+        goToLocation(match[5], {
+          line: match[7] ? parseInt(match[7], 10) - 1 : 0,
+          column: match[9] ? parseInt(match[9], 10) - 1 : 0,
+        });
+      };
+    }
+
+    chunks.push(
+      // flowlint-next-line sketchy-null-string:off
+      href ? (
+        <a
+          key={`r${index}`}
+          href={href}
+          target="_blank"
+          onClick={handleOnClick}>
+          {matchedText}
+        </a>
+      ) : (
+        matchedText
+      ),
+    );
+
+    index++;
+  }
+
+  // Add any remaining text.
+  chunks.push(text.slice(lastIndex));
+
+  return chunks;
+}
diff --git a/modules/atom-ide-ui/pkg/atom-ide-console/lib/ui/RecordView.js b/modules/atom-ide-ui/pkg/atom-ide-console/lib/ui/RecordView.js
index e3a0ed80..d5741f62 100644
--- a/modules/atom-ide-ui/pkg/atom-ide-console/lib/ui/RecordView.js
+++ b/modules/atom-ide-ui/pkg/atom-ide-console/lib/ui/RecordView.js
@@ -27,8 +27,7 @@ import shallowEqual from 'shallowequal';
 import {TextRenderer} from 'nuclide-commons-ui/TextRenderer';
 import debounce from 'nuclide-commons/debounce';
 import {nextAnimationFrame} from 'nuclide-commons/observable';
-import {URL_REGEX} from 'nuclide-commons/string';
-import featureConfig from 'nuclide-commons-atom/feature-config';
+import parseText from '../parseText';
 
 type Props = {
   displayableRecord: DisplayableRecord,
@@ -238,80 +237,3 @@ function getIconName(record: Record): ?string {
       return 'stop';
   }
 }
-
-/**
- * Parse special entities into links. In the future, it would be great to add a service so that we
- * could add new clickable things and to allow providers to mark specific ranges as links to things
- * that only they can know (e.g. relative paths output in BUCK messages). For now, however, we'll
- * just use some pattern settings and hardcode the patterns we care about.
- */
-function parseText(text: string): Array<string | React.Element<any>> {
-  const chunks = [];
-  let lastIndex = 0;
-  let index = 0;
-  while (true) {
-    const match = CLICKABLE_RE.exec(text);
-    if (match == null) {
-      break;
-    }
-
-    const matchedText = match[0];
-
-    // Add all the text since our last match.
-    chunks.push(
-      text.slice(lastIndex, CLICKABLE_RE.lastIndex - matchedText.length),
-    );
-    lastIndex = CLICKABLE_RE.lastIndex;
-
-    let href;
-    if (match[1] != null) {
-      // It's a diff
-      const url = toString(
-        featureConfig.get('atom-ide-console.diffUrlPattern'),
-      );
-      if (url !== '') {
-        href = url.replace('%s', matchedText);
-      }
-    } else if (match[2] != null) {
-      // It's a task
-      const url = toString(
-        featureConfig.get('atom-ide-console.taskUrlPattern'),
-      );
-      if (url !== '') {
-        href = url.replace('%s', matchedText.slice(1));
-      }
-    } else if (match[3] != null) {
-      // It's a URL
-      href = matchedText;
-    }
-
-    chunks.push(
-      // flowlint-next-line sketchy-null-string:off
-      href ? (
-        <a key={`r${index}`} href={href} target="_blank">
-          {matchedText}
-        </a>
-      ) : (
-        matchedText
-      ),
-    );
-
-    index++;
-  }
-
-  // Add any remaining text.
-  chunks.push(text.slice(lastIndex));
-
-  return chunks;
-}
-
-const DIFF_PATTERN = '\\b[dD][1-9][0-9]{5,}\\b';
-const TASK_PATTERN = '\\b[tT]\\d+\\b';
-const CLICKABLE_PATTERNS = `(${DIFF_PATTERN})|(${TASK_PATTERN})|${
-  URL_REGEX.source
-}`;
-const CLICKABLE_RE = new RegExp(CLICKABLE_PATTERNS, 'g');
-
-function toString(value: mixed): string {
-  return typeof value === 'string' ? value : '';
-}
diff --git a/modules/atom-ide-ui/pkg/atom-ide-console/spec/parseText-spec.js b/modules/atom-ide-ui/pkg/atom-ide-console/spec/parseText-spec.js
new file mode 100644
index 00000000..9a878e7b
--- /dev/null
+++ b/modules/atom-ide-ui/pkg/atom-ide-console/spec/parseText-spec.js
@@ -0,0 +1,137 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @flow
+ * @format
+ */
+
+import parseText from '../lib/parseText';
+
+describe('parseText', () => {
+  it('parses url pattern', () => {
+    const chunks = parseText('Message: https://facebook.com');
+    expect(chunks.length).toBe(3);
+    expect(chunks[0]).toBe('Message: ');
+    expect(chunks[2]).toBe('');
+
+    const reactElement = chunks[1];
+    expect(typeof reactElement).toBe('object'); // type React.Element
+
+    if (typeof reactElement === 'object') {
+      expect(reactElement.type).toBe('a');
+      expect(reactElement.props.href).toBe('https://facebook.com');
+      expect(reactElement.props.children).toBe('https://facebook.com');
+    }
+  });
+
+  it('parses absolute file path', () => {
+    const chunks = parseText(
+      'Message: /absolute/file/path/file.js should be parsed.',
+    );
+    expect(chunks.length).toBe(3);
+    expect(chunks[0]).toBe('Message: ');
+    expect(chunks[2]).toBe(' should be parsed.');
+
+    const reactElement = chunks[1];
+    expect(typeof reactElement).toBe('object'); // type React.Element
+
+    if (typeof reactElement === 'object') {
+      expect(reactElement.type).toBe('a');
+      expect(reactElement.props.onClick).toBeDefined();
+      expect(reactElement.props.children).toBe('/absolute/file/path/file.js');
+    }
+  });
+
+  it('parses absolute file path with line number', () => {
+    const chunks = parseText(
+      'Message: /absolute/file/path/file.js:10 should be parsed.',
+    );
+    expect(chunks.length).toBe(3);
+    expect(chunks[0]).toBe('Message: ');
+    expect(chunks[2]).toBe(' should be parsed.');
+
+    const reactElement = chunks[1];
+    expect(typeof reactElement).toBe('object'); // type React.Element
+
+    if (typeof reactElement === 'object') {
+      expect(reactElement.type).toBe('a');
+      expect(reactElement.props.onClick).toBeDefined();
+      expect(reactElement.props.children).toBe(
+        '/absolute/file/path/file.js:10',
+      );
+    }
+  });
+
+  it('parses absolute file path with line number and column number', () => {
+    const chunks = parseText(
+      'Message: /absolute/file/path/file.js:1:17 should be parsed.',
+    );
+    expect(chunks.length).toBe(3);
+    expect(chunks[0]).toBe('Message: ');
+    expect(chunks[2]).toBe(' should be parsed.');
+
+    const reactElement = chunks[1];
+    expect(typeof reactElement).toBe('object'); // type React.Element
+
+    if (typeof reactElement === 'object') {
+      expect(reactElement.type).toBe('a');
+      expect(reactElement.props.onClick).toBeDefined();
+      expect(reactElement.props.children).toBe(
+        '/absolute/file/path/file.js:1:17',
+      );
+    }
+  });
+
+  it('parses relative file path', () => {
+    const chunks = parseText('relative/path/file.js:1:17 should be parsed.');
+    expect(chunks.length).toBe(3);
+    expect(chunks[0]).toBe('');
+    expect(chunks[2]).toBe(' should be parsed.');
+
+    const reactElement = chunks[1];
+    expect(typeof reactElement).toBe('object'); // type React.Element
+
+    if (typeof reactElement === 'object') {
+      expect(reactElement.type).toBe('a');
+      expect(reactElement.props.onClick).toBeDefined();
+      expect(reactElement.props.children).toBe('relative/path/file.js:1:17');
+    }
+  });
+
+  it('parses mutliple file paths', () => {
+    const chunks = parseText(
+      'Message: relative/path/file.js:1:17 and /Absolute/path/file.file.js should be parsed.',
+    );
+    expect(chunks.length).toBe(5);
+    expect(chunks[0]).toBe('Message: ');
+    expect(chunks[2]).toBe(' and ');
+    expect(chunks[4]).toBe(' should be parsed.');
+
+    const reactElementRelative = chunks[1];
+    const reactElementAbsolute = chunks[3];
+    expect(typeof reactElementRelative).toBe('object');
+    expect(typeof reactElementAbsolute).toBe('object');
+
+    if (
+      typeof reactElementRelative === 'object' &&
+      typeof reactElementAbsolute === 'object'
+    ) {
+      expect(reactElementRelative.type).toBe('a');
+      expect(reactElementRelative.props.onClick).toBeDefined();
+      expect(reactElementRelative.props.children).toBe(
+        'relative/path/file.js:1:17',
+      );
+
+      expect(reactElementAbsolute.type).toBe('a');
+      expect(reactElementAbsolute.props.onClick).toBeDefined();
+      expect(reactElementAbsolute.props.children).toBe(
+        '/Absolute/path/file.file.js',
+      );
+    }
+  });
+});

From 2120a17e572de186ca098cde07d3a875223d2eb7 Mon Sep 17 00:00:00 2001
From: Aman Agarwal <goom@fb.com>
Date: Thu, 1 Mar 2018 18:20:26 -0800
Subject: [PATCH 12/15] Disable Clicking Stackframes if Sources are not
 Available

Summary:
If a row in the callstack doesn't have an associated source (frame.source.available is false), then do not allow it to be clickable and additionally dim that row so that it is clear it is disabled.

The dim is a very subtle effect on just the text of the row.

Reviewed By: mostafaeweda

Differential Revision: D7131270

fbshipit-source-id: 75c16d5b7500ccff96bd05421c3f25cd870db87c
---
 modules/nuclide-commons-ui/Table.js          | 10 +++++++---
 modules/nuclide-commons-ui/styles/Table.less |  4 ++++
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/modules/nuclide-commons-ui/Table.js b/modules/nuclide-commons-ui/Table.js
index 6aa01459..a19dd0b3 100644
--- a/modules/nuclide-commons-ui/Table.js
+++ b/modules/nuclide-commons-ui/Table.js
@@ -95,7 +95,7 @@ type Props<T> = {
    * Whether items can be selected.
    * If specified, `onSelect` must also be specified.
    */
-  selectable?: boolean,
+  selectable?: boolean | ((row: T) => boolean),
   selectedIndex?: ?number,
   /**
    * Handler to be called upon selection. Called iff `selectable` is `true`. We pass along the event
@@ -582,7 +582,9 @@ export class Table<T: Object> extends React.Component<Props<T>, State<T>> {
           </div>
         );
       });
-      const rowProps = selectable
+      const selectableRow =
+        typeof selectable === 'function' ? selectable(row.data) : selectable;
+      const rowProps = selectableRow
         ? {
             onClick: event => {
               switch (event.detail) {
@@ -609,7 +611,9 @@ export class Table<T: Object> extends React.Component<Props<T>, State<T>> {
         <div
           className={classnames(rowClassName, {
             'nuclide-ui-table-row': true,
-            'nuclide-ui-table-row-selectable': selectable,
+            'nuclide-ui-table-row-selectable': selectableRow,
+            'nuclide-ui-table-row-disabled':
+              typeof selectable === 'function' && !selectableRow,
             'nuclide-ui-table-row-using-keyboard-nav': this.state.usingKeyboard,
             'nuclide-ui-table-row-selected': isSelectedRow,
             'nuclide-ui-table-row-alternate':
diff --git a/modules/nuclide-commons-ui/styles/Table.less b/modules/nuclide-commons-ui/styles/Table.less
index 5cb0ab5e..02e1f58a 100644
--- a/modules/nuclide-commons-ui/styles/Table.less
+++ b/modules/nuclide-commons-ui/styles/Table.less
@@ -103,6 +103,10 @@
   color: @text-color-selected;
 }
 
+.nuclide-ui-table-row-disabled {
+  color: @text-color-subtle;
+}
+
 .nuclide-ui-table-row-selected {
   background-color: @background-color-selected;
   color: @text-color-selected;

From c18c6ded4302877223169d851f1aa85dd117c54a Mon Sep 17 00:00:00 2001
From: Mostafa Eweda <most@fb.com>
Date: Fri, 2 Mar 2018 13:57:23 -0800
Subject: [PATCH 13/15] Nuclide Vsp Debugger: Add source views with stepping,
 breakpoints & scopes

Summary: This adds read only source views (initially working with the NodeJS debugger) to be able to see the scopes, step through and set breakpoints in sources that doesn't map to files on the filesystem.

Reviewed By: ebluestein

Differential Revision: D7102789

fbshipit-source-id: 1dd7b0cae603304bc5ce1f95e1268f1745baacf2
---
 modules/nuclide-commons-ui/ReadOnlyNotice.js | 57 ++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 modules/nuclide-commons-ui/ReadOnlyNotice.js

diff --git a/modules/nuclide-commons-ui/ReadOnlyNotice.js b/modules/nuclide-commons-ui/ReadOnlyNotice.js
new file mode 100644
index 00000000..be719428
--- /dev/null
+++ b/modules/nuclide-commons-ui/ReadOnlyNotice.js
@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @flow
+ * @format
+ */
+
+import * as React from 'react';
+import {Notice} from './TextEditorBanner';
+import {Button, ButtonTypes} from './Button';
+import {MessageTypes} from './Message';
+
+type Props = {
+  detailedMessage: string,
+  canEditAnyway?: boolean,
+  onEditAnyway?: () => void,
+  onDismiss?: () => void,
+};
+
+export default class ReadOnlyNotice extends React.Component<Props> {
+  render(): React.Node {
+    let editAnywayButton;
+
+    if (this.props.canEditAnyway) {
+      editAnywayButton = (
+        <Button buttonType={ButtonTypes.INFO} onClick={this.props.onEditAnyway}>
+          Edit Anyway
+        </Button>
+      );
+    }
+
+    const dismissButton = (
+      <Button buttonType={ButtonTypes.INFO} onClick={this.props.onDismiss}>
+        Dismiss
+      </Button>
+    );
+
+    return (
+      <Notice messageType={MessageTypes.info}>
+        <span>
+          <strong>This is a read-only file.</strong>
+          <br />
+          {this.props.detailedMessage}
+        </span>
+        <div>
+          {editAnywayButton}
+          {dismissButton}
+        </div>
+      </Notice>
+    );
+  }
+}

From eeb3abe3d14da5c20849269676478664f57f0c6a Mon Sep 17 00:00:00 2001
From: Eric Bluestein <ericblue@fb.com>
Date: Fri, 2 Mar 2018 14:35:45 -0800
Subject: [PATCH 14/15] Allow error/warning/success output event types and
 fallback to console if invalid.

Summary:
We used to have a "success" log type that showed green in the console, and used to allow "warning", "info", and "error" in addition to "stdout", "stderr", "console" as valid output event types.

The VS protocol doc makes it look like the output event types are loose (the wording indicates you should be able to have others other than what is specifically defined here). Any type that VS Code doesn't understand, it still accepts, but just presents as "console".

  /** The output category. If not specified, 'console' is assumed.
      Values: 'console', 'stdout', 'stderr', 'telemetry', etc.
  */

This diff adds back our success, error, warning, info support, and also falls back to "console" for event types we don't understand, rather than simply not rendering them.

This also removes splitStream because it was breaking single output events into multiple output events, and failing to output any event that didn't end in a \n

Reviewed By: mostafaeweda

Differential Revision: D7112173

fbshipit-source-id: 47b0c6255a0a9e5d45b29c761a33e8e8738a7337
---
 modules/atom-ide-ui/pkg/atom-ide-console/lib/main.js  | 3 +++
 modules/atom-ide-ui/pkg/atom-ide-console/lib/types.js | 1 +
 2 files changed, 4 insertions(+)

diff --git a/modules/atom-ide-ui/pkg/atom-ide-console/lib/main.js b/modules/atom-ide-ui/pkg/atom-ide-console/lib/main.js
index f3f1d4e7..1eda6a26 100644
--- a/modules/atom-ide-ui/pkg/atom-ide-console/lib/main.js
+++ b/modules/atom-ide-ui/pkg/atom-ide-console/lib/main.js
@@ -231,6 +231,9 @@ class Activation {
         info(object: string): void {
           console.append({text: object, level: 'info'});
         },
+        success(object: string): void {
+          console.append({text: object, level: 'success'});
+        },
         append(message: Message): void {
           invariant(activation != null && !disposed);
           activation._getStore().dispatch(
diff --git a/modules/atom-ide-ui/pkg/atom-ide-console/lib/types.js b/modules/atom-ide-ui/pkg/atom-ide-console/lib/types.js
index 812478f2..cd5a52d8 100644
--- a/modules/atom-ide-ui/pkg/atom-ide-console/lib/types.js
+++ b/modules/atom-ide-ui/pkg/atom-ide-console/lib/types.js
@@ -27,6 +27,7 @@ export type ConsoleApi = {
   error(object: string, _: void): void,
   warn(object: string, _: void): void,
   info(object: string, _: void): void,
+  success(object: string, _: void): void,
 
   // A generic API for sending a message of any level (log, error, etc.).
   append(message: Message): void,

From 5ed276620c2c89d6e8ba2527e48f2bcfcdc4f05a Mon Sep 17 00:00:00 2001
From: Will Pitts <wipi@fb.com>
Date: Sat, 3 Mar 2018 13:48:55 -0800
Subject: [PATCH 15/15] Add getSuggestionDetailsOnSelect support to Nuclide.

Summary: In 1.24, Atom added support for the `getSuggestionDetailsOnSelect` function in its autocomplete config, which runs asynchronously and fetches more information about the currently selected autocomplete item.  This change adds support for that to Nuclide.

Reviewed By: hansonw

Differential Revision: D7070208

fbshipit-source-id: f52a9ea1be44a79d7b7dc77660bd09347409320f
---
 flow-libs/atom.js.flow | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/flow-libs/atom.js.flow b/flow-libs/atom.js.flow
index cc9f6204..c9ca8232 100644
--- a/flow-libs/atom.js.flow
+++ b/flow-libs/atom.js.flow
@@ -2049,6 +2049,9 @@ type atom$AutocompleteProvider = {
   +getSuggestions: (
     request: atom$AutocompleteRequest,
   ) => Promise<?Array<atom$AutocompleteSuggestion>> | ?Array<atom$AutocompleteSuggestion>,
+  +getSuggestionDetailsOnSelect?: (
+    suggestion: atom$AutocompleteSuggestion
+  ) => Promise<?atom$AutocompleteSuggestion>,
   +disableForSelector?: string,
   +inclusionPriority?: number,
   +excludeLowerPriority?: boolean,